diff options
Diffstat (limited to 'omegalib/code_gen/src')
| -rw-r--r-- | omegalib/code_gen/src/CG.cc | 1163 | ||||
| -rw-r--r-- | omegalib/code_gen/src/CG_roseBuilder.cc | 1533 | ||||
| -rw-r--r-- | omegalib/code_gen/src/CG_roseRepr.cc | 176 | ||||
| -rw-r--r-- | omegalib/code_gen/src/CG_stringBuilder.cc | 487 | ||||
| -rw-r--r-- | omegalib/code_gen/src/CG_stringRepr.cc | 54 | ||||
| -rw-r--r-- | omegalib/code_gen/src/CG_suifBuilder.cc | 678 | ||||
| -rw-r--r-- | omegalib/code_gen/src/CG_suifRepr.cc | 81 | ||||
| -rwxr-xr-x | omegalib/code_gen/src/CG_utils.cc | 1735 | ||||
| -rw-r--r-- | omegalib/code_gen/src/code_gen.cc | 656 | ||||
| -rwxr-xr-x | omegalib/code_gen/src/codegen.cc | 378 | ||||
| -rw-r--r-- | omegalib/code_gen/src/cscope.out | 89773 | ||||
| -rw-r--r-- | omegalib/code_gen/src/output_repr.cc | 1931 | ||||
| -rw-r--r-- | omegalib/code_gen/src/rose_attributes.cc | 183 | ||||
| -rw-r--r-- | omegalib/code_gen/src/tags | 158 |
14 files changed, 98986 insertions, 0 deletions
diff --git a/omegalib/code_gen/src/CG.cc b/omegalib/code_gen/src/CG.cc new file mode 100644 index 0000000..42bd172 --- /dev/null +++ b/omegalib/code_gen/src/CG.cc @@ -0,0 +1,1163 @@ +/***************************************************************************** + Copyright (C) 1994-2000 the Omega Project Team + Copyright (C) 2005-2011 Chun Chen + All Rights Reserved. + + Purpose: + CG node classes, used to build AST tree from polyhedra scanning. + + Notes: + Parameter "restriction" is always tighter than "known" since CG_split + node does not correspond to any code for enforcement. This property is + destroyed after hoistGuard since "restriction" is not used anymore. + CG node's children are guaranteed not to be NULL, either NULL child is + removed from the children or the parent node itself becomes NULL. + + History: + 04/20/96 printRepr added by D people. Lei Zhou + 10/24/06 hoistGuard added by chun + 08/03/10 collect CG classes into one place, by Chun Chen + 08/04/10 track dynamically substituted variables in printRepr, by chun + 04/02/11 rewrite the CG node classes, by chun + *****************************************************************************/ + +#include <typeinfo> +#include <assert.h> +#include <omega.h> +#include <code_gen/codegen.h> +#include <code_gen/CG.h> +#include <code_gen/CG_outputBuilder.h> +#include <code_gen/CG_stringBuilder.h> +#include <code_gen/CG_utils.h> +#include <code_gen/codegen_error.h> +#include <stack> +#include <string.h> + +namespace omega { + +extern std::vector<std::vector<int> > smtNonSplitLevels; +extern std::vector<std::vector<std::string> > loopIdxNames; //per stmt +extern std::vector<std::pair<int, std::string> > syncs; + +extern int checkLoopLevel; +extern int stmtForLoopCheck; +extern int upperBoundForLevel; +extern int lowerBoundForLevel; +extern bool fillInBounds; + +//----------------------------------------------------------------------------- +// Class: CG_result +//----------------------------------------------------------------------------- + +CG_outputRepr *CG_result::printRepr(CG_outputBuilder *ocg, + const std::vector<CG_outputRepr *> &stmts) const { + return printRepr(1, ocg, stmts, + std::vector<std::pair<CG_outputRepr *, int> >(num_level(), + std::make_pair(static_cast<CG_outputRepr *>(NULL), 0))); +} + +std::string CG_result::printString() const { + CG_stringBuilder ocg; + std::vector<CG_outputRepr *> stmts(codegen_->xforms_.size()); + for (int i = 0; i < stmts.size(); i++) + stmts[i] = new CG_stringRepr("s" + to_string(i)); + CG_stringRepr *repr = static_cast<CG_stringRepr *>(printRepr(&ocg, stmts)); + for (int i = 0; i < stmts.size(); i++) + delete stmts[i]; + + if (repr != NULL) { + std::string s = repr->GetString(); + delete repr; + return s; + } else + return std::string(); +} + +int CG_result::num_level() const { + return codegen_->num_level(); +} + +//----------------------------------------------------------------------------- +// Class: CG_split +//----------------------------------------------------------------------------- + +CG_result *CG_split::recompute(const BoolSet<> &parent_active, + const Relation &known, const Relation &restriction) { + active_ &= parent_active; + if (active_.empty()) { + delete this; + return NULL; + } + + + int i = 0; + while (i < restrictions_.size()) { + Relation new_restriction = Intersection(copy(restrictions_[i]), + copy(restriction)); + + new_restriction.simplify(2, 4); + //new_restriction.simplify(); + clauses_[i] = clauses_[i]->recompute(active_, copy(known), + new_restriction); + if (clauses_[i] == NULL) { + restrictions_.erase(restrictions_.begin() + i); + clauses_.erase(clauses_.begin() + i); + } else + i++; + } + + + if (restrictions_.size() == 0) { + delete this; + return NULL; + } else + return this; +} + +int CG_split::populateDepth() { + int max_depth = 0; + for (int i = 0; i < clauses_.size(); i++) { + int t = clauses_[i]->populateDepth(); + if (t > max_depth) + max_depth = t; + } + return max_depth; +} + +std::pair<CG_result *, Relation> CG_split::liftOverhead(int depth, + bool propagate_up) { + for (int i = 0; i < clauses_.size();) { + std::pair<CG_result *, Relation> result = clauses_[i]->liftOverhead( + depth, propagate_up); + if (result.first == NULL) + clauses_.erase(clauses_.begin() + i); + else { + clauses_[i] = result.first; + if (!result.second.is_obvious_tautology()) + return std::make_pair(this, result.second); + i++; + } + + } + + if (clauses_.size() == 0) { + delete this; + return std::make_pair(static_cast<CG_result *>(NULL), + Relation::True(num_level())); + } else + return std::make_pair(this, Relation::True(num_level())); +} + +Relation CG_split::hoistGuard() { + std::vector<Relation> guards; + for (int i = 0; i < clauses_.size(); i++) + guards.push_back(clauses_[i]->hoistGuard()); + + return SimpleHull(guards, true, true); +} + +void CG_split::removeGuard(const Relation &guard) { + for (int i = 0; i < clauses_.size(); i++) + clauses_[i]->removeGuard(guard); +} + +std::vector<CG_result *> CG_split::findNextLevel() const { + std::vector<CG_result *> result; + for (int i = 0; i < clauses_.size(); i++) { + CG_split *splt = dynamic_cast<CG_split *>(clauses_[i]); + if (splt != NULL) { + std::vector<CG_result *> t = splt->findNextLevel(); + result.insert(result.end(), t.begin(), t.end()); + } else + result.push_back(clauses_[i]); + } + + return result; +} + +CG_outputRepr *CG_split::printRepr(int indent, CG_outputBuilder *ocg, + const std::vector<CG_outputRepr *> &stmts, + const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) const { + CG_outputRepr *stmtList = NULL; + std::vector<CG_result *> next_level = findNextLevel(); + + std::vector<CG_loop *> cur_loops; + for (int i = 0; i < next_level.size(); i++) { + CG_loop *lp = dynamic_cast<CG_loop *>(next_level[i]); + if (lp != NULL) { + cur_loops.push_back(lp); + } else { + stmtList = ocg->StmtListAppend(stmtList, + loop_print_repr(cur_loops, 0, cur_loops.size(), + Relation::True(num_level()), NULL, indent, ocg, + stmts, assigned_on_the_fly)); + stmtList = ocg->StmtListAppend(stmtList, + next_level[i]->printRepr(indent, ocg, stmts, + assigned_on_the_fly)); + cur_loops.clear(); + } + } + + stmtList = ocg->StmtListAppend(stmtList, + loop_print_repr(cur_loops, 0, cur_loops.size(), + Relation::True(num_level()), NULL, indent, ocg, stmts, + assigned_on_the_fly)); + return stmtList; +} + +CG_result *CG_split::clone() const { + std::vector<CG_result *> clauses(clauses_.size()); + for (int i = 0; i < clauses_.size(); i++) + clauses[i] = clauses_[i]->clone(); + return new CG_split(codegen_, active_, restrictions_, clauses); +} + +void CG_split::dump(int indent) const { + std::string prefix; + for (int i = 0; i < indent; i++) + prefix += " "; + std::cout << prefix << "SPLIT: " << active_ << std::endl; + for (int i = 0; i < restrictions_.size(); i++) { + std::cout << prefix << "restriction: "; + const_cast<CG_split *>(this)->restrictions_[i].print(); + clauses_[i]->dump(indent + 1); + } + +} + +//----------------------------------------------------------------------------- +// Class: CG_loop +//----------------------------------------------------------------------------- + +CG_result *CG_loop::recompute(const BoolSet<> &parent_active, + const Relation &known, const Relation &restriction) { + known_ = copy(known); + restriction_ = copy(restriction); + active_ &= parent_active; + + std::vector<Relation> Rs; + for (BoolSet<>::iterator i = active_.begin(); i != active_.end(); i++) { + Relation r = Intersection(copy(restriction), + copy(codegen_->projected_IS_[level_ - 1][*i])); + + //r.simplify(2, 4); + r.simplify(); + if (!r.is_upper_bound_satisfiable()) { + active_.unset(*i); + continue; + } + Rs.push_back(copy(r)); + } + + if (active_.empty()) { + delete this; + return NULL; + } + + Relation hull = SimpleHull(Rs, true, true); + + //hull.simplify(2,4); + + // check if actual loop is needed + std::pair<EQ_Handle, int> result = find_simplest_assignment(hull, + hull.set_var(level_)); + if (result.second < INT_MAX) { + needLoop_ = false; + + bounds_ = Relation(hull.n_set()); + F_Exists *f_exists = bounds_.add_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map<Variable_ID, Variable_ID> exists_mapping; + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(result.first); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h.update_coef(bounds_.input_var(v->get_position()), + cvi.curr_coef()); + break; + case Wildcard_Var: { + Variable_ID v2 = replicate_floor_definition(hull, v, bounds_, + f_exists, f_root, exists_mapping); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = bounds_.get_local(g); + else + v2 = bounds_.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const(result.first.get_const()); + bounds_.simplify(); + } + // loop iterates more than once, extract bounds now + else { + needLoop_ = true; + + bounds_ = Relation(hull.n_set()); + F_Exists *f_exists = bounds_.add_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map<Variable_ID, Variable_ID> exists_mapping; + + Relation b = Gist(copy(hull), copy(known), 1); + bool has_unresolved_bound = false; + + std::set<Variable_ID> excluded_floor_vars; + excluded_floor_vars.insert(b.set_var(level_)); + for (GEQ_Iterator e(b.single_conjunct()->GEQs()); e; e++) + if ((*e).get_coef(b.set_var(level_)) != 0) { + bool is_bound = true; + for (Constr_Vars_Iter cvi(*e, true); cvi; cvi++) { + std::pair<bool, GEQ_Handle> result = find_floor_definition( + b, cvi.curr_var(), excluded_floor_vars); + if (!result.first) { + is_bound = false; + has_unresolved_bound = true; + break; + } + } + + if (!is_bound) + continue; + + GEQ_Handle h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h.update_coef(bounds_.input_var(v->get_position()), + cvi.curr_coef()); + break; + case Wildcard_Var: { + Variable_ID v2 = replicate_floor_definition(b, v, + bounds_, f_exists, f_root, exists_mapping); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = bounds_.get_local(g); + else + v2 = bounds_.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const((*e).get_const()); + } + + if (has_unresolved_bound) { + b = Approximate(b); + b.simplify(2, 4); + //Simplification of Hull + hull = Approximate(hull); + hull.simplify(2, 4); + //end : Anand + for (GEQ_Iterator e(b.single_conjunct()->GEQs()); e; e++) + if ((*e).get_coef(b.set_var(level_)) != 0) + f_root->add_GEQ(*e); + } + bounds_.simplify(); + hull.simplify(2,4); + // Since current SimpleHull does not support max() upper bound or min() lower bound, + // we have to forcefully split the loop when hull approximation does not return any bound. + bool has_lb = false; + bool has_ub = false; + for (GEQ_Iterator e = bounds_.single_conjunct()->GEQs(); e; e++) { + if ((*e).get_coef(bounds_.set_var(level_)) > 0) + has_lb = true; + else if ((*e).get_coef(bounds_.set_var(level_)) < 0) + has_ub = true; + if (has_lb && has_ub) + break; + } + + if (!has_lb) { + for (int i = 0; i < Rs.size(); i++) { + Relation r = Approximate(copy(Rs[i])); + r.simplify(2, 4); + for (GEQ_Iterator e = r.single_conjunct()->GEQs(); e; e++) + if ((*e).get_coef(r.input_var(level_)) > 0) { + Relation r2 = Relation::True(num_level()); + r2.and_with_GEQ(*e); + r2.simplify(); + std::vector<Relation> restrictions(2); + restrictions[0] = Complement(copy(r2)); + restrictions[0].simplify(); + restrictions[1] = r2; + std::vector<CG_result *> clauses(2); + clauses[0] = this; + clauses[1] = this->clone(); + CG_result *cgr = new CG_split(codegen_, active_, + restrictions, clauses); + cgr = cgr->recompute(active_, copy(known), + copy(restriction)); + return cgr; + } + } + for (int i = 0; i < Rs.size(); i++) { + Relation r = Approximate(copy(Rs[i])); + r.simplify(2, 4); + for (EQ_Iterator e = r.single_conjunct()->EQs(); e; e++) + if ((*e).get_coef(r.input_var(level_)) != 0) { + Relation r2 = Relation::True(num_level()); + r2.and_with_GEQ(*e); + r2.simplify(); + std::vector<Relation> restrictions(2); + if ((*e).get_coef(r.input_var(level_)) > 0) { + restrictions[0] = Complement(copy(r2)); + restrictions[0].simplify(); + restrictions[1] = r2; + } else { + restrictions[0] = r2; + restrictions[1] = Complement(copy(r2)); + restrictions[1].simplify(); + } + std::vector<CG_result *> clauses(2); + clauses[0] = this; + clauses[1] = this->clone(); + CG_result *cgr = new CG_split(codegen_, active_, + restrictions, clauses); + cgr = cgr->recompute(active_, copy(known), + copy(restriction)); + return cgr; + } + } + } else if (!has_ub) { + for (int i = 0; i < Rs.size(); i++) { + Relation r = Approximate(copy(Rs[i])); + r.simplify(2, 4); + for (GEQ_Iterator e = r.single_conjunct()->GEQs(); e; e++) + if ((*e).get_coef(r.input_var(level_)) < 0) { + Relation r2 = Relation::True(num_level()); + r2.and_with_GEQ(*e); + r2.simplify(); + std::vector<Relation> restrictions(2); + restrictions[1] = Complement(copy(r2)); + restrictions[1].simplify(); + restrictions[0] = r2; + std::vector<CG_result *> clauses(2); + clauses[0] = this; + clauses[1] = this->clone(); + CG_result *cgr = new CG_split(codegen_, active_, + restrictions, clauses); + cgr = cgr->recompute(active_, copy(known), + copy(restriction)); + return cgr; + } + } + for (int i = 0; i < Rs.size(); i++) { + Relation r = Approximate(copy(Rs[i])); + r.simplify(2, 4); + for (EQ_Iterator e = r.single_conjunct()->EQs(); e; e++) + if ((*e).get_coef(r.input_var(level_)) != 0) { + Relation r2 = Relation::True(num_level()); + r2.and_with_GEQ(*e); + r2.simplify(); + std::vector<Relation> restrictions(2); + if ((*e).get_coef(r.input_var(level_)) > 0) { + restrictions[0] = Complement(copy(r2)); + restrictions[0].simplify(); + restrictions[1] = r2; + } else { + restrictions[0] = r2; + restrictions[1] = Complement(copy(r2)); + restrictions[1].simplify(); + } + std::vector<CG_result *> clauses(2); + clauses[0] = this; + clauses[1] = this->clone(); + CG_result *cgr = new CG_split(codegen_, active_, + restrictions, clauses); + cgr = cgr->recompute(active_, copy(known), + copy(restriction)); + return cgr; + } + } + } + + if (!has_lb && !has_ub) + throw codegen_error( + "can't find any bound at loop level " + to_string(level_)); + else if (!has_lb) + throw codegen_error( + "can't find lower bound at loop level " + + to_string(level_)); + else if (!has_ub) + throw codegen_error( + "can't find upper bound at loop level " + + to_string(level_)); + } + bounds_.copy_names(hull); + bounds_.setup_names(); + + // additional guard/stride condition extraction + if (needLoop_) { + Relation cur_known = Intersection(copy(bounds_), copy(known_)); + cur_known.simplify(); + hull = Gist(hull, copy(cur_known), 1); + + std::pair<EQ_Handle, Variable_ID> result = find_simplest_stride(hull, + hull.set_var(level_)); + if (result.second != NULL) + if (abs(result.first.get_coef(hull.set_var(level_))) == 1) { + F_Exists *f_exists = bounds_.and_with_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map<Variable_ID, Variable_ID> exists_mapping; + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(result.first); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h.update_coef(bounds_.input_var(v->get_position()), + cvi.curr_coef()); + break; + case Wildcard_Var: { + Variable_ID v2; + if (v == result.second) + v2 = f_exists->declare(); + else + v2 = replicate_floor_definition(hull, v, bounds_, + f_exists, f_root, exists_mapping); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = bounds_.get_local(g); + else + v2 = bounds_.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const(result.first.get_const()); + } else { + // since gist is not powerful enough on modular constraints for now, + // make an educated guess + coef_t stride = abs(result.first.get_coef(result.second)) + / gcd(abs(result.first.get_coef(result.second)), + abs( + result.first.get_coef( + hull.set_var(level_)))); + + Relation r1(hull.n_inp()); + F_Exists *f_exists = r1.add_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map<Variable_ID, Variable_ID> exists_mapping; + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(result.first); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h.update_coef(r1.input_var(v->get_position()), + cvi.curr_coef()); + break; + case Wildcard_Var: { + Variable_ID v2; + if (v == result.second) + v2 = f_exists->declare(); + else + v2 = replicate_floor_definition(hull, v, r1, + f_exists, f_root, exists_mapping); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r1.get_local(g); + else + v2 = r1.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const(result.first.get_const()); + r1.simplify(); + + bool guess_success = false; + for (GEQ_Iterator e(bounds_.single_conjunct()->GEQs()); e; e++) + if ((*e).get_coef(bounds_.set_var(level_)) == 1) { + Relation r2(hull.n_inp()); + F_Exists *f_exists = r2.add_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map<Variable_ID, Variable_ID> exists_mapping; + EQ_Handle h = f_root->add_EQ(); + h.update_coef(f_exists->declare(), stride); + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h.update_coef(r2.input_var(v->get_position()), + cvi.curr_coef()); + break; + case Wildcard_Var: { + Variable_ID v2 = replicate_floor_definition( + hull, v, r2, f_exists, f_root, + exists_mapping); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r2.get_local(g); + else + v2 = r2.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const((*e).get_const()); + r2.simplify(); + + if (Gist(copy(r1), + Intersection(copy(cur_known), copy(r2)), 1).is_obvious_tautology() + && Gist(copy(r2), + Intersection(copy(cur_known), copy(r1)), + 1).is_obvious_tautology()) { + bounds_ = Intersection(bounds_, r2); + bounds_.simplify(); + guess_success = true; + break; + } + } + + // this is really a stride with non-unit coefficient for this loop variable + if (!guess_success) { + // TODO: for stride ax = b mod n it might be beneficial to + // generate modular linear equation solver code for + // runtime to get the starting position in printRepr, + // and stride would be n/gcd(|a|,n), thus this stride + // can be put into bounds_ too. + } + + } + + hull = Project(hull, hull.set_var(level_)); + hull.simplify(2, 4); + guard_ = Gist(hull, Intersection(copy(bounds_), copy(known_)), 1); + } + // don't generate guard for non-actual loop, postpone it. otherwise + // redundant if-conditions might be generated since for-loop semantics + // includes implicit comparison checking. -- by chun 09/14/10 + else + guard_ = Relation::True(num_level()); + guard_.copy_names(bounds_); + guard_.setup_names(); + + //guard_.simplify(); + // recursively down the AST + Relation new_known = Intersection(copy(known), + Intersection(copy(bounds_), copy(guard_))); + new_known.simplify(2, 4); + Relation new_restriction = Intersection(copy(restriction), + Intersection(copy(bounds_), copy(guard_))); + new_restriction.simplify(2, 4); + body_ = body_->recompute(active_, new_known, new_restriction); + if (body_ == NULL) { + delete this; + return NULL; + } else + return this; +} + +int CG_loop::populateDepth() { + int depth = body_->populateDepth(); + if (needLoop_) + depth_ = depth + 1; + else + depth_ = depth; + return depth_; +} + +std::pair<CG_result *, Relation> CG_loop::liftOverhead(int depth, + bool propagate_up) { + if (depth_ > depth) { + assert(propagate_up == false); + std::pair<CG_result *, Relation> result = body_->liftOverhead(depth, + false); + body_ = result.first; + return std::make_pair(this, Relation::True(num_level())); + } else { // (depth_ <= depth) + if (propagate_up) { + Relation r = pick_one_guard(guard_, level_); + if (!r.is_obvious_tautology()) + return std::make_pair(this, r); + } + + std::pair<CG_result *, Relation> result; + if (propagate_up || needLoop_) + result = body_->liftOverhead(depth, true); + else + result = body_->liftOverhead(depth, false); + body_ = result.first; + if (result.second.is_obvious_tautology()) + return std::make_pair(this, result.second); + + // loop is an assignment, replace this loop variable in overhead condition + if (!needLoop_) { + result.second = Intersection(result.second, copy(bounds_)); + result.second = Project(result.second, + result.second.set_var(level_)); + result.second.simplify(2, 4); + } + + + int max_level = 0; + bool has_wildcard = false; + bool direction = true; + for (EQ_Iterator e(result.second.single_conjunct()->EQs()); e; e++) + if ((*e).has_wildcards()) { + if (has_wildcard) + assert(false); + else + has_wildcard = true; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var()->kind() == Input_Var + && cvi.curr_var()->get_position() > max_level) + max_level = cvi.curr_var()->get_position(); + } else + assert(false); + + if (!has_wildcard) { + int num_simple_geq = 0; + for (GEQ_Iterator e(result.second.single_conjunct()->GEQs()); e; + e++) + if (!(*e).has_wildcards()) { + num_simple_geq++; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var()->kind() == Input_Var + && cvi.curr_var()->get_position() > max_level) { + max_level = cvi.curr_var()->get_position(); + direction = (cvi.curr_coef() < 0) ? true : false; + } + } else { + has_wildcard = true; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var()->kind() == Input_Var + && cvi.curr_var()->get_position() > max_level) { + max_level = cvi.curr_var()->get_position(); + } + } + assert( + (has_wildcard && num_simple_geq == 0) || (!has_wildcard && num_simple_geq == 1)); + } + + // check if this is the top loop level for splitting for this overhead + if (!propagate_up || (has_wildcard && max_level == level_ - 1) + || (!has_wildcard && max_level == level_)) { + std::vector<Relation> restrictions(2); + std::vector<CG_result *> clauses(2); + int saved_num_level = num_level(); + if (has_wildcard || direction) { + restrictions[1] = Complement(copy(result.second)); + restrictions[1].simplify(); + clauses[1] = this->clone(); + restrictions[0] = result.second; + clauses[0] = this; + } else { + restrictions[0] = Complement(copy(result.second)); + restrictions[0].simplify(); + clauses[0] = this->clone(); + restrictions[1] = result.second; + clauses[1] = this; + } + CG_result *cgr = new CG_split(codegen_, active_, restrictions, + clauses); + CG_result *new_cgr = cgr->recompute(active_, copy(known_), + copy(restriction_)); + new_cgr->populateDepth(); + assert(new_cgr==cgr); + if (static_cast<CG_split *>(new_cgr)->clauses_.size() == 1) + // infinite recursion detected, bail out + return std::make_pair(new_cgr, Relation::True(saved_num_level)); + else + return cgr->liftOverhead(depth, propagate_up); + } else + return std::make_pair(this, result.second); + } +} + +Relation CG_loop::hoistGuard() { + + Relation r = body_->hoistGuard(); + + // TODO: should bookkeep catched contraints in loop output as enforced and check if anything missing + // if (!Gist(copy(b), copy(enforced)).is_obvious_tautology()) { + // fprintf(stderr, "need to generate extra guard inside the loop\n"); + // } + + if (!needLoop_) + r = Intersection(r, copy(bounds_)); + r = Project(r, r.set_var(level_)); + r = Gist(r, copy(known_), 1); + + Relation eliminate_existentials_r; + Relation eliminate_existentials_known; + + eliminate_existentials_r = copy(r); + if (!r.is_obvious_tautology()) { + eliminate_existentials_r = Approximate(copy(r)); + eliminate_existentials_r.simplify(2,4); + eliminate_existentials_known = Approximate(copy(known_)); + eliminate_existentials_known.simplify(2,4); + + eliminate_existentials_r = Gist( eliminate_existentials_r, eliminate_existentials_known, 1); + } + + + if (!eliminate_existentials_r.is_obvious_tautology()) { + // if (!r.is_obvious_tautology()) { + body_->removeGuard(r); + guard_ = Intersection(guard_, copy(r)); + guard_.simplify(); + } + + return guard_; + + // return ifList; + // } + + +} + +void CG_loop::removeGuard(const Relation &guard) { + known_ = Intersection(known_, copy(guard)); + known_.simplify(); + + guard_ = Gist(guard_, copy(known_), 1); + guard_.copy_names(known_); + guard_.setup_names(); +} + +CG_outputRepr *CG_loop::printRepr(int indent, CG_outputBuilder *ocg, + const std::vector<CG_outputRepr *> &stmts, + const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) const { + return printRepr(true, indent, ocg, stmts, assigned_on_the_fly); +} + +CG_outputRepr *CG_loop::printRepr(bool do_print_guard, int indent, + CG_outputBuilder *ocg, const std::vector<CG_outputRepr *> &stmts, + const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) const { + CG_outputRepr *guardRepr; + if (do_print_guard) + guardRepr = output_guard(ocg, guard_, assigned_on_the_fly); + else + guardRepr = NULL; + + Relation cur_known = Intersection(copy(known_), copy(guard_)); + cur_known.simplify(); + if (needLoop_) { + + if (checkLoopLevel) + if (level_ == checkLoopLevel) + if (active_.get(stmtForLoopCheck)) + fillInBounds = true; + + CG_outputRepr *ctrlRepr = output_loop(ocg, bounds_, level_, cur_known, + assigned_on_the_fly); + + fillInBounds = false; + + CG_outputRepr *bodyRepr = body_->printRepr( + (guardRepr == NULL) ? indent + 1 : indent + 2, ocg, stmts, + assigned_on_the_fly); + CG_outputRepr * loopRepr; + + if (guardRepr == NULL) + loopRepr = ocg->CreateLoop(indent, ctrlRepr, bodyRepr); + else + loopRepr = ocg->CreateLoop(indent + 1, ctrlRepr, bodyRepr); + + if (!smtNonSplitLevels.empty()) { + bool blockLoop = false; + bool threadLoop = false; + bool sync = false; + int firstActiveStmt = -1; + for (int s = 0; s < active_.size(); s++) { + if (active_.get(s)) { + if (firstActiveStmt < 0) + firstActiveStmt = s; + //We assume smtNonSplitLevels is only used to mark the first of + //the block or thread loops to be reduced in CUDA-CHiLL. Here we + //place some comments to help with final code generation. + //int idx = smtNonSplitLevels[s].index(level_); + + if (s < smtNonSplitLevels.size()) { + if (smtNonSplitLevels[s].size() > 0) + if (smtNonSplitLevels[s][0] == level_) { + blockLoop = true; + } + //Assume every stmt marked with a thread loop index also has a block loop idx + if (smtNonSplitLevels[s].size() > 1) + if (smtNonSplitLevels[s][1] == level_) { + threadLoop = true; + } + } + } + } + if (blockLoop && threadLoop) { + fprintf(stderr, + "Warning, have %d level more than once in smtNonSplitLevels\n", + level_); + threadLoop = false; + } + std::string preferredIdx; + if (loopIdxNames.size() + && (level_ / 2) - 1 < loopIdxNames[firstActiveStmt].size()) + preferredIdx = loopIdxNames[firstActiveStmt][(level_ / 2) - 1]; + for (int s = 0; s < active_.size(); s++) { + if (active_.get(s)) { + for (int i = 0; i < syncs.size(); i++) { + if (syncs[i].first == s + && strcmp(syncs[i].second.c_str(), + preferredIdx.c_str()) == 0) { + sync = true; + //printf("FOUND SYNC\n"); + } + + } + } + + } + if (threadLoop || blockLoop || preferredIdx.length() != 0) { + char buf[1024]; + std::string loop; + if (blockLoop) + loop = "blockLoop "; + if (threadLoop) + loop = "threadLoop "; + if (preferredIdx.length() != 0 && sync) { + sprintf(buf, "~cuda~ %spreferredIdx: %s sync", loop.c_str(), + preferredIdx.c_str()); + } else if (preferredIdx.length() != 0) { + sprintf(buf, "~cuda~ %spreferredIdx: %s", loop.c_str(), + preferredIdx.c_str()); + } else { + sprintf(buf, "~cuda~ %s", loop.c_str()); + } + + + loopRepr = ocg->CreateAttribute(loopRepr, buf); + } + + } + if (guardRepr == NULL) + return loopRepr; + else + return ocg->CreateIf(indent, guardRepr, loopRepr, NULL); + } else { + std::pair<CG_outputRepr *, std::pair<CG_outputRepr *, int> > result = + output_assignment(ocg, bounds_, level_, cur_known, + assigned_on_the_fly); + guardRepr = ocg->CreateAnd(guardRepr, result.first); + + if (result.second.second < CodeGen::var_substitution_threshold) { + std::vector<std::pair<CG_outputRepr *, int> > atof = + assigned_on_the_fly; + atof[level_ - 1] = result.second; + CG_outputRepr *bodyRepr = body_->printRepr( + (guardRepr == NULL) ? indent : indent + 1, ocg, stmts, + atof); + delete atof[level_ - 1].first; + if (guardRepr == NULL) + return bodyRepr; + else + return ocg->CreateIf(indent, guardRepr, bodyRepr, NULL); + } else { + CG_outputRepr *assignRepr = ocg->CreateAssignment( + (guardRepr == NULL) ? indent : indent + 1, + output_ident(ocg, bounds_, + const_cast<CG_loop *>(this)->bounds_.set_var( + level_), assigned_on_the_fly), + result.second.first); + CG_outputRepr *bodyRepr = body_->printRepr( + (guardRepr == NULL) ? indent : indent + 1, ocg, stmts, + assigned_on_the_fly); + if (guardRepr == NULL) + return ocg->StmtListAppend(assignRepr, bodyRepr); + else + return ocg->CreateIf(indent, guardRepr, + ocg->StmtListAppend(assignRepr, bodyRepr), NULL); + } + + } +} + +CG_result *CG_loop::clone() const { + return new CG_loop(codegen_, active_, level_, body_->clone()); +} + +void CG_loop::dump(int indent) const { + std::string prefix; + for (int i = 0; i < indent; i++) + prefix += " "; + std::cout << prefix << "LOOP (level " << level_ << "): " << active_ + << std::endl; + std::cout << prefix << "known: "; + const_cast<CG_loop *>(this)->known_.print(); + std::cout << prefix << "restriction: "; + const_cast<CG_loop *>(this)->restriction_.print(); + std::cout << prefix << "bounds: "; + const_cast<CG_loop *>(this)->bounds_.print(); + std::cout << prefix << "guard: "; + const_cast<CG_loop *>(this)->guard_.print(); + body_->dump(indent + 1); +} + +//----------------------------------------------------------------------------- +// Class: CG_leaf +//----------------------------------------------------------------------------- + +CG_result* CG_leaf::recompute(const BoolSet<> &parent_active, + const Relation &known, const Relation &restriction) { + active_ &= parent_active; + known_ = copy(known); + + guards_.clear(); + for (BoolSet<>::iterator i = active_.begin(); i != active_.end(); i++) { + Relation r = Intersection( + copy(codegen_->projected_IS_[num_level() - 1][*i]), + copy(restriction)); + r.simplify(2, 4); + if (!r.is_upper_bound_satisfiable()) + active_.unset(*i); + else { + r = Gist(r, copy(known), 1); + if (!r.is_obvious_tautology()) { + guards_[*i] = r; + guards_[*i].copy_names(known); + guards_[*i].setup_names(); + } + } + } + + + if (active_.empty()) { + delete this; + return NULL; + } else + return this; +} + +std::pair<CG_result *, Relation> CG_leaf::liftOverhead(int depth, bool) { + if (depth == 0) + return std::make_pair(this, Relation::True(num_level())); + + for (std::map<int, Relation>::iterator i = guards_.begin(); + i != guards_.end(); i++) { + Relation r = pick_one_guard(i->second); + if (!r.is_obvious_tautology()) { + bool has_wildcard = false; + int max_level = 0; + for (EQ_Iterator e(r.single_conjunct()->EQs()); e; e++) { + if ((*e).has_wildcards()) + has_wildcard = true; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var()->kind() == Input_Var + && cvi.curr_var()->get_position() > max_level) + max_level = cvi.curr_var()->get_position(); + } + for (GEQ_Iterator e(r.single_conjunct()->GEQs()); e; e++) { + if ((*e).has_wildcards()) + has_wildcard = true; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var()->kind() == Input_Var + && cvi.curr_var()->get_position() > max_level) + max_level = cvi.curr_var()->get_position(); + } + + if (!(has_wildcard && max_level == codegen_->num_level())) + return std::make_pair(this, r); + } + } + + return std::make_pair(this, Relation::True(num_level())); +} + +Relation CG_leaf::hoistGuard() { + std::vector<Relation> guards; + for (BoolSet<>::iterator i = active_.begin(); i != active_.end(); i++) { + std::map<int, Relation>::iterator j = guards_.find(*i); + if (j == guards_.end()) { + Relation r = Relation::True(num_level()); + r.copy_names(known_); + r.setup_names(); + return r; + } else { + guards.push_back(j->second); + } + } + + return SimpleHull(guards, true, true); +} + +void CG_leaf::removeGuard(const Relation &guard) { + known_ = Intersection(known_, copy(guard)); + known_.simplify(); + + std::map<int, Relation>::iterator i = guards_.begin(); + while (i != guards_.end()) { + i->second = Gist(i->second, copy(known_), 1); + if (i->second.is_obvious_tautology()) + guards_.erase(i++); + else + ++i; + } +} + +CG_outputRepr *CG_leaf::printRepr(int indent, CG_outputBuilder *ocg, + const std::vector<CG_outputRepr *> &stmts, + const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) const { + return leaf_print_repr(active_, guards_, NULL, known_, indent, ocg, + codegen_->remap_, codegen_->xforms_, stmts, assigned_on_the_fly); +} + +CG_result *CG_leaf::clone() const { + return new CG_leaf(codegen_, active_); +} + +void CG_leaf::dump(int indent) const { + std::string prefix; + for (int i = 0; i < indent; i++) + prefix += " "; + std::cout << prefix << "LEAF: " << active_ << std::endl; + std::cout << prefix << "known: "; + const_cast<CG_leaf *>(this)->known_.print(); + for (std::map<int, Relation>::const_iterator i = guards_.begin(); + i != guards_.end(); i++) { + std::cout << prefix << "guard #" << i->first << ":"; + const_cast<Relation &>(i->second).print(); + } +} + +} diff --git a/omegalib/code_gen/src/CG_roseBuilder.cc b/omegalib/code_gen/src/CG_roseBuilder.cc new file mode 100644 index 0000000..eb16830 --- /dev/null +++ b/omegalib/code_gen/src/CG_roseBuilder.cc @@ -0,0 +1,1533 @@ +/***************************************************************************** + Copyright (C) 2008 University of Southern California + Copyright (C) 2009-2010 University of Utah + All Rights Reserved. + + Purpose: + generate suif code for omega + + Notes: + + History: + 02/01/06 created by Chun Chen + *****************************************************************************/ + +#include <stack> +#include <code_gen/CG_roseBuilder.h> +#include <string> + +struct ir_error: public std::runtime_error { + ir_error(const std::string &msg) : + std::runtime_error(msg) { + } +}; + +using namespace SageBuilder; +using namespace SageInterface; +using namespace OmpSupport; + +namespace omega { + +//----------------------------------------------------------------------------- +// make suif initilization happy +//----------------------------------------------------------------------------- +char *k_ocg_comment; + +// void __attribute__ ((constructor)) my_init(void) { +// ANNOTE(k_ocg_comment, "omega_comment", TRUE); +// } + +/* + const char *libcode_gen_ver_string = ""; + const char *libcode_gen_who_string = ""; + const char *libcode_gen_suif_string = ""; + + void init_code_gen(int&, char* []) { + ANNOTE(k_ocg_comment, "omega_comment", TRUE); + } + + void exit_code_gen(void) { + } + */ +CG_roseBuilder::CG_roseBuilder(int is_fortran, SgGlobal* global, SgGlobal* firstScope, + SgSymbolTable* symtab, SgSymbolTable* symtab2, SgNode* root) : + isFortran(is_fortran), global_(global), global_scope(firstScope), symtab_(symtab), symtab2_( + symtab2), root_(root) { +} + + +CG_roseBuilder::~CG_roseBuilder() { +} + +// Manu:: returns true if input is in fortran, else returns false +bool CG_roseBuilder::isInputFortran() const{ + if (isFortran) + return true; + else + return false; +} + +//----------------------------------------------------------------------------- +// place holder generation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, + const std::vector<std::string> &vars, std::vector<CG_outputRepr*> &subs) const { + + SgStatementPtrList* list = static_cast<CG_roseRepr *>(stmt)->list_; + SgNode *tnl; + SgStatement* statement; + if (list != NULL) { + //statement = *((*list).begin()); + //tnl = isSgNode(statement); + delete stmt; + for (int i = 0; i < subs.size(); i++) { + if (subs[i] == NULL) + continue; + + CG_roseRepr *repr = static_cast<CG_roseRepr*>(subs[i]); + SgExpression* op = repr->op_; + + for (SgStatementPtrList::iterator it = (*list).begin(); + it != (*list).end(); it++) { + statement = (*it); + tnl = isSgNode(statement); + + // std::string master = tnl->unparseToString(); + + int j; + int not_in_symtab_; + + not_in_symtab_ = 0; + + SgVariableSymbol *vs = symtab_->find_variable( + SgName(vars[i].c_str())); + + if (vs == NULL) { + + not_in_symtab_ = 1; + + vs = symtab2_->find_variable(SgName(vars[i].c_str())); + } + if (vs != NULL) { + //std::string x = vars[i].c_str() ; + //std::string y = isSgNode(op)->unparseToString(); + + std::vector<SgVarRefExp *> array = substitute(tnl, + (const SgVariableSymbol*) vs, op, root_); + for (std::vector<SgVarRefExp *>::iterator it = + array.begin(); it != array.end(); it++) { + + // std::string z = isSgNode(array[j])->unparseToString(); + if (isSgVarRefExp(op)) { + if (strcmp( + isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), + vs->get_name().getString().c_str())) { + + (*it)->set_symbol( + isSgVarRefExp(op)->get_symbol()); + // std::string z = isSgNode(array[j])->unparseToString(); + + // isSgBinaryOp(array[j]->get_parent())->replace_expression(array[j], op); + + } + } else if (isSgExpression(op)) { + + if (isSgBinaryOp((*it)->get_parent())) + isSgBinaryOp((*it)->get_parent())->replace_expression( + *it, op); + else if (isSgUnaryOp((*it)->get_parent())) + isSgUnaryOp((*it)->get_parent())->replace_expression( + *it, op); + else if (isSgExprListExp((*it)->get_parent())) + isSgExprListExp((*it)->get_parent())->replace_expression( + *it, op); + else + throw ir_error("unrecognized expression type"); + } + + } + /* std::vector<SgVarRefExp *> array2 = substitute (tnl,(const SgVariableSymbol*) vs, op, root_); + if(array2.size() != 0) + throw ir_error("variable replacement unsuccessful"); + */ + } + + } + + delete repr; + subs[i] = NULL; + + if (subs[i] != NULL) + throw ir_error("not freed properly"); + + } + + return new CG_roseRepr(list); + + } else { + tnl = static_cast<CG_roseRepr *>(stmt)->tnl_; + //std::string master = tnl->unparseToString(); + + if (tnl == NULL) + throw ir_error("both list and tnl are null!!"); + + delete stmt; + int j; + int not_in_symtab_; + for (int i = 0; i < subs.size(); i++) { + if (subs[i] == NULL) + continue; + not_in_symtab_ = 0; + + + CG_roseRepr *repr = static_cast<CG_roseRepr*>(subs[i]); + SgExpression* op = repr->op_; + delete repr; + subs[i] = NULL; + + SgVariableSymbol *vs = symtab_->find_variable( + SgName(vars[i].c_str())); + + if (vs == NULL) { + + not_in_symtab_ = 1; + + vs = symtab2_->find_variable(SgName(vars[i].c_str())); + } + if (vs != NULL) { + //std::string x = vars[i].c_str() ; + //std::string y = isSgNode(op)->unparseToString(); + std::vector<SgVarRefExp *> array = substitute(tnl, vs, op, + root_); + + if (not_in_symtab_ && isSgVarRefExp(op)) { + if (strcmp( + isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), + vs->get_name().getString().c_str())) { + // symtab2_->remove(vs); + } + } + /* else if(not_in_symtab_ && isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())){ + if(strcmp(isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())->get_symbol()->get_name().getString().c_str(),\ + vs->get_name().getString().c_str())){ + symtab2_->remove(vs); + } + }*/ + //symtab2_->remove(vs); + for (std::vector<SgVarRefExp *>::iterator j = array.begin(); + j != array.end(); j++) { + // std::string z = isSgNode(array[j])->unparseToString(); + + if (isSgVarRefExp(op)) { + if (strcmp( + isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), + vs->get_name().getString().c_str())) { + (*j)->set_symbol(isSgVarRefExp(op)->get_symbol()); + //isSgBinaryOp(array[j]->get_parent())->replace_expression(array[j], op); + // std::string z = isSgNode(array[j])->unparseToString(); + + } + } else if (isSgExpression(op)) { + + if (isSgBinaryOp((*j)->get_parent())) + isSgBinaryOp((*j)->get_parent())->replace_expression( + *j, op); + else if (isSgUnaryOp((*j)->get_parent())) + isSgUnaryOp((*j)->get_parent())->replace_expression( + *j, op); + else if (isSgExprListExp((*j)->get_parent())) { // Manu:: fortran indices are stored this way + isSgExprListExp((*j)->get_parent())->replace_expression(*j, op); + } + else + throw ir_error("unrecognized expression type"); + /* if(strcmp(isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())->get_symbol()->get_name().getString().c_str(),\ + vs->get_name().getString().c_str() )){ + array[j]->set_symbol(isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())->get_symbol()); + + */ + + } + + } + /* std::vector<SgVarRefExp *> array2 = substitute (tnl,(const SgVariableSymbol*) vs, op, root_); + if(array2.size() != 0) + throw ir_error("variable replacement unsuccessful"); + */ + } + /* SgExpression* exp = NULL; + + if(stmt1 = isSgStatement(tnl)){ + if (SgExprStatement* expr_stmt = isSgExprStatement(stmt1)) + exp = expr_stmt->get_expression(); + else if( block = isSgBasicBlock(tnl)){ + SgStatementPtrList& stmts = block->get_statements(); + SgExpression* exp2; + for(int i =0; i < stmts.size(); i++){ + if(isSgExprStatement(stmts[i])){ + exp2 = isSgExprStatement(stmts[i])->get_expression(); + if(exp2 != NULL){ + + if(isSgBinaryOp(exp2)) { + substitute(isSgBinaryOp(exp2)->get_lhs_operand(), vs, op, root_, exp2); + substitute(isSgBinaryOp(exp2)->get_rhs_operand(), vs, op, root_, exp2); + } + else if (isSgUnaryOp(exp2)) + substitute(isSgUnaryOp(exp2)->get_operand(), vs, op, root_, exp2); + + + }//end if + + }//end if + }//end for + + }//end else + else if(SgForStatement* for_stmt = isSgForStatement(tnl)){ + SgForStatement* temp = for_stmt; + while(isSgForStatement(temp)){ + + + + } + + + + + } + + + }//end if + else + exp = isSgExpression(tnl); + + if(exp != NULL){ + if(isSgBinaryOp(exp)) { + substitute(isSgBinaryOp(exp)->get_lhs_operand(), vs, op, root_, exp); + substitute(isSgBinaryOp(exp)->get_rhs_operand(), vs, op, root_, exp); + } + else if (isSgUnaryOp(exp)) + substitute(isSgUnaryOp(exp)->get_operand(), vs, op, root_, exp); + + } + // if (op.is_instr()) + // delete op.instr(); + } + */ + } + return new CG_roseRepr(tnl); + } + +} + +//----------------------------------------------------------------------------- +// assignment generation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateAssignment(int, CG_outputRepr *lhs, + CG_outputRepr *rhs) const { + if (lhs == NULL || rhs == NULL) { + fprintf(stderr, "Code generation: Missing lhs or rhs\n"); + return NULL; + } + + SgExpression* src = static_cast<CG_roseRepr*>(rhs)->op_; + SgExpression* dst = static_cast<CG_roseRepr*>(lhs)->op_; + + SgExprStatement* ins = buildAssignStatement(dst, src); + src->set_parent(ins); + dst->set_parent(ins); + + SgStatementPtrList* new_list = new SgStatementPtrList; + + (*new_list).push_back(isSgStatement(ins)); + + delete lhs; + delete rhs; + + return new CG_roseRepr(new_list); + +} + +//----------------------------------------------------------------------------- +// function invocation generation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateInvoke(const std::string &fname, + std::vector<CG_outputRepr *> &list) const { + + // Manu:: debug +// std::cout << "--------- CreateInvoke --------- \n"; + + if (fname == std::string("max") || fname == std::string("min")) { + if (list.size() == 0) { + return NULL; + } else if (list.size() == 1) { + return list[0]; + } else { + int last = list.size() - 1; + SgExpression* op2 = static_cast<CG_roseRepr*>(list[last])->op_; + delete list[last]; + list.erase(list.end()-1); + CG_roseRepr *repr = static_cast<CG_roseRepr*>(CreateInvoke(fname, + list)); + SgExpression* op1 = repr->op_; + + + SgExpression *ins; + SgExprListExp* arg_list = buildExprListExp(); + appendExpression(arg_list, op1); + appendExpression(arg_list, op2); + SgVarRefExp* opaque_var; + + + if (fname == std::string("max")) { + opaque_var = buildOpaqueVarRefExp("__rose_gt", global_); + ins = isSgExpression(buildFunctionCallExp(opaque_var, arg_list)); + + // Manu:: fortran support + if (isInputFortran()) { + SgName fName("merge"); + SgTypeInt *retType = buildIntType(); + + SgExpression *cond = static_cast<CG_roseRepr *>(CreateLE(new CG_roseRepr(op2), new CG_roseRepr(op1)))->op_; + appendExpression(arg_list, cond); + ins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_)); +// std::cout << "--------- CreateInvoke:: " << isSgNode(ins)->unparseToString().c_str() << "\n"; + } + + } else { + opaque_var = buildOpaqueVarRefExp("__rose_lt", global_); + ins = isSgExpression(buildFunctionCallExp(opaque_var, arg_list)); + + // Manu:: fortran support + if (isInputFortran()) { + SgName fName("merge"); + SgTypeInt *retType = buildIntType(); + + SgExpression *cond = static_cast<CG_roseRepr *>(CreateLE(new CG_roseRepr(op1), new CG_roseRepr(op2)))->op_; + appendExpression(arg_list, cond); + ins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_)); +// std::cout << "--------- CreateInvoke:: " << isSgNode(ins)->unparseToString().c_str() << "\n"; + } + + } + + repr->op_ = ins; + return repr; + } + } else { + fprintf(stderr, + "Code generation: invoke function io_call not implemented\n"); + return NULL; + } + +} + +//----------------------------------------------------------------------------- +// comment generation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateComment(int, + const std::string &commentText) const { + if (commentText == std::string("")) { + return NULL; + } + + SgLocatedNode *tnl = new SgLocatedNode(); + buildComment(tnl, "//omega_comment: " + commentText); + + return new CG_roseRepr(isSgNode(tnl)); + +} + +//----------------------------------------------------------------------------- +// if stmt gen operations +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateIf(int, CG_outputRepr *guardList, + CG_outputRepr *true_stmtList, CG_outputRepr *false_stmtList) const { + + // static int if_counter = 1; + // std::string s = std::string("omegaif_")+to_string(if_counter++); + // SgLabelStatement* label =buildLabelStatement(SgName(const_cast<char *>(s.c_str()))); + + if (true_stmtList == NULL && false_stmtList == NULL) { + delete guardList; + return NULL; + } else if (guardList == NULL) { + return StmtListAppend(true_stmtList, false_stmtList); + } + + SgExpression* header = static_cast<CG_roseRepr*>(guardList)->op_; + + SgStatementPtrList *then_part1, *else_part1; + SgStatement* then_part; + SgStatement* else_part; + SgBasicBlock* then_part2; + SgBasicBlock* else_part2; + if (true_stmtList != NULL) { + then_part1 = static_cast<CG_roseRepr*>(true_stmtList)->list_; + if (then_part1 != NULL) { + then_part = *((*then_part1).begin()); + + if ((*then_part1).size() > 1) { + then_part2 = buildBasicBlock(); + for (SgStatementPtrList::iterator it = (*then_part1).begin(); + it != (*then_part1).end(); it++) { + then_part2->append_statement(*it); + + } + then_part = isSgStatement(then_part2); + + } + } else { + // Manu:: fortran support (if part) + if (isInputFortran()) { + then_part2 = buildBasicBlock(); + then_part2->append_statement(isSgStatement(static_cast<CG_roseRepr*>(true_stmtList)->tnl_)); + then_part = isSgStatement(then_part2); + } else + then_part = isSgStatement(static_cast<CG_roseRepr*>(true_stmtList)->tnl_); + } + } else { + then_part = NULL; + } + if (false_stmtList != NULL) { + else_part1 = static_cast<CG_roseRepr*>(false_stmtList)->list_; + if (else_part1 != NULL) { + else_part = *((*else_part1).begin()); + if ((*else_part1).size() > 1) { + else_part2 = buildBasicBlock(); + for (SgStatementPtrList::iterator it2 = (*else_part1).begin(); + it2 != (*else_part1).end(); it2++) { + else_part2->append_statement(*it2); + + } + else_part = isSgStatement(else_part2); + + } + } else { + // Manu:: fortran support (if part) + if (isInputFortran()) { + else_part2 = buildBasicBlock(); + else_part2->append_statement(isSgStatement(static_cast<CG_roseRepr*>(false_stmtList)->tnl_)); + else_part = isSgStatement(else_part2); + } else + else_part = isSgStatement(static_cast<CG_roseRepr*>(false_stmtList)->tnl_); + } + } else { + else_part = NULL; + } + + SgIfStmt* ti = buildIfStmt(header, isSgStatement(then_part), + isSgStatement(else_part)); + +// label->set_scope(ti);//may have to be shifted to after symbol table insertion +// SgLabelSymbol* if_label = isSgLabelSymbol(label->get_symbol_from_symbol_table()); + +// symtab_->insert( SgName(const_cast<char *>(s.c_str())) , isSgSymbol(if_label)); + + delete guardList; + delete true_stmtList; + delete false_stmtList; + + return new CG_roseRepr(isSgNode(ti)); + +} + +//----------------------------------------------------------------------------- +// inductive variable generation, to be used in CreateLoop as control +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateInductive(CG_outputRepr *index, + CG_outputRepr *lower, CG_outputRepr *upper, CG_outputRepr *step) const { + + if (index == NULL || lower == NULL || upper == NULL) { + fprintf(stderr, + "Code generation: something wrong in CreateInductive\n"); + return NULL; + } + + if (step == NULL) + step = new CG_roseRepr(isSgExpression(buildIntVal(1))); + + SgVarRefExp *index_sym = isSgVarRefExp( + static_cast<CG_roseRepr*>(index)->op_); + SgExpression* lower_bound = static_cast<CG_roseRepr*>(lower)->op_; + SgExpression* upper_bound = static_cast<CG_roseRepr*>(upper)->op_; + SgExpression* step_size = static_cast<CG_roseRepr*>(step)->op_; + + /* label_sym *contLabel = new label_sym(""); + label_sym *brkLabel = new label_sym(""); may not be required on rose?! + */ + + SgStatement* for_init_stmt = buildAssignStatement(index_sym, lower_bound); + SgLessOrEqualOp* cond = buildLessOrEqualOp(index_sym, upper_bound); + SgExprStatement* test = buildExprStatement(cond); + SgPlusAssignOp* increment = buildPlusAssignOp(index_sym, step_size); + SgForStatement *for_stmt = buildForStatement(for_init_stmt, + isSgStatement(test), increment, NULL); + + delete index; + delete lower; + delete upper; + delete step; + + + // Manu + if (isInputFortran()) { + // std::cout << "CG_roseBuilder:: need to construct a fortran do statement\n"; + SgFortranDo * forStmt=new SgFortranDo(Sg_File_Info::generateDefaultFileInfoForTransformationNode()); + forStmt->set_has_end_statement(true); + forStmt->set_bound(upper_bound); + forStmt->set_increment(step_size); + forStmt->set_initialization(isSgExprStatement(for_init_stmt)->get_expression()); + return new CG_roseRepr(isSgNode(forStmt)); + } else { +// std::cout << "CG_roseBuilder:: for statement is fine\n"; + + return new CG_roseRepr(isSgNode(for_stmt)); + + } + +} + +//----------------------------------------------------------------------------- +// Attribute Creation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateAttribute(CG_outputRepr *control, + const std::string &commentText) const { + + SgNode *tnl = static_cast<CG_roseRepr*>(control)->tnl_; + + tnl->setAttribute("omega_comment", new AstTextAttribute(commentText)); + + return static_cast<CG_roseRepr*>(control); + +} + +//----------------------------------------------------------------------------- +// Pragma Attribute +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreatePragmaAttribute(CG_outputRepr *stmt, int looplevel, const std::string &pragmaText) const { + SgNode *tnl = static_cast<CG_roseRepr*>(stmt)->tnl_; + CodeInsertionAttribute* attr = NULL; + if (!tnl->attributeExists("code_insertion")) { + attr = new CodeInsertionAttribute(); + tnl->setAttribute("code_insertion", attr); + } + else { + attr = static_cast<CodeInsertionAttribute*>(tnl->getAttribute("code_insertion")); + } + attr->add(new PragmaInsertion(looplevel, pragmaText)); + return stmt; +} + +//----------------------------------------------------------------------------- +// Prefetch Attribute +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreatePrefetchAttribute(CG_outputRepr* stmt, int looplevel, const std::string &arrName, int hint) const { + SgNode *tnl = static_cast<CG_roseRepr*>(stmt)->tnl_; + CodeInsertionAttribute *attr = getOrCreateCodeInsertionAttribute(tnl); + attr->add(new MMPrefetchInsertion(looplevel, arrName, hint)); +} + +//----------------------------------------------------------------------------- +// loop stmt generation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateLoop(int, CG_outputRepr *control, + CG_outputRepr *stmtList) const { + if (stmtList == NULL) { + delete control; + return NULL; + } else if (control == NULL) { + fprintf(stderr, "Code generation: no inductive for this loop\n"); + return stmtList; + } + + SgNode *tnl = static_cast<CG_roseRepr*>(control)->tnl_; + SgForStatement *tf = isSgForStatement(tnl); + + // Manu :: fortran support + SgFortranDo *tfd = NULL; + if (isInputFortran()) { + tfd = isSgFortranDo(tnl); + } + // Manu:: debug +/* if (!tf) { + std::cout << "CreateLoop:: Not a for loop\n"; + if (isSgFortranDo(tnl)) + std::cout << "CreateLoop:: It is a fortran do loop\n"; + } +*/ + + SgStatementPtrList * body = static_cast<CG_roseRepr*>(stmtList)->list_; + + if (body != NULL) { + if (!((*body).empty())) { + if ((*body).size() == 1) { + // if(isSgBasicBlock(*((*body).begin()))){ + if (!isInputFortran()) { // Manu:: added if-else for fortran support + tf->set_loop_body(*((*body).begin())); + (*((*body).begin()))->set_parent(tf); + } else { + SgBasicBlock* bb1 = buildBasicBlock(); + bb1->set_parent(tfd); + bb1->append_statement(*((*body).begin())); + tfd->set_body(bb1); + } + // } + /* else{ + SgBasicBlock* bb1 = buildBasicBlock(); + bb1->set_parent(tf); + bb1->append_statement(*((*body).begin())); + tf->set_loop_body(bb1); + + }*/ + } else { + // Manu:: support for fortran label (do - continue) + SgName *sname = NULL; + + SgBasicBlock* bb = buildBasicBlock(); + if (!isInputFortran()) + bb->set_parent(tf); + else + bb->set_parent(tfd); + for (SgStatementPtrList::iterator it = (*body).begin(); + it != (*body).end(); it++) { + bb->append_statement(*it); + (*it)->set_parent(bb); + } + if (!isInputFortran()) + tf->set_loop_body(bb); + else { + tfd->set_body(bb); + } + } + } + } else { + SgNode* tnl2 = static_cast<CG_roseRepr*>(stmtList)->tnl_; + + if (tnl2 != NULL) { + if (!isInputFortran()) { + tf->set_loop_body(isSgStatement(tnl2)); + tnl2->set_parent(tf); + } else { + SgBasicBlock* bb1 = buildBasicBlock(); + bb1->set_parent(tfd); + bb1->append_statement(isSgStatement(tnl2)); + tfd->set_body(bb1); + tnl2->set_parent(bb1); + } + } + } + + delete stmtList; + + return control; +} + +//----------------------------------------------------------------------------- +// basic int, identifier gen operations +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateInt(int _i) const { + return new CG_roseRepr(isSgExpression(buildIntVal(_i))); +} +bool CG_roseBuilder::isInteger(CG_outputRepr *op) const{ + + SgExpression *op1 = static_cast<CG_roseRepr *>(op)->op_; + + if(op1) + if(isSgIntVal(op1)) + return true; + + return false; +} +CG_outputRepr* CG_roseBuilder::CreateIdent(const std::string &_s) const { + + SgVariableSymbol *vs = symtab_->find_variable(SgName(_s.c_str())); + SgVariableSymbol *vs2 = symtab2_->find_variable(SgName(_s.c_str())); + + if (vs == NULL && vs2 == NULL) { + + SgVariableDeclaration* defn = buildVariableDeclaration( + SgName(_s.c_str()), buildIntType()); + SgInitializedNamePtrList& variables = defn->get_variables(); + SgInitializedNamePtrList::const_iterator i = variables.begin(); + SgInitializedName* initializedName = *i; + vs = new SgVariableSymbol(initializedName); + prependStatement(defn, isSgScopeStatement(root_)); + + vs->set_parent(symtab2_); + symtab2_->insert(SgName(_s.c_str()), vs); + return new CG_roseRepr(isSgExpression(buildVarRefExp(vs))); + + } + + /* May have problem */ + + if (!isSgExpression(buildVarRefExp(SgName(_s.c_str())))) + throw ir_error("error in Create ident!!"); + if (vs2 != NULL) + return new CG_roseRepr(isSgExpression(buildVarRefExp(vs2))); + + return new CG_roseRepr(isSgExpression(buildVarRefExp(vs))); + +} + +//----------------------------------------------------------------------------- +// binary arithmetic operations +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreatePlus(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL) { + return lop; + } else if (lop == NULL) { + return rop; + } + + SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; + SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; + + SgAddOp *ins = buildAddOp(op1, op2); + op1->set_parent(ins); + op2->set_parent(ins); + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +CG_outputRepr* CG_roseBuilder::CreateMinus(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL) { + return lop; /* May Cause Problem */ + } else if (lop == NULL) { + SgExpression *op = static_cast<CG_roseRepr*>(rop)->op_; + SgMinusOp *ins = buildMinusOp(op); + + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + } else { + SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; + SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; + + SgSubtractOp *ins = buildSubtractOp(op1, op2); + op1->set_parent(ins); + op2->set_parent(ins); + delete lop; + delete rop; + return new CG_roseRepr(isSgExpression(ins)); + } + +} + +CG_outputRepr* CG_roseBuilder::CreateTimes(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) { + if (rop != NULL) { + rop->clear(); + delete rop; + } + if (lop != NULL) { + lop->clear(); + delete lop; + } + return NULL; + } + + SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; + SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; + + SgMultiplyOp *ins = buildMultiplyOp(op1, op2); + op1->set_parent(ins); + op2->set_parent(ins); + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +CG_outputRepr* CG_roseBuilder::CreateIntegerFloor(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL) { + fprintf(stderr, "Code generation: divide by NULL\n"); + return NULL; + } else if (lop == NULL) { + delete rop; + return NULL; + } + + // (6+5)*10 / 4 + SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; + SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; + + // bugs in SUIF prevent use of correct io_divfloor + SgDivideOp *ins = buildDivideOp(op1, op2); + + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +CG_outputRepr* CG_roseBuilder::CreateIntegerMod(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) { + return NULL; + } + + SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; + SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; + + // bugs in SUIF prevent use of correct io_mod + SgModOp *ins; + if (!isInputFortran()) { + ins = buildModOp(op1, op2); + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + } else { // Manu:: fortran mod is a function call and not an operator (f77 and f90) + SgExpression *fins; + SgName fName("MOD"); + SgExprListExp* arg_list = buildExprListExp(); + appendExpression(arg_list, op1); + appendExpression(arg_list, op2); + SgTypeInt *retType = buildIntType(); + fins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_)); + return new CG_roseRepr(isSgExpression(fins)); + } + +} + +//----------------------------------------------------------------------------- +// binary logical operations +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateAnd(CG_outputRepr *lop, + CG_outputRepr *rop) const { + /*if (rop == NULL || lop == NULL) { + return NULL; + }*/ + + if (rop == NULL) + return lop; + else if (lop == NULL) + return rop; + + SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; + SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; + + SgAndOp *ins = buildAndOp(op1, op2); + + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +//----------------------------------------------------------------------------- +// binary relational operations +//----------------------------------------------------------------------------- +/*CG_outputRepr* CG_roseBuilder::CreateGE(CG_outputRepr *lop, + CG_outputRepr *rop) const { + return CreateLE(rop, lop); +}*/ + +CG_outputRepr* CG_roseBuilder::CreateLE(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) { + return NULL; + } + + SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; + SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; + + SgLessOrEqualOp *ins = buildLessOrEqualOp(op1, op2); + + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +CG_outputRepr* CG_roseBuilder::CreateEQ(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) { + return NULL; + } + + SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; + SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; + + SgEqualityOp *ins = buildEqualityOp(op1, op2); + + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +//----------------------------------------------------------------------------- +// stmt list gen operations +//----------------------------------------------------------------------------- +/*CG_outputRepr* CG_roseBuilder::CreateStmtList(CG_outputRepr *singleton) const { + + if (singleton == NULL) { + return new CG_roseRepr(new SgStatementPtrList); + } + + SgStatementPtrList *tnl = static_cast<CG_roseRepr *>(singleton)->list_; + SgNode* sgn = static_cast<CG_roseRepr *>(singleton)->tnl_; + + if (tnl == NULL) + tnl = new SgStatementPtrList; + + if (sgn == NULL) { + SgExpression* op = static_cast<CG_roseRepr *>(singleton)->op_; + + if (op != NULL) + (*tnl).push_back( + buildExprStatement( + static_cast<CG_roseRepr *>(singleton)->op_)); + + } else + (*tnl).push_back(isSgStatement(sgn)); + + delete singleton; + return new CG_roseRepr(tnl); + +// tnl = isSgNode(buildBasicBlock(buildExprStatement(static_cast<CG_roseRepr *>(singleton)->op_))); + +// delete singleton; +// return new CG_roseRepr(tnl); + +} + +CG_outputRepr* CG_roseBuilder::StmtListInsertLast(CG_outputRepr *list, + CG_outputRepr *node) const { + return StmtListAppend(list, node); +} +*/ +CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1, + CG_outputRepr *list2) const { + + if (list2 == NULL) { + return list1; + } else if (list1 == NULL) { + return list2; + } + + // SgStatement* parent; + // SgStatement* stmt1; + // SgStatement* stmt2; + + SgStatementPtrList* new_list; + + SgStatementPtrList* tnl1 = static_cast<CG_roseRepr *>(list1)->list_; + SgStatementPtrList* tnl2 = static_cast<CG_roseRepr *>(list2)->list_; + SgNode* one = static_cast<CG_roseRepr *>(list1)->tnl_; + SgNode* two = static_cast<CG_roseRepr *>(list2)->tnl_; + + SgExpression* exp1 = static_cast<CG_roseRepr *>(list1)->op_; + SgExpression* exp2 = static_cast<CG_roseRepr *>(list2)->op_; + + if (exp1 || exp2) + throw ir_error("error in stmtlistappend!!"); + + if (tnl1 && one) + throw ir_error("error in stmtlistappend!!"); + + if (tnl2 && two) + throw ir_error("error in stmtlistappend!!"); +// SgNode* sg1 = static_cast<CG_roseRepr *>(list1)->tnl_; + +//if((*tnl1).empty()){ + +// if(SgStatement* stmt = isSgStatement(sg1)) +// (*tnl1).push_back(stmt); +//else if(isSgScopeStatement(sg1)){ +// SgStatementPtrList scopeStmtPtrLst = isSgScopeStatement(sg1)->generateStatementList(); + +// for(SgStatementPtrList::iterator it1 = scopeStmtPtrLst.begin();it1 != scopeStmtPtrLst.end(); it1++) +// (*tnl1).push_back(*it1); +//} +//} + + if ((tnl1 == NULL) && (tnl2 == NULL)) { + + if ((one != NULL) && (two != NULL)) { + + new_list = new SgStatementPtrList; + + (*new_list).push_back(isSgStatement(one)); + (*new_list).push_back(isSgStatement(two)); + + CG_roseRepr* new_rep = new CG_roseRepr(new_list); + + return static_cast<CG_outputRepr *>(new_rep); + + } else if ((one != NULL) && (two == NULL)) { + + return static_cast<CG_outputRepr *>(new CG_roseRepr(one)); + + } else if ((two != NULL) && (one == NULL)) { + return static_cast<CG_outputRepr *>(new CG_roseRepr(two)); + + } + + } else { + if ((tnl2 != NULL) && (tnl1 == NULL)) { + /* for(SgStatementPtrList::iterator it = (*tnl2).begin(); it != (*tnl2).end(); it++) + { + (*tnl1).push_back(*it); + + } + */ + if (one == NULL) + return list2; + else { + new_list = new SgStatementPtrList; + (*new_list).push_back(isSgStatement(one)); + + for (SgStatementPtrList::iterator it = (*tnl2).begin(); + it != (*tnl2).end(); it++) { + (*new_list).push_back(*it); + + } + //delete list2; + return static_cast<CG_outputRepr *>(new CG_roseRepr(new_list)); + } + } else if ((tnl1 != NULL) && (tnl2 == NULL)) { + if (two == NULL) + return list1; + else { + + (*tnl1).push_back(isSgStatement(two)); + // delete list1; + return static_cast<CG_outputRepr *>(new CG_roseRepr(tnl1)); + + } + + } else if ((tnl1 != NULL) && (tnl2 != NULL)) { + + for (SgStatementPtrList::iterator it = (*tnl2).begin(); + it != (*tnl2).end(); it++) { + (*tnl1).push_back(*it); + + } + + // delete list2; + // delete list1; + return static_cast<CG_outputRepr *>(new CG_roseRepr(tnl1)); + } +//else{ +// SgNode* tnll2 = static_cast<CG_roseRepr *>(list2)->tnl_; +// if(tnll2 != NULL){ +// if(isSgStatement(tnll2)) +// (*tnl1).push_back(isSgStatement(tnll2)); +// else if(isSgScopeStatement(tnll2)){ +// SgStatementPtrList scopeStmtPtrLst1 = isSgScopeStatement(tnll2)->generateStatementList(); + +// for(SgStatementPtrList::iterator it2 = scopeStmtPtrLst1.begin();it2 != scopeStmtPtrLst1.end(); it2++) +// (*tnl1).push_back(*it2); + +// } +//} +// else{ +// SgStatement* stmt2 = isSgStatement(buildExprStatement(static_cast<CG_roseRepr *>(list2)->op_)); +// (*tnl1).push_back(stmt2); + +// } + +//} + // stmt2 = isSgStatement(tnl2); + +// std::string c = tnl1->unparseToString(); + +// std::string d = isSgNode(stmt2)->unparseToString(); + +// if(isSgForStatement(tnl1) || isSgBasicBlock(tnl1)) +// isSgScopeStatement(tnl1)->append_statement(stmt2); +// else +// { + // stmt1 = isSgStatement(tnl1); + // parent = isSgStatement(tnl1->get_parent()); + // if(isSgForStatement(tnl1->get_parent()) || isSgBasicBlock(tnl1->get_parent())) + // isSgScopeStatement(tnl1->get_parent())->append_statement(stmt2); + // else if (isSgStatement(tnl1->get_parent())) + // isSgStatement(tnl1->get_parent())->insert_statement(stmt1, stmt2, false); + +// } + + } +// delete list2; + +// return list1; + +} + + +CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, CG_outputRepr* arg1, + CG_outputRepr* arg2, CG_outputRepr* arg3) const { + + //SgName type_name("dim3"); + //SgClassSymbol * type_symbol = global_scope->lookup_class_symbol(type_name); + // SgClassDeclaration * type_decl = isSgClassDeclaration( + // type_symbol->get_declaration()); + + //SgVariableDeclaration * var_decl = buildVariableDeclaration(varName, type_symbol->get_type()); + + SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol( + SgName("dim3")); + + SgExprListExp * ctor_args; + if(arg3 != NULL) + ctor_args = buildExprListExp(static_cast<CG_roseRepr*>(arg1)->op_, + static_cast<CG_roseRepr*>(arg2)->op_, static_cast<CG_roseRepr*>(arg3)->op_); + else + ctor_args = buildExprListExp(static_cast<CG_roseRepr*>(arg1)->op_, + static_cast<CG_roseRepr*>(arg2)->op_); + SgFunctionCallExp * dim3_func_call = buildFunctionCallExp( + buildFunctionRefExp(ctor_symbol->get_declaration()), ctor_args); + + char joined_str[20]; + + strcpy(joined_str, "dim3 "); + strcat(joined_str, varName); + + SgExprStatement* decl = buildAssignStatement( + buildOpaqueVarRefExp(joined_str, isSgScopeStatement(root_)), + dim3_func_call); + + SgStatementPtrList *tnl2 = new SgStatementPtrList; + + // (*tnl2).push_back(var_decl); + (*tnl2).push_back(decl); + return new CG_roseRepr(tnl2); + +} + +/*CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, int arg1, + int arg2) const { + + SgName type_name("dim3"); + SgClassSymbol * type_symbol = global_scope->lookup_class_symbol(type_name); + SgClassDeclaration * type_decl = isSgClassDeclaration( + type_symbol->get_declaration()); + + //SgVariableDeclaration * var_decl = buildVariableDeclaration(varName, type_symbol->get_type()); + + SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol( + SgName("dim3")); + + SgExprListExp * ctor_args = buildExprListExp(buildIntVal(arg1), + buildIntVal(arg2)); + + SgFunctionCallExp * dim3_func_call = buildFunctionCallExp( + buildFunctionRefExp(ctor_symbol->get_declaration()), ctor_args); + + char joined_str[20]; + + strcpy(joined_str, "dim3 "); + strcat(joined_str, varName); + + SgExprStatement* decl = buildAssignStatement( + buildOpaqueVarRefExp(joined_str, isSgScopeStatement(root_)), + dim3_func_call); + + SgStatementPtrList *tnl2 = new SgStatementPtrList; + + // (*tnl2).push_back(var_decl); + (*tnl2).push_back(decl); + return new CG_roseRepr(tnl2); +} + +CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, int arg1, + int arg2, int arg3) const { + + SgName type_name("dim3"); + SgClassSymbol * type_symbol = global_scope->lookup_class_symbol(type_name); + SgClassDeclaration * type_decl = isSgClassDeclaration( + type_symbol->get_declaration()); + + //SgVariableDeclaration * var_decl = buildVariableDeclaration(varName, type_symbol->get_type()); + + SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol( + SgName("dim3")); + + SgExprListExp * ctor_args = buildExprListExp(buildIntVal(arg1), + buildIntVal(arg2), buildIntVal(arg3)); + + SgFunctionCallExp * dim3_func_call = buildFunctionCallExp( + buildFunctionRefExp(ctor_symbol->get_declaration()), ctor_args); + + char joined_str[20]; + + strcpy(joined_str, "dim3 "); + strcat(joined_str, varName); + + SgExprStatement* decl = buildAssignStatement( + buildOpaqueVarRefExp(joined_str, isSgScopeStatement(root_)), + dim3_func_call); + + SgStatementPtrList *tnl2 = new SgStatementPtrList; + + // (*tnl2).push_back(var_decl); + (*tnl2).push_back(decl); + return new CG_roseRepr(tnl2); + + + +} +*/ + +/*CG_outputRepr* CG_suifBuilder::CreateKernel(immed_list* iml) const { + instruction *ins = new in_rrr(io_mrk); + ins->append_annote(k_cuda_kernel, iml); + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + return new CG_suifRepr(tnl); + } + + type_node* CG_suifBuilder::ModifyType(type_node* base, const char* modifier) const { + modifier_type* result = new modifier_type(TYPE_NULL, base); + immed_list *iml = new immed_list; + iml->append(immed((char*)modifier)); + result->append_annote(k_cuda_modifier, iml); + return result; + } + */ + +std::vector<SgVarRefExp *> substitute(SgNode *in, const SgVariableSymbol *sym, + SgExpression* expr, SgNode* root) { + + SgStatement* stmt; + SgExpression* op; + std::vector<SgVarRefExp *> arrays; + + if (in != NULL) { + if (stmt = isSgStatement(in)) { + if (isSgBasicBlock(stmt)) { + SgStatementPtrList& stmts = + isSgBasicBlock(stmt)->get_statements(); + for (int i = 0; i < stmts.size(); i++) { + stmts[i]->set_parent(stmt); + std::vector<SgVarRefExp *> a = substitute( + isSgNode(stmts[i]), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } + } else if (isSgForStatement(stmt)) { + SgForStatement *tnf = isSgForStatement(stmt); + tnf->get_for_init_stmt()->set_parent(tnf); + tnf->get_test()->set_parent(tnf); + tnf->get_increment()->set_parent(tnf); + tnf->get_loop_body()->set_parent(tnf); + std::vector<SgVarRefExp *> a = substitute( + isSgNode(tnf->get_for_init_stmt()), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + std::vector<SgVarRefExp *> a1 = substitute( + isSgNode(tnf->get_test()), sym, expr, root); + std::copy(a1.begin(), a1.end(), back_inserter(arrays)); + std::vector<SgVarRefExp *> a2 = substitute( + isSgNode(tnf->get_increment()), sym, expr, root); + std::copy(a2.begin(), a2.end(), back_inserter(arrays)); + std::vector<SgVarRefExp *> a3 = substitute( + isSgNode(tnf->get_loop_body()), sym, expr, root); + std::copy(a3.begin(), a3.end(), back_inserter(arrays)); + } else if (isSgFortranDo(stmt)) { // Manu:: fortran support + SgFortranDo *tnf = isSgFortranDo(stmt); + tnf->get_initialization()->set_parent(tnf); + tnf->get_bound()->set_parent(tnf); + tnf->get_increment()->set_parent(tnf); + tnf->get_body()->set_parent(tnf); + std::vector<SgVarRefExp *> a = substitute( + isSgNode(tnf->get_initialization()), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + std::vector<SgVarRefExp *> a1 = substitute( + isSgNode(tnf->get_bound()), sym, expr, root); + std::copy(a1.begin(), a1.end(), back_inserter(arrays)); + std::vector<SgVarRefExp *> a2 = substitute( + isSgNode(tnf->get_increment()), sym, expr, root); + std::copy(a2.begin(), a2.end(), back_inserter(arrays)); + std::vector<SgVarRefExp *> a3 = substitute( + isSgNode(tnf->get_body()), sym, expr, root); + std::copy(a3.begin(), a3.end(), back_inserter(arrays)); + } else if (isSgForInitStatement(stmt)) { + + SgStatementPtrList& stmts = + isSgForInitStatement(stmt)->get_init_stmt(); + + for (SgStatementPtrList::iterator it = stmts.begin(); + it != stmts.end(); it++) { + std::vector<SgVarRefExp *> a = substitute(isSgNode(*it), + sym, expr, root); + + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } + } + /*else if(isSgFortranDo(stmt)){ + SgFortranDo *tfortran = isSgFortranDo(stmt); + omega::CG_roseRepr *r = new omega::CG_roseRepr(isSgStatement(tfortran->get_body())); + std::vector<IR_ArrayRef *> a = FindArrayRef(r); + delete r; + std::copy(a.begin(), a.end(), back_inserter(arrays)); + }*/ + else if (isSgVariableDeclaration(stmt)) { + if (SgExpression *init = + isSgVariableDeclaration(stmt)->get_variables().front()->get_initializer()) { + if (isSgAssignInitializer(init)) { + std::vector<SgVarRefExp *> a = substitute( + isSgAssignInitializer(init)->get_operand(), sym, + expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } + } + } else if (isSgIfStmt(stmt)) { + SgIfStmt* tni = isSgIfStmt(stmt); + //tni->get_conditional()->set_parent(tni); + //tni->get_true_body()->set_parent(tni); + //tni->get_false_body()->set_parent(tni); + std::vector<SgVarRefExp *> a = substitute( + isSgNode(tni->get_conditional()), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + std::vector<SgVarRefExp *> a1 = substitute( + isSgNode(tni->get_true_body()), sym, expr, root); + std::copy(a1.begin(), a1.end(), back_inserter(arrays)); + std::vector<SgVarRefExp *> a2 = substitute( + isSgNode(tni->get_false_body()), sym, expr, root); + std::copy(a2.begin(), a2.end(), back_inserter(arrays)); + } else if (isSgExprStatement(stmt)) { + (isSgExprStatement(stmt)->get_expression())->set_parent( + isSgExprStatement(stmt)); + std::vector<SgVarRefExp *> a = substitute( + isSgNode(isSgExprStatement(stmt)->get_expression()), + sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } //end else if + } //end if + else { + op = isSgExpression(in); + // std::string x = isSgNode(op)->unparseToString(); + std::string y = sym->get_name().getString(); +// std::cout << "------substitute else:: " << in->unparseToString().c_str() << ", " << y.c_str() << "\n"; + + if (isSgBinaryOp(op)) { + + isSgBinaryOp(op)->get_lhs_operand()->set_parent(op); + isSgBinaryOp(op)->get_rhs_operand()->set_parent(op); + + std::vector<SgVarRefExp *> a = substitute( + isSgBinaryOp(op)->get_lhs_operand(), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + std::vector<SgVarRefExp *> a1 = substitute( + isSgBinaryOp(op)->get_rhs_operand(), sym, expr, root); + std::copy(a1.begin(), a1.end(), back_inserter(arrays)); + } else if (isSgUnaryOp(op)) { + //isSgUnaryOp(op)->get_operand()->set_parent(op); + //std::string x = isSgNode(op)->unparseToString(); + //std::cout<<x<<std::endl; + std::vector<SgVarRefExp *> a = substitute( + isSgUnaryOp(op)->get_operand(), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } else if (isSgVarRefExp(op)) { + std::string z = + isSgVarRefExp(op)->get_symbol()->get_name().getString(); + if (!strcmp(z.c_str(), y.c_str())) { + //isSgVarRefExp(op)->set_symbol(isSgVarRefExp(expr)->get_symbol()); + arrays.push_back(isSgVarRefExp(op)); + //replaceVariableReferences(root, isSgVarRefExp(in)->get_symbol(), temp); + //r = true; + } //end if + } //end else if + else if (isSgCallExpression(op)) { + SgExprListExp* exprs = isSgCallExpression(op)->get_args(); + SgExpressionPtrList &expr_list = exprs->get_expressions(); + + for (SgExpressionPtrList::iterator it = expr_list.begin(); + it != expr_list.end(); it++) { + std::vector<SgVarRefExp *> a = substitute(isSgNode(*it), + sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } + } else if (isSgExprListExp(op)) { // Manu:: fortran indices are stored this way + SgExpressionPtrList &expr_list = isSgExprListExp(op)->get_expressions(); + + for (SgExpressionPtrList::iterator it = expr_list.begin(); + it != expr_list.end(); it++) { + std::vector<SgVarRefExp *> a = substitute(isSgNode(*it), + sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } + + } + + //end else if + //else if(!isSgValueExp(op)) + // throw ir_error("unrecognized expression type"); + } //end else + } //end if + + /* bool r = false; + if (isSgVarRefExp(in) && (isSgVarRefExp(in)->get_symbol() == sym)) { + omega::CG_roseRepr *result = new omega::CG_roseRepr(expr); + SgExpression* expr1 = result->GetExpression(); + delete result; + SgVariableSymbol* temp = isSgVarRefExp(expr1)->get_symbol(); + parent->replace_expression(in, expr1); + replaceVariableReferences(root, isSgVarRefExp(in)->get_symbol(), temp); + r = true; + } + else if(isSgBinaryOp(in)){ + substitute(isSgBinaryOp(in)->get_lhs_operand(), sym, expr, root, in); + substitute(isSgBinaryOp(in)->get_rhs_operand(), sym, expr, root, in); + } + else if(isSgUnaryOp(in)) + substitute(isSgUnaryOp(in)->get_operand(), sym, expr, root, in); + + */ + + return arrays; +} + +/*bool substitute(SgStatement *tn, SgVariableSymbol *sym, SgExpression* expr, SgNode* root, SgSymbolTable* symtab) { + if (tn == NULL) + return false; + + bool r = false; + if( tn != NULL){ + if(isSgExpression(tn)){ + r = substitute(isSgExpression(tn), sym, expr, root, isSgExpression(tn)) || r; + + } + else { + omega::CG_roseRepr *result = new omega::CG_roseRepr(expr); + SgExpression* expr1 = result->GetExpression(); + tn->replace_expression(buildVarRefExp(sym), expr1); + for (unsigned i = 0; i < tn->get_numberOfTraversalSuccessors(); i++) + r = substitute(isSgStatement(tn->get_traversalSuccessorByIndex(i)), sym, expr, root, symtab) || r; + + } + } + return r; + } + + bool substitute(SgNode *tnl, SgVariableSymbol *sym, SgExpression* expr, SgNode* root, SgSymbolTable* symtab) { + if (tnl == NULL) + return false; + + bool r = false; + + for(int i=0; i < tnl->get_numberOfTraversalSuccessors(); i++){ + + SgNode* tn = tnl->get_traversalSuccessorByIndex(i); + r = substitute(isSgStatement(tn), sym, expr, root, symtab) || r; + } + + + return r; + } + */ + +} // namespace diff --git a/omegalib/code_gen/src/CG_roseRepr.cc b/omegalib/code_gen/src/CG_roseRepr.cc new file mode 100644 index 0000000..99cf973 --- /dev/null +++ b/omegalib/code_gen/src/CG_roseRepr.cc @@ -0,0 +1,176 @@ +/***************************************************************************** + Copyright (C) 2008 University of Southern California. + All Rights Reserved. + + Purpose: + omega holder for suif implementaion + + Notes: + + History: + 02/01/06 - Chun Chen - created +*****************************************************************************/ + +#include <code_gen/CG_roseRepr.h> +#include <code_gen/rose_attributes.h> +#include <stdio.h> +#include <string.h> +#include <cstring> +namespace omega { + + + + +CG_roseRepr::CG_roseRepr(): tnl_(NULL), op_(NULL), list_(NULL){ + +} + +CG_roseRepr::CG_roseRepr(SgNode *tnl): tnl_(tnl), op_(NULL),list_(NULL) { +} + +CG_roseRepr::CG_roseRepr(SgExpression* op): tnl_(NULL), op_(op),list_(NULL){ +} +CG_roseRepr::CG_roseRepr(SgStatementPtrList* stmtlist):tnl_(NULL), op_(NULL), list_(stmtlist){ +} + +CG_roseRepr::~CG_roseRepr() { + // delete nothing here. operand or tree_node_list should already be + // grafted to other expression tree or statement list +} + +CG_outputRepr* CG_roseRepr::clone() const { + + if( tnl_ != NULL) { + SgTreeCopy tc; + SgNode *tnl = tnl_->copy(tc); + copyAttributes(tnl_, tnl); + + tnl->set_parent(tnl_->get_parent()); + return new CG_roseRepr(tnl); + } + else if(op_ != NULL) + { + SgTreeCopy tc1; + SgNode* op = isSgNode(op_)->copy(tc1); + copyAttributes(op_, op); + + op->set_parent(isSgNode(op_)->get_parent()); + return new CG_roseRepr(isSgExpression(op)); + } + else if(list_ != NULL) + { + SgStatementPtrList* list2 = new SgStatementPtrList; + + for(SgStatementPtrList::iterator it = (*list_).begin(); it != (*list_).end(); it++){ + SgTreeCopy tc3; + SgNode *tnl2 = isSgNode(*it)->copy(tc3); + copyAttributes(*it, tnl2); + + tnl2->set_parent(isSgNode(*it)->get_parent()); + + (*list2).push_back(isSgStatement(tnl2)); + } + return new CG_roseRepr(list2); + } + + return NULL; +} + +void CG_roseRepr::clear() { + if(tnl_ != NULL) { + delete tnl_; + tnl_ = NULL; + } +} + +SgNode* CG_roseRepr::GetCode() const { + return tnl_; +} + +SgStatementPtrList* CG_roseRepr::GetList() const { + return list_; +} + +SgExpression* CG_roseRepr::GetExpression() const { + return op_; +} +void CG_roseRepr::Dump() const { +SgNode* tnl = tnl_; +SgExpression* op = op_ ; + if(tnl != NULL) + DumpFileHelper(tnl, stdout); + else if(op != NULL) + DumpFileHelper(isSgNode(op), stdout); + +} + +void CG_roseRepr::DumpFileHelper(SgNode* node, FILE *fp) const{ + std::string x; + size_t numberOfSuccessors = node->get_numberOfTraversalSuccessors(); + if(numberOfSuccessors == 0){ + x = node->unparseToString (); + fprintf(fp, "%s", x.c_str()); + } + else{ + for (size_t idx = 0; idx < numberOfSuccessors; idx++) + { + SgNode *child = NULL; + child = node->get_traversalSuccessorByIndex(idx); + DumpFileHelper(child, fp); + } + +} +} + +/*void CG_roseRepr::DumpToFile(FILE *fp) const { +// std::string x; +SgNode* tnl = tnl_; +SgExpression* op = op_ ; + +if(tnl!= NULL){ + std::string x = tnl->unparseToString(); + fprintf(fp, "%s", x.c_str()); + +} +else if(op != NULL){ + std::string x = isSgNode(op)->unparseToString(); + fprintf(fp, "%s", x.c_str()); + + + +} +} +*/ +/* +SgNode* CG_roseRepr::copyAST ( SgNode* node ) +{ + +// This is a better implementation using a derived class from SgCopyHelp to control the +// copying process (skipping the copy of any function definition). This is a variable +// declaration with an explicitly declared class type. +class RestrictedCopyType : public SgCopyHelp + { + // DQ (9/26/2005): This class demonstrates the use of the copy mechanism + // within Sage III (originally designed and implemented by Qing Yi). + // One problem with it is that there is no context information permitted. + + public: + virtual SgNode *copyAst(const SgNode *n) + { + // This is the simpliest possible version of a deep copy SgCopyHelp::copyAst() member function. + SgNode *returnValue = n->copy(*this); + + return returnValue; + } + } restrictedCopyType; + + + + +// This triggers a bug with test2005_152.C (the unparsed code fails for g++ 4.1.2, but not 3.5.6) +SgNode* copyOfNode = node->copy(restrictedCopyType); +return copyOfNode; + +} +*/ +} // namespace diff --git a/omegalib/code_gen/src/CG_stringBuilder.cc b/omegalib/code_gen/src/CG_stringBuilder.cc new file mode 100644 index 0000000..2f9286f --- /dev/null +++ b/omegalib/code_gen/src/CG_stringBuilder.cc @@ -0,0 +1,487 @@ +/***************************************************************************** + Copyright (C) 1994-2000 the Omega Project Team + Copyright (C) 2005-2011 Chun Chen + All Rights Reserved. + + Purpose: + generate pseudo string code + + Notes: + There is no need to check illegal NULL parameter and throw invalid_argument + in other IR interface implementation. They are for debugging purpose. + intMod implements modular function that returns positve remainder no matter + lop is postive or nagative and rop is guranteed to be positive here. + + History: + 04/17/96 - Lei Zhou - created + 08/31/09 add parenthesis to string operands, Chun Chen +*****************************************************************************/ + +#include <code_gen/CG_stringBuilder.h> +#include <code_gen/codegen_error.h> +#include <basic/util.h> +#include <string> +#include <stdexcept> +#include <ctype.h> +#include <string.h> + +namespace { + +std::string SafeguardString(const std::string &s, char op) { + int len = s.length(); + int paren_level = 0; + int num_plusminus = 0; + int num_mul = 0; + int num_div = 0; + for (int i = 0; i < len; i++) + switch (s[i]) { + case '(': + paren_level++; + break; + case ')': + paren_level--; + break; + case '+': + case '-': + if (paren_level == 0) + num_plusminus++; + break; + case '*': + if (paren_level == 0) + num_mul++; + break; + case '/': + if (paren_level == 0) + num_div++; + break; + default: + break; + } + + bool need_paren = false; + switch (op) { + case '-': + if (num_plusminus > 0) + need_paren = true; + break; + case '*': + if (num_plusminus > 0 || num_div > 0) + need_paren = true; + break; + case '/': + if (num_plusminus > 0 || num_div > 0 || num_mul > 0) + need_paren = true; + break; + default: + break; + } + + if (need_paren) + return "(" + s + ")"; + else + return s; +} + + +std::string GetIndentSpaces(int indent) { + std::string indentStr; + for (int i = 1; i < indent; i++) { + indentStr += " "; + } + return indentStr; +} + + +// A shortcut to extract the string enclosed in the CG_outputRepr and delete +// the original holder. +std::string GetString(omega::CG_outputRepr *repr) { + std::string result = static_cast<omega::CG_stringRepr *>(repr)->GetString(); + delete repr; + return result; +} + +} + + +namespace omega { + + + +//----------------------------------------------------------------------------- +// Class: CG_stringBuilder +//----------------------------------------------------------------------------- + +CG_stringRepr *CG_stringBuilder::CreateSubstitutedStmt(int indent, CG_outputRepr *stmt, + const std::vector<std::string> &vars, + std::vector<CG_outputRepr *> &subs) const { + std::string listStr = ""; + + for (int i = 0; i < subs.size(); i++) { + if (subs[i] == NULL) + listStr += "N/A"; + else + listStr += GetString(subs[i]); + if (i < subs.size() - 1) + listStr += ","; + } + + std::string stmtName = GetString(stmt); + std::string indentStr = GetIndentSpaces(indent); + + return new CG_stringRepr(indentStr + stmtName + "(" + listStr + ");\n"); +} + +CG_stringRepr *CG_stringBuilder::CreateAssignment(int indent, + CG_outputRepr *lhs, + CG_outputRepr *rhs) const { + if (lhs == NULL || rhs == NULL) + throw std::invalid_argument("missing lhs or rhs in assignment"); + + std::string lhsStr = GetString(lhs); + std::string rhsStr = GetString(rhs); + + std::string indentStr = GetIndentSpaces(indent); + + return new CG_stringRepr(indentStr + lhsStr + "=" + rhsStr + ";\n"); +} + + +CG_stringRepr *CG_stringBuilder::CreateInvoke(const std::string &funcName, + std::vector<CG_outputRepr *> &list) const { + std::string listStr = ""; + + for (int i = 0; i < list.size(); i++) { + listStr += GetString(list[i]); + if ( i < list.size()-1) + listStr += ","; + } + + return new CG_stringRepr(funcName + "(" + listStr + ")"); +} + + +CG_stringRepr *CG_stringBuilder::CreateComment(int indent, const std::string &commentText) const { + if (commentText == std::string("")) { + return NULL; + } + + std::string indentStr = GetIndentSpaces(indent); + + return new CG_stringRepr(indentStr + "// " + commentText + "\n"); +} + +CG_stringRepr* CG_stringBuilder::CreateAttribute(CG_outputRepr *control, + const std::string &commentText) const { + if (commentText == std::string("")) { + return static_cast<CG_stringRepr *> (control); + } + + std::string controlString = GetString(control); + + return new CG_stringRepr("// " + commentText + "\n" + controlString); + +} + +CG_outputRepr* CG_stringBuilder::CreatePragmaAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &pragmaText) const { + // -- Not Implemented + return scopeStmt; +} + +CG_outputRepr* CG_stringBuilder::CreatePrefetchAttribute(CG_outputRepr* scopeStmt, int looplevel, const std::string& arrName, int hint) const { + // -- Not Implemented + return scopeStmt; +} + +CG_stringRepr *CG_stringBuilder::CreateIf(int indent, CG_outputRepr *guardList, + CG_outputRepr *true_stmtList, CG_outputRepr *false_stmtList) const { + if (guardList == NULL) + throw std::invalid_argument("missing if condition"); + + if (true_stmtList == NULL && false_stmtList == NULL) { + delete guardList; + return NULL; + } + + std::string guardListStr = GetString(guardList); + std::string indentStr = GetIndentSpaces(indent); + std::string s; + if (true_stmtList != NULL && false_stmtList == NULL) { + s = indentStr + "if (" + guardListStr + ") {\n" + + GetString(true_stmtList) + + indentStr + "}\n"; + } + else if (true_stmtList == NULL && false_stmtList != NULL) { + s = indentStr + "if !(" + guardListStr + ") {\n" + + GetString(false_stmtList) + + indentStr + "}\n"; + } + else { + s = indentStr + "if (" + guardListStr + ") {\n" + + GetString(true_stmtList) + + indentStr + "}\n" + + indentStr + "else {\n" + + GetString(false_stmtList) + + indentStr + "}\n"; + } + + return new CG_stringRepr(s); +} + + + +CG_stringRepr *CG_stringBuilder::CreateInductive(CG_outputRepr *index, + CG_outputRepr *lower, CG_outputRepr *upper, + CG_outputRepr *step) const { + if (index == NULL) + throw std::invalid_argument("missing loop index"); + if (lower == NULL) + throw std::invalid_argument("missing loop lower bound"); + if (upper == NULL) + throw std::invalid_argument("missing loop upper bound"); + if (step == NULL) + throw std::invalid_argument("missing loop step size"); + + std::string indexStr = GetString(index); + std::string lowerStr = GetString(lower); + std::string upperStr = GetString(upper); + + std::string doStr = "for(" + indexStr + " = " + lowerStr + "; " + + indexStr + " <= " + upperStr + "; " + + indexStr; + + std::string stepStr = GetString(step); + if (stepStr == to_string(1)) + doStr += "++"; + else + doStr += " += " + stepStr; + + doStr += ")"; + + return new CG_stringRepr(doStr); +} + + +CG_stringRepr *CG_stringBuilder::CreateLoop(int indent, CG_outputRepr *control, + CG_outputRepr *stmtList) const { + if (stmtList == NULL) { + delete control; + return NULL; + } + else if (control == NULL) + return static_cast<CG_stringRepr *>(stmtList); + + std::string ctrlStr = GetString(control); + std::string stmtStr = GetString(stmtList); + + std::string indentStr = GetIndentSpaces(indent); + + std::string s = indentStr + ctrlStr + " {\n" + + stmtStr + + indentStr + "}\n"; + + return new CG_stringRepr(s); +} + + + +CG_stringRepr *CG_stringBuilder::CreateInt(int num) const { + std::string s = to_string(num); + return new CG_stringRepr(s); +} + + + +bool CG_stringBuilder::isInteger(CG_outputRepr *op) const { + + char * cstr; + std::string s = GetString(op); + cstr = new char [s.size()+1]; + strcpy (cstr, s.c_str()); + int count = 0; + while(cstr[count] != '\n' && cstr[count] != '\0' ) + if( !isdigit(cstr[count])) + return false; + + + return true; +} + + + +CG_stringRepr *CG_stringBuilder::CreateIdent(const std::string &varName) const { + if (varName == std::string("")) { + return NULL; + } + + return new CG_stringRepr(varName); +} + + +CG_stringRepr *CG_stringBuilder::CreatePlus(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) { + return static_cast<CG_stringRepr *>(lop); + } + else if (lop == NULL) { + return static_cast<CG_stringRepr *>(rop); + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + "+" + ropStr); +} + + +CG_stringRepr *CG_stringBuilder::CreateMinus(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) { + return static_cast<CG_stringRepr *>(lop); + } + else if (lop == NULL) { + std::string ropStr = GetString(rop); + return new CG_stringRepr("-" + SafeguardString(ropStr, '-')); + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + "-" + SafeguardString(ropStr, '-')); +} + + +CG_stringRepr *CG_stringBuilder::CreateTimes(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) { + delete rop; + delete lop; + return NULL; + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(SafeguardString(lopStr, '*') + "*" + SafeguardString(ropStr, '*')); +} + + +CG_stringRepr *CG_stringBuilder::CreateDivide(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) + throw codegen_error("integer division by zero"); + else if (lop == NULL) { + delete rop; + return NULL; + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(SafeguardString(lopStr, '/') + "/" + SafeguardString(ropStr, '/')); +} + + +CG_stringRepr *CG_stringBuilder::CreateIntegerFloor(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) + throw codegen_error("integer division by zero"); + else if (lop == NULL) { + delete rop; + return NULL; + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr("intFloor(" + lopStr + "," + ropStr + ")"); +} + + +CG_stringRepr *CG_stringBuilder::CreateIntegerMod(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) + throw codegen_error("integer modulo by zero"); + else if (lop == NULL) { + delete rop; + return NULL; + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr("intMod(" + lopStr + "," + ropStr + ")"); +} + +CG_stringRepr *CG_stringBuilder::CreateIntegerCeil(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == 0) + throw codegen_error("integer ceiling by zero"); + else if (lop == NULL) { + delete rop; + return NULL; + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr("intCeil(" + lopStr + "," + ropStr + ")"); +} + + +CG_stringRepr *CG_stringBuilder::CreateAnd(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) + return static_cast<CG_stringRepr *>(lop); + else if (lop == NULL) + return static_cast<CG_stringRepr *>(rop); + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + " && " + ropStr); +} + + +CG_stringRepr *CG_stringBuilder::CreateGE(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) + throw std::invalid_argument("missing operand in greater than equal comparison condition"); + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + " >= " + ropStr); +} + + + +CG_stringRepr *CG_stringBuilder::CreateLE(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) + throw std::invalid_argument("missing operand in less than equal comparison condition"); + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + " <= " + ropStr); +} + + + +CG_stringRepr *CG_stringBuilder::CreateEQ(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) + throw std::invalid_argument("missing operand in equal comparison condition"); + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + " == " + ropStr); +} + + + +CG_stringRepr *CG_stringBuilder::StmtListAppend(CG_outputRepr *list1, CG_outputRepr *list2) const { + if (list2 == NULL) { + return static_cast<CG_stringRepr *>(list1); + } + else if (list1 == NULL) { + return static_cast<CG_stringRepr *>(list2); + } + + std::string list1Str = GetString(list1); + std::string list2Str = GetString(list2); + + return new CG_stringRepr(list1Str + list2Str); +} + +} diff --git a/omegalib/code_gen/src/CG_stringRepr.cc b/omegalib/code_gen/src/CG_stringRepr.cc new file mode 100644 index 0000000..63a1657 --- /dev/null +++ b/omegalib/code_gen/src/CG_stringRepr.cc @@ -0,0 +1,54 @@ +/***************************************************************************** + Copyright (C) 1994-2000 University of Maryland + Copyright (C) 2008 University of Southern California + Copyright (C) 2009 University of Utah + All Rights Reserved. + + Purpose: + omega holder for string implementation. + + Notes: + + History: + 04/17/96 - Lei Zhou - created +*****************************************************************************/ + +#include <code_gen/CG_stringRepr.h> +#include <stdio.h> + +namespace omega { + +CG_stringRepr::CG_stringRepr() { +} + +CG_stringRepr::CG_stringRepr(const std::string& _s) : s(_s) { +} + +CG_stringRepr::~CG_stringRepr() { +} + +CG_outputRepr* CG_stringRepr::clone() { + return new CG_stringRepr(s); +} + + +//----------------------------------------------------------------------------- +// basic operation +//----------------------------------------------------------------------------- +std::string CG_stringRepr::GetString() const { + return s; +} + + +//----------------------------------------------------------------------------- +// Dump operations +//----------------------------------------------------------------------------- +void CG_stringRepr::Dump() const { + printf("%s\n", s.c_str()); +} + +void CG_stringRepr::DumpToFile(FILE *fp) const { + fprintf(fp,"%s", s.c_str()); +} + +} // namespace diff --git a/omegalib/code_gen/src/CG_suifBuilder.cc b/omegalib/code_gen/src/CG_suifBuilder.cc new file mode 100644 index 0000000..6bb91b7 --- /dev/null +++ b/omegalib/code_gen/src/CG_suifBuilder.cc @@ -0,0 +1,678 @@ +/***************************************************************************** + Copyright (C) 2008 University of Southern California + Copyright (C) 2009-2010 University of Utah + All Rights Reserved. + + Purpose: + generate suif code for omega + + Notes: + + History: + 02/01/06 created by Chun Chen +*****************************************************************************/ + +#include <stack> +#include <code_gen/CG_suifBuilder.h> +#include <suif1/annote.h> +#include <vector> + +namespace omega { + +//----------------------------------------------------------------------------- +// make suif initilization happy +//----------------------------------------------------------------------------- +char *k_ocg_comment; +char *k_s2c_pragma; +char *k_cuda_dim3; +char *k_cuda_kernel; +char *k_cuda_modifier; +char *k_cuda_texture_memory; //protonu--added to track texture memory type + +// void __attribute__ ((constructor)) my_init(void) { +// ANNOTE(k_ocg_comment, "omega_comment", TRUE); +// } + +//protonu--extern decls +//protonu--adding stuff to make Chun's code work with Gabe's +extern Tuple< Tuple<int> > smtNonSplitLevels; +extern Tuple< Tuple<std::string> > loopIdxNames;//per stmt +extern std::vector< std::pair<int, std::string> > syncs; +extern int checkLoopLevel; +extern int stmtForLoopCheck; +extern int upperBoundForLevel; +extern int lowerBoundForLevel; +extern bool fillInBounds; + + +const char *libcode_gen_ver_string = ""; +const char *libcode_gen_who_string = ""; +const char *libcode_gen_suif_string = ""; + + +void init_code_gen() { + static bool isInit = false; + if(!isInit) + { + isInit = true; + ANNOTE(k_ocg_comment, "omega_comment", TRUE); + ANNOTE(k_s2c_pragma, "s2c pragma", TRUE); + ANNOTE(k_cuda_dim3, "cuda dim3", TRUE); + ANNOTE(k_cuda_kernel, "cuda kernel", TRUE); + ANNOTE(k_cuda_modifier, "cuda modifier", TRUE); + } +} + + +void exit_code_gen(void) { +} + + +//----------------------------------------------------------------------------- +// Class: CG_suifBuilder +//----------------------------------------------------------------------------- + +CG_suifBuilder::CG_suifBuilder(proc_symtab *symtab) +{ + symtab_ = symtab; + init_code_gen(); +} + +CG_outputRepr* CG_suifBuilder::CreatePlaceHolder (int, CG_outputRepr *stmt, + Tuple<CG_outputRepr*> &funcList, Tuple<std::string> &loop_vars) const { + tree_node_list *tnl = static_cast<CG_suifRepr *>(stmt)->tnl_; + delete stmt; + + for (int i = 1; i <= funcList.size(); i++) { + if (funcList[i] == NULL) + continue; + + CG_suifRepr *repr = static_cast<CG_suifRepr*>(funcList[i]); + operand op = repr->op_; + delete repr; + + var_sym *vs = static_cast<var_sym*>(symtab_->lookup_sym(loop_vars[i].c_str(), SYM_VAR)); + + substitute(tnl, vs, op, symtab_); + + if (op.is_instr()) + delete op.instr(); + } + + return new CG_suifRepr(tnl); +} + + +CG_outputRepr* CG_suifBuilder::CreateAssignment(int, CG_outputRepr *lhs, + CG_outputRepr *rhs) const { + if ( lhs == NULL || rhs == NULL ) { + fprintf(stderr, "Code generation: Missing lhs or rhs\n"); + return NULL; + } + + operand src = static_cast<CG_suifRepr*>(rhs)->op_; + if (src.is_instr() && src.instr()->opcode() == io_array) { + in_array *ia = static_cast<in_array *>(src.instr()); + instruction *ins = new in_rrr(io_lod, ia->elem_type(), operand(), ia); + src = operand(ins); + } + + instruction *ins; + operand dst = static_cast<CG_suifRepr*>(lhs)->op_; + if (dst.is_instr() && dst.instr()->opcode() == io_array) { + in_array *ia = static_cast<in_array *>(dst.instr()); + ins = new in_rrr(io_str, type_void, operand(), operand(ia), src); + } + else + ins = new in_rrr(io_cpy, src.type(), dst, src); + + delete lhs; + delete rhs; + + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + + return new CG_suifRepr(tnl); +} + + +CG_outputRepr* CG_suifBuilder::CreateInvoke(const std::string &fname, + Tuple<CG_outputRepr*> &list) const { + if (fname == std::string("max") || fname == std::string("min")) { + if (list.size() == 0) { + return NULL; + } + else if (list.size() == 1) { + return list[1]; + } + else { + int last = list.size(); + operand op2 = static_cast<CG_suifRepr*>(list[last])->op_; + delete list[last]; + list.delete_last(); + CG_suifRepr *repr = static_cast<CG_suifRepr*>(CreateInvoke(fname, list)); + operand op1 = repr->op_; + + instruction *ins; + if (fname == std::string("max")) + ins = new in_rrr(io_max, op1.type(), operand(), op1, op2); + else + ins = new in_rrr(io_min, op1.type(), operand(), op1, op2); + + repr->op_ = operand(ins); + + return repr; + } + } + else { + fprintf(stderr, "Code generation: invoke function io_call not implemented\n"); + return NULL; + } +} + + +CG_outputRepr* CG_suifBuilder::CreateAttribute(CG_outputRepr *control, + const std::string &commentText)const { + if (commentText == std::string("")) { + return control; + } + + instruction *ins = new in_rrr(io_mrk); + + immed_list *iml = new immed_list; + iml->append(immed(const_cast<char *>(commentText.c_str()))); + ins->prepend_annote(k_ocg_comment, iml); + + tree_node_list *tnl ; + tnl = static_cast<CG_suifRepr*>(control)->tnl_; + tnl->append(new tree_instr(ins)); + + + return new CG_suifRepr(tnl); + + +} + + + +CG_outputRepr* CG_suifBuilder::CreateComment(int, const std::string &commentText) const { + if ( commentText == std::string("") ) { + return NULL; + } + + instruction *ins = new in_rrr(io_mrk); + + immed_list *iml = new immed_list; + iml->append(immed(const_cast<char *>(commentText.c_str()))); + ins->prepend_annote(k_ocg_comment, iml); + + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + + return new CG_suifRepr(tnl); +} + + +CG_outputRepr* CG_suifBuilder::CreateIf(int, CG_outputRepr *guardList, + CG_outputRepr *true_stmtList, CG_outputRepr *false_stmtList) const { + static int if_counter = 1; + std::string s = std::string("omegaif_")+to_string(if_counter++); + label_sym *if_label = new label_sym(const_cast<char *>(s.c_str())); + symtab_->add_sym(if_label); + + if ( true_stmtList == NULL && false_stmtList == NULL ) { + delete guardList; + return NULL; + } + else if ( guardList == NULL ) { + return StmtListAppend(true_stmtList, false_stmtList); + } + + tree_node_list *header = new tree_node_list; + operand op = static_cast<CG_suifRepr*>(guardList)->op_; + + std::stack<void *> S; + S.push(op.instr()); + while(!S.empty()) { + instruction *ins = static_cast<instruction *>(S.top()); + S.pop(); + if (ins->opcode() == io_and) { + instruction *ins1 = ins->src_op(0).instr(); + ins1->remove(); + S.push(ins1); + instruction *ins2 = ins->src_op(1).instr(); + ins2->remove(); + S.push(ins2); + delete ins; + } + else { + ins = new in_bj(io_bfalse, if_label, operand(ins)); + header->append(new tree_instr(ins)); + } + } + + tree_node_list *then_part, *else_part; + if (true_stmtList != NULL) + then_part = static_cast<CG_suifRepr*>(true_stmtList)->tnl_; + else + then_part = NULL; + if (false_stmtList != NULL) + else_part = static_cast<CG_suifRepr*>(false_stmtList)->tnl_; + else + else_part = NULL; + tree_if *ti = new tree_if(if_label, header, then_part, else_part); + + tree_node_list *tnl = new tree_node_list; + tnl->append(ti); + + delete guardList; + delete true_stmtList; + delete false_stmtList; + + return new CG_suifRepr(tnl); +} + + +CG_outputRepr* CG_suifBuilder::CreateInductive(CG_outputRepr *index, + CG_outputRepr *lower, + CG_outputRepr *upper, + CG_outputRepr *step) const { + if ( index == NULL || lower == NULL || upper == NULL ) { + fprintf(stderr, "Code generation: something wrong in CreateInductive\n"); + return NULL; + } + + if (step == NULL) + step = CreateInt(1); + + var_sym *index_sym = static_cast<CG_suifRepr*>(index)->op_.symbol(); + operand lower_bound = static_cast<CG_suifRepr*>(lower)->op_; + operand upper_bound = static_cast<CG_suifRepr*>(upper)->op_; + operand step_size = static_cast<CG_suifRepr*>(step)->op_; + + label_sym *contLabel = new label_sym(""); + label_sym *brkLabel = new label_sym(""); + symtab_->add_sym(contLabel); + symtab_->add_sym(brkLabel); + tree_for *tf = new tree_for(index_sym, FOR_SLTE, contLabel, brkLabel, NULL, + lower_bound, upper_bound, step_size, NULL); + + tree_node_list *tnl = new tree_node_list; + tnl->append(tf); + + delete index; + delete lower; + delete upper; + delete step; + + return new CG_suifRepr(tnl); +} + + +CG_outputRepr* CG_suifBuilder::CreateLoop(int, CG_outputRepr *control, + CG_outputRepr *stmtList) const { + if ( stmtList == NULL ) { + delete control; + return NULL; + } + else if ( control == NULL ) { + fprintf(stderr, "Code generation: no inductive for this loop\n"); + return stmtList; + } + + tree_node_list *tnl = static_cast<CG_suifRepr*>(control)->tnl_; + tree_node_list_iter iter(tnl); + tree_for *tf = static_cast<tree_for*>(iter.step()); + + tree_node_list *body = static_cast<CG_suifRepr*>(stmtList)->tnl_; + tf->set_body(body); + + delete stmtList; + + return control; +} + + +CG_outputRepr* CG_suifBuilder::CreateInt(int _i) const { + in_ldc *ins = new in_ldc(type_s32, operand(), immed(_i)); + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateIdent(const std::string &_s) const { + if ( &_s == NULL || _s == std::string("") ) { + return NULL; + } + + var_sym *vs = static_cast<var_sym*>(symtab_->lookup_sym(_s.c_str(), SYM_VAR)); + + if (vs == NULL) { + vs = new var_sym(type_s32, const_cast<char*>(_s.c_str())); + symtab_->add_sym(vs); + } + + return new CG_suifRepr(operand(vs)); +} + + +CG_outputRepr* CG_suifBuilder::CreatePlus(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL ) { + return lop; + } + else if ( lop == NULL ) { + return rop; + } + + operand op1 = static_cast<CG_suifRepr*>(lop)->op_; + operand op2 = static_cast<CG_suifRepr*>(rop)->op_; + + instruction *ins = new in_rrr(io_add, op1.type(), operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateMinus(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL ) { + return lop; + } + else if ( lop == NULL ) { + operand op = static_cast<CG_suifRepr*>(rop)->op_; + instruction *ins = new in_rrr(io_neg, op.type(), operand(), op); + + delete rop; + + return new CG_suifRepr(operand(ins)); + } + else { + operand op1 = static_cast<CG_suifRepr*>(lop)->op_; + operand op2 = static_cast<CG_suifRepr*>(rop)->op_; + + instruction *ins = new in_rrr(io_sub, op1.type(), operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); + } +} + + +CG_outputRepr* CG_suifBuilder::CreateTimes(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL || lop == NULL) { + if (rop != NULL) { + rop->clear(); + delete rop; + } + if (lop != NULL) { + lop->clear(); + delete lop; + } + return NULL; + } + + operand op1 = static_cast<CG_suifRepr*>(lop)->op_; + operand op2 = static_cast<CG_suifRepr*>(rop)->op_; + + instruction *ins = new in_rrr(io_mul, op1.type(), operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateIntegerDivide(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL ) { + fprintf(stderr, "Code generation: divide by NULL\n"); + return NULL; + } + else if ( lop == NULL ) { + delete rop; + return NULL; + } + + // (6+5)*10 / 4 + operand op1 = static_cast<CG_suifRepr*>(lop)->op_; + operand op2 = static_cast<CG_suifRepr*>(rop)->op_; + + // bugs in SUIF prevent use of correct io_divfloor + instruction *ins = new in_rrr(io_div, op1.type(), operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateIntegerMod(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL || lop == NULL ) { + return NULL; + } + + operand op1 = static_cast<CG_suifRepr*>(lop)->op_; + operand op2 = static_cast<CG_suifRepr*>(rop)->op_; + + // bugs in SUIF prevent use of correct io_mod + instruction *ins = new in_rrr(io_rem, type_s32, operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateAnd(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL) + return lop; + else if (lop == NULL) + return rop; + + operand op1 = static_cast<CG_suifRepr*>(lop)->op_; + operand op2 = static_cast<CG_suifRepr*>(rop)->op_; + + instruction *ins = new in_rrr(io_and, op1.type(), operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateGE(CG_outputRepr *lop, + CG_outputRepr *rop) const { + return CreateLE(rop, lop); +} + + +CG_outputRepr* CG_suifBuilder::CreateLE(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL || lop == NULL ) { + return NULL; + } + + operand op1 = static_cast<CG_suifRepr*>(lop)->op_; + operand op2 = static_cast<CG_suifRepr*>(rop)->op_; + + instruction *ins = new in_rrr(io_sle, type_s32, operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateEQ(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL || lop == NULL ) { + return NULL; + } + + operand op1 = static_cast<CG_suifRepr*>(lop)->op_; + operand op2 = static_cast<CG_suifRepr*>(rop)->op_; + + instruction *ins = new in_rrr(io_seq, type_s32, operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + + +CG_outputRepr* CG_suifBuilder::StmtListAppend(CG_outputRepr *list1, + CG_outputRepr *list2) const { + if ( list2 == NULL ) { + return list1; + } + else if ( list1 == NULL ) { + return list2; + } + + tree_node_list *tnl1 = static_cast<CG_suifRepr *>(list1)->tnl_; + tree_node_list *tnl2 = static_cast<CG_suifRepr *>(list2)->tnl_; + if (tnl2 == NULL) + tnl1->append(new tree_instr(static_cast<CG_suifRepr *>(list2)->op_.instr())); + else + tnl1->append(tnl2); + + delete list2; + + return list1; +} + +//protonu--Gabe's stuff added here +//----------------------------------------------------------------------------- +// pragma generation +// TODO: Could allow for a immed_list* instead of a String for strongly typed prgma args +//----------------------------------------------------------------------------- +CG_outputRepr* CG_suifBuilder::CreatePragma(int, + const std::string &pragmaText) const { + if ( pragmaText == std::string("") ) { + return NULL; + } + instruction *ins = new in_rrr(io_mrk); + immed_list *iml = new immed_list; + iml->append(immed(const_cast<char*>(pragmaText.c_str()))); + ins->append_annote(k_s2c_pragma, iml); + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + return new CG_suifRepr(tnl); +} + +CG_outputRepr* CG_suifBuilder::CreateDim3(immed varName, immed arg1, immed arg2) const { + instruction *ins = new in_rrr(io_mrk); + immed_list *iml = new immed_list; + iml->append(immed(varName)); + iml->append(arg1); + iml->append(arg2); + ins->append_annote(k_cuda_dim3, iml); + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + return new CG_suifRepr(tnl); +} + +CG_outputRepr* CG_suifBuilder::CreateDim3(immed varName, immed arg1, immed arg2, immed arg3) const { + instruction *ins = new in_rrr(io_mrk); + immed_list *iml = new immed_list; + iml->append(immed(varName)); + iml->append(arg1); + iml->append(arg2); + iml->append(arg3); + ins->append_annote(k_cuda_dim3, iml); + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + return new CG_suifRepr(tnl); +} + +CG_outputRepr* CG_suifBuilder::CreateKernel(immed_list* iml) const { + instruction *ins = new in_rrr(io_mrk); + ins->append_annote(k_cuda_kernel, iml); + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + return new CG_suifRepr(tnl); +} + +type_node* CG_suifBuilder::ModifyType(type_node* base, const char* modifier) const { + modifier_type* result = new modifier_type(TYPE_NULL, base); + immed_list *iml = new immed_list; + iml->append(immed((char*)modifier)); + result->append_annote(k_cuda_modifier, iml); + return result; +} +//end-protonu + + +//----------------------------------------------------------------------------- +// suif utility +//----------------------------------------------------------------------------- + +bool substitute(instruction *in, var_sym *sym, operand expr, base_symtab *st) { + if (in == NULL || sym == NULL) + return false; + + bool r = false; + for (unsigned i = 0; i < in->num_srcs(); i++) { + operand op(in->src_op(i)); + + if (op.is_symbol() && op.symbol() == sym) { + in->set_src_op(i, expr.clone(st)); + r = true; + } + else if (op.is_instr()) { + r = substitute(op.instr(), sym, expr, st) || r; + } + } + + return r; +} + +bool substitute(tree_node *tn, var_sym *sym, operand expr, base_symtab *st) { + if (tn == NULL) + return false; + + bool r = false; + if (tn->kind() == TREE_INSTR) + r = substitute(static_cast<tree_instr*>(tn)->instr(), sym, expr, st) || r; + else { + for (unsigned i = 0; i < tn->num_child_lists(); i++) { + r = substitute(tn->child_list_num(i), sym, expr, st) || r; + } + } + + return r; +} + +bool substitute(tree_node_list *tnl, var_sym *sym, operand expr, + base_symtab *st) { + if (tnl == NULL) + return false; + + bool r = false; + tree_node_list_iter iter(tnl); + while (!iter.is_empty()) { + tree_node *tn = iter.step(); + + r = substitute(tn, sym, expr, st) || r; + } + + return r; +} + +} diff --git a/omegalib/code_gen/src/CG_suifRepr.cc b/omegalib/code_gen/src/CG_suifRepr.cc new file mode 100644 index 0000000..f4f987d --- /dev/null +++ b/omegalib/code_gen/src/CG_suifRepr.cc @@ -0,0 +1,81 @@ +/***************************************************************************** + Copyright (C) 2008 University of Southern California. + All Rights Reserved. + + Purpose: + omega holder for suif implementaion + + Notes: + + History: + 02/01/06 - Chun Chen - created +*****************************************************************************/ + +#include <code_gen/CG_suifRepr.h> +#include <stdio.h> + +namespace omega { + +CG_suifRepr::CG_suifRepr(): tnl_(NULL), op_() { +} + +CG_suifRepr::CG_suifRepr(tree_node_list *tnl): tnl_(tnl),op_() { +} + +CG_suifRepr::CG_suifRepr(operand op): tnl_(NULL), op_(op) { +} + +CG_suifRepr::~CG_suifRepr() { + // delete nothing here. operand or tree_node_list should already be + // grafted to other expression tree or statement list +} + +CG_outputRepr* CG_suifRepr::clone() { + if (!op_.is_null() ) { + operand op = op_.clone(); + return new CG_suifRepr(op); + } + else if (tnl_ != NULL) { + tree_node_list *tnl = tnl_->clone(); + return new CG_suifRepr(tnl); + } + else + return new CG_suifRepr(); +} + +void CG_suifRepr::clear() { + if (!op_.is_null()) { + if (op_.is_instr()) + delete op_.instr(); + op_.set_null(); + } + else if (tnl_ != NULL) { + delete tnl_; + tnl_ = NULL; + } +} + +tree_node_list* CG_suifRepr::GetCode() const { + return tnl_; +} + +operand CG_suifRepr::GetExpression() const { + return op_; +} + +void CG_suifRepr::Dump() const { + if (tnl_ != NULL) + tnl_->print(); + else if (!op_.is_null()) + op_.print(); +} + +void CG_suifRepr::DumpToFile(FILE *fp) const { + if (tnl_ != NULL) + tnl_->print(fp); + else if (!op_.is_null()) + op_.print(fp); +} + + +} // namespace diff --git a/omegalib/code_gen/src/CG_utils.cc b/omegalib/code_gen/src/CG_utils.cc new file mode 100755 index 0000000..d3a5f71 --- /dev/null +++ b/omegalib/code_gen/src/CG_utils.cc @@ -0,0 +1,1735 @@ +/***************************************************************************** + Copyright (C) 1994-2000 the Omega Project Team + Copyright (C) 2005-2011 Chun Chen + All Rights Reserved. + + Purpose: + Utility functions for processing CG tree. + + Notes: + + History: + 07/19/07 when generating output variable substitutions for a mapping + relation, map it to each output to get correct equality, -chun + 07/29/10 when translating equality to assignment, generate appropriate + if-condition when necesssary, -chun +*****************************************************************************/ + +#include <typeinfo> +#include <omega.h> +#include <code_gen/CG.h> +#include <code_gen/CG_utils.h> +#include <code_gen/codegen_error.h> +#include <math.h> +#include <stack> + +namespace omega { + +int checkLoopLevel; +int stmtForLoopCheck; +int upperBoundForLevel; +int lowerBoundForLevel; +bool fillInBounds; + +//trick to static init checkLoopLevel to 0 +class JunkStaticInit{ public: JunkStaticInit(){ checkLoopLevel=0; fillInBounds=false;} }; +static JunkStaticInit junkInitInstance__; + + + + +namespace { + +Relation find_best_guard(const Relation &R, const BoolSet<> &active, const std::map<int, Relation> &guards) { + std::pair<int, int> best_cost = std::make_pair(0, 0); + Relation best_cond = Relation::True(R.n_set()); + + Relation r = copy(R); + int max_iter_count = 2*(r.single_conjunct()->n_EQs()) + r.single_conjunct()->n_GEQs(); + int iter_count = 0; + while (!r.is_obvious_tautology()) { + std::pair<int, int> cost = std::make_pair(0, 0); + Relation cond = pick_one_guard(r); + Relation complement_cond = Complement(copy(cond)); + complement_cond.simplify(); + for (BoolSet<>::const_iterator i = active.begin(); i != active.end(); i++) { + std::map<int, Relation>::const_iterator j = guards.find(*i); + if (j == guards.end()) + continue; + if (Must_Be_Subset(copy(j->second), copy(cond))) + cost.first++; + else if (Must_Be_Subset(copy(j->second), copy(complement_cond))) + cost.second++; + } + if (cost > best_cost) { + best_cost = cost; + best_cond = copy(cond); + } + r = Gist(r, cond, 1); + + if (iter_count > max_iter_count) + throw codegen_error("guard condition too complex to handle"); + + iter_count++; + } + + return best_cond; +} + + +Relation find_best_guard(const Relation &R, const std::vector<CG_loop *> &loops, int start, int end) { + std::pair<int, int> best_cost = std::make_pair(0, 0); + Relation best_cond = Relation::True(R.n_set()); + + Relation r = copy(R); + int max_iter_count = 2*(r.single_conjunct()->n_EQs()) + r.single_conjunct()->n_GEQs(); + int iter_count = 0; + while (!r.is_obvious_tautology()) { + std::pair<int, int> cost = std::make_pair(0, 0); + Relation cond = pick_one_guard(r); + int i = start; + for ( ; i < end; i++) { + if (Must_Be_Subset(copy(loops[i]->guard_), copy(cond))) + cost.first++; + else + break; + } + Relation complement_cond = Complement(copy(cond)); + complement_cond.simplify(); + for (int j = i; j < end; j++) + if (Must_Be_Subset(copy(loops[j]->guard_), copy(complement_cond))) + cost.second++; + else + break; + + if (cost > best_cost) { + best_cost = cost; + best_cond = copy(cond); + } + r = Gist(r, cond, 1); + + if (iter_count > max_iter_count) + throw codegen_error("guard condition too complex to handle"); + + iter_count++; + } + + return best_cond; +} + +} + +bool bound_must_hit_stride(const GEQ_Handle &inequality, Variable_ID v, const EQ_Handle &stride_eq, Variable_ID wc, const Relation &bounds, const Relation &known) { + assert(inequality.get_coef(v) != 0 && abs(stride_eq.get_coef(v)) == 1 && wc->kind() == Wildcard_Var && abs(stride_eq.get_coef(wc)) > 1); + + // if bound expression uses floor operation, bail out for now + // TODO: in the future, handle this + if (abs(inequality.get_coef(v)) != 1) + return false; + + coef_t stride = abs(stride_eq.get_coef(wc)); + + Relation r1(known.n_set()); + F_Exists *f_exists1 = r1.add_and()->add_exists(); + F_And *f_root1 = f_exists1->add_and(); + std::map<Variable_ID, Variable_ID> exists_mapping1; + EQ_Handle h1 = f_root1->add_EQ(); + Relation r2(known.n_set()); + F_Exists *f_exists2 = r2.add_and()->add_exists(); + F_And *f_root2 = f_exists2->add_and(); + std::map<Variable_ID, Variable_ID> exists_mapping2; + EQ_Handle h2 = f_root2->add_EQ(); + for (Constr_Vars_Iter cvi(inequality); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h1.update_coef(r1.input_var(v->get_position()), cvi.curr_coef()); + h2.update_coef(r2.input_var(v->get_position()), cvi.curr_coef()); + break; + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v1, v2; + if (g->arity() == 0) { + v1 = r1.get_local(g); + v2 = r2.get_local(g); + } + else { + v1 = r1.get_local(g, v->function_of()); + v2 = r2.get_local(g, v->function_of()); + } + h1.update_coef(v1, cvi.curr_coef()); + h2.update_coef(v2, cvi.curr_coef()); + break; + } + case Wildcard_Var: { + Variable_ID v1 = replicate_floor_definition(bounds, v, r1, f_exists1, f_root1, exists_mapping1); + Variable_ID v2 = replicate_floor_definition(bounds, v, r2, f_exists2, f_root2, exists_mapping2); + h1.update_coef(v1, cvi.curr_coef()); + h2.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h1.update_const(inequality.get_const()); + h1.update_coef(f_exists1->declare(), stride); + h2.update_const(inequality.get_const()); + r1.simplify(); + r2.simplify(); + + Relation all_known = Intersection(copy(bounds), copy(known)); + all_known.simplify(); + + if (Gist(r1, copy(all_known), 1).is_obvious_tautology()) { + Relation r3(known.n_set()); + F_Exists *f_exists3 = r3.add_and()->add_exists(); + F_And *f_root3 = f_exists3->add_and(); + std::map<Variable_ID, Variable_ID> exists_mapping3; + EQ_Handle h3 = f_root3->add_EQ(); + for (Constr_Vars_Iter cvi(stride_eq); cvi; cvi++) { + Variable_ID v= cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h3.update_coef(r3.input_var(v->get_position()), cvi.curr_coef()); + break; + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v3; + if (g->arity() == 0) + v3 = r3.get_local(g); + else + v3 = r3.get_local(g, v->function_of()); + h3.update_coef(v3, cvi.curr_coef()); + break; + } + case Wildcard_Var: + if (v == wc) + h3.update_coef(f_exists3->declare(), cvi.curr_coef()); + else { + Variable_ID v3 = replicate_floor_definition(bounds, v, r3, f_exists3, f_root3, exists_mapping3); + h3.update_coef(v3, cvi.curr_coef()); + } + break; + default: + assert(false); + } + } + h3.update_const(stride_eq.get_const()); + r3.simplify(); + + if (Gist(r3, Intersection(r2, all_known), 1).is_obvious_tautology()) + return true; + else + return false; + } + else + return false; +} + + +// +// output variable by its name, however if this variable need to be substituted, +// return the substitution. +// +CG_outputRepr *output_ident(CG_outputBuilder *ocg, const Relation &R, Variable_ID v, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) { + const_cast<Relation &>(R).setup_names(); // hack + + if (v->kind() == Input_Var) { + int pos = v->get_position(); + if (assigned_on_the_fly[pos-1].first != NULL) + return assigned_on_the_fly[pos-1].first->clone(); + else + return ocg->CreateIdent(v->name()); + } + else if (v->kind() == Global_Var) { + if (v->get_global_var()->arity() == 0) + return ocg->CreateIdent(v->name()); + else { + /* This should be improved to take into account the possible elimination + of the set variables. */ + int arity = v->get_global_var()->arity(); + std::vector<CG_outputRepr *> argList; + for(int i = 1; i <= arity; i++) + argList.push_back(ocg->CreateIdent(const_cast<Relation &>(R).input_var(i)->name())); + CG_outputRepr *call = ocg->CreateInvoke(v->get_global_var()->base_name(), argList); + return call; + } + } + else + assert(false); +} + + +// +// return pair<if condition, <assignment rhs, assignment cost> > +// +std::pair<CG_outputRepr *, std::pair<CG_outputRepr *, int> > output_assignment(CG_outputBuilder *ocg, const Relation &R, int level, const Relation &known, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) { + Variable_ID v = const_cast<Relation &>(R).set_var(level); + Conjunct *c = const_cast<Relation &>(R).single_conjunct(); + + std::pair<EQ_Handle, int> result = find_simplest_assignment(R, v, assigned_on_the_fly); + + if (result.second == INT_MAX) + return std::make_pair(static_cast<CG_outputRepr *>(NULL), std::make_pair(static_cast<CG_outputRepr *>(NULL), INT_MAX)); + + CG_outputRepr *if_repr = NULL; + CG_outputRepr *assign_repr = NULL; + // check whether to generate if-conditions from equality constraints + if (abs(result.first.get_coef(v)) != 1) { + Relation r(R.n_set()); + F_Exists *f_exists = r.add_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map<Variable_ID, Variable_ID> exists_mapping; + exists_mapping[v] = f_exists->declare(); + + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(result.first); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Input_Var: { + if (cvi.curr_var() == v) + h.update_coef(exists_mapping[v], cvi.curr_coef()); + else + h.update_coef(r.set_var(cvi.curr_var()->get_position()), cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = cvi.curr_var()->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r.get_local(g); + else + v2 = r.get_local(g, cvi.curr_var()->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Wildcard_Var: { + std::map<Variable_ID, Variable_ID>::iterator p = exists_mapping.find(cvi.curr_var()); + Variable_ID v2; + if (p == exists_mapping.end()) { + v2 = f_exists->declare(); + exists_mapping[cvi.curr_var()] = v2; + } + else + v2 = p->second; + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(0); + } + h.update_const(result.first.get_const()); + + for (EQ_Iterator e(c->EQs()); e; e++) + if (!((*e) == result.first)) { + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Input_Var: { + assert(cvi.curr_var() != v); + h.update_coef(r.set_var(cvi.curr_var()->get_position()), cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = cvi.curr_var()->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r.get_local(g); + else + v2 = r.get_local(g, cvi.curr_var()->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Wildcard_Var: { + std::map<Variable_ID, Variable_ID>::iterator p = exists_mapping.find(cvi.curr_var()); + Variable_ID v2; + if (p == exists_mapping.end()) { + v2 = f_exists->declare(); + exists_mapping[cvi.curr_var()] = v2; + } + else + v2 = p->second; + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(0); + } + h.update_const((*e).get_const()); + } + + for (GEQ_Iterator e(c->GEQs()); e; e++) { + GEQ_Handle h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Input_Var: { + h.update_coef(r.set_var(cvi.curr_var()->get_position()), cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = cvi.curr_var()->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r.get_local(g); + else + v2 = r.get_local(g, cvi.curr_var()->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Wildcard_Var: { + std::map<Variable_ID, Variable_ID>::iterator p = exists_mapping.find(cvi.curr_var()); + Variable_ID v2; + if (p == exists_mapping.end()) { + v2 = f_exists->declare(); + exists_mapping[cvi.curr_var()] = v2; + } + else + v2 = p->second; + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(0); + } + h.update_const((*e).get_const()); + } + + r.simplify(); + if (!Gist(r, copy(known), 1).is_obvious_tautology()) { + CG_outputRepr *lhs = output_substitution_repr(ocg, result.first, v, false, R, assigned_on_the_fly); + if_repr = ocg->CreateEQ(ocg->CreateIntegerMod(lhs->clone(), ocg->CreateInt(abs(result.first.get_coef(v)))), ocg->CreateInt(0)); + assign_repr = ocg->CreateDivide(lhs, ocg->CreateInt(abs(result.first.get_coef(v)))); + } + else + assign_repr = output_substitution_repr(ocg, result.first, v, true, R, assigned_on_the_fly); + } + else + assign_repr = output_substitution_repr(ocg, result.first, v, true, R, assigned_on_the_fly); + + if (assign_repr == NULL) + assign_repr = ocg->CreateInt(0); + + return std::make_pair(if_repr, std::make_pair(assign_repr, result.second)); +} + + +// +// return NULL if 0 +// +CG_outputRepr *output_substitution_repr(CG_outputBuilder *ocg, const EQ_Handle &equality, Variable_ID v, bool apply_v_coef, const Relation &R, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) { + const_cast<Relation &>(R).setup_names(); // hack + + coef_t a = equality.get_coef(v); + assert(a != 0); + + CG_outputRepr *repr = NULL; + for (Constr_Vars_Iter cvi(equality); cvi; cvi++) + if (cvi.curr_var() != v) { + CG_outputRepr *t; + if (cvi.curr_var()->kind() == Wildcard_Var) { + std::pair<bool, GEQ_Handle> result = find_floor_definition(R, cvi.curr_var()); + if (!result.first) { + delete repr; + throw codegen_error("can't output non floor defined wildcard"); + } + t = output_inequality_repr(ocg, result.second, cvi.curr_var(), R, assigned_on_the_fly); + } + else + t = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + + if (a > 0) { + if (coef > 0) { + if (coef == 1) + repr = ocg->CreateMinus(repr, t); + else + repr = ocg->CreateMinus(repr, ocg->CreateTimes(ocg->CreateInt(coef), t)); + } + else { // coef < 0 + if (coef == -1) + repr = ocg->CreatePlus(repr, t); + else + repr = ocg->CreatePlus(repr, ocg->CreateTimes(ocg->CreateInt(-coef), t)); + } + } + else { + if (coef > 0) { + if (coef == 1) + repr = ocg->CreatePlus(repr, t); + else + repr = ocg->CreatePlus(repr, ocg->CreateTimes(ocg->CreateInt(coef), t)); + } + else { // coef < 0 + if (coef == -1) + repr = ocg->CreateMinus(repr, t); + else + repr = ocg->CreateMinus(repr, ocg->CreateTimes(ocg->CreateInt(-coef), t)); + } + } + } + + int c = equality.get_const(); + if (a > 0) { + if (c > 0) + repr = ocg->CreateMinus(repr, ocg->CreateInt(c)); + else if (c < 0) + repr = ocg->CreatePlus(repr, ocg->CreateInt(-c)); + } + else { + if (c > 0) + repr = ocg->CreatePlus(repr, ocg->CreateInt(c)); + else if (c < 0) + repr = ocg->CreateMinus(repr, ocg->CreateInt(-c)); + } + + if (apply_v_coef && abs(a) != 1) + repr = ocg->CreateDivide(repr, ocg->CreateInt(abs(a))); + + return repr; +} + + +// +// original Substitutions class from omega can't handle integer +// division, this is new way. +// +std::vector<CG_outputRepr*> output_substitutions(CG_outputBuilder *ocg, const Relation &R, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) { + std::vector<CG_outputRepr *> subs; + + for (int i = 1; i <= R.n_out(); i++) { + Relation mapping(R.n_out(), 1); + F_And *f_root = mapping.add_and(); + EQ_Handle h = f_root->add_EQ(); + h.update_coef(mapping.output_var(1), 1); + h.update_coef(mapping.input_var(i), -1); + Relation r = Composition(mapping, copy(R)); + r.simplify(); + + Variable_ID v = r.output_var(1); + CG_outputRepr *repr = NULL; + std::pair<EQ_Handle, int> result = find_simplest_assignment(r, v, assigned_on_the_fly); + if (result.second < INT_MAX) + repr = output_substitution_repr(ocg, result.first, v, true, r, assigned_on_the_fly); + else { + std::pair<bool, GEQ_Handle> result = find_floor_definition(R, v); + if (result.first) + try { + repr = output_inequality_repr(ocg, result.second, v, R, assigned_on_the_fly); + } + catch (const codegen_error &) { + } + } + + subs.push_back(repr); + } + + return subs; +} + + +// +// handle floor definition wildcards in equality, the second in returned pair +// is the cost. +// +std::pair<EQ_Handle, int> find_simplest_assignment(const Relation &R, Variable_ID v, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) { + Conjunct *c = const_cast<Relation &>(R).single_conjunct(); + + int min_cost = INT_MAX; + EQ_Handle eq; + for (EQ_Iterator e(c->EQs()); e; e++) + if (!(*e).has_wildcards() && (*e).get_coef(v) != 0) { + int cost = 0; + + if (abs((*e).get_coef(v)) != 1) + cost += 4; // divide cost + + int num_var = 0; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var() != v) { + num_var++; + if (abs(cvi.curr_coef()) != 1) + cost += 2; // multiply cost + if (cvi.curr_var()->kind() == Global_Var && cvi.curr_var()->get_global_var()->arity() > 0) + cost += 10; // function cost + else if (cvi.curr_var()->kind() == Input_Var && + assigned_on_the_fly.size() >= cvi.curr_var()->get_position() && + assigned_on_the_fly[cvi.curr_var()->get_position()-1].first != NULL) + cost += assigned_on_the_fly[cvi.curr_var()->get_position()-1].second; // substitution cost on record + } + if ((*e).get_const() != 0) + num_var++; + if (num_var > 1) + cost += num_var - 1; // addition cost + + if (cost < min_cost) { + min_cost = cost; + eq = *e; + } + } + + if (min_cost < INT_MAX) + return std::make_pair(eq, min_cost); + + for (EQ_Iterator e(c->EQs()); e; e++) + if ((*e).has_wildcards() && (*e).get_coef(v) != 0) { + bool is_assignment = true; + for (Constr_Vars_Iter cvi(*e, true); cvi; cvi++) { + std::pair<bool, GEQ_Handle> result = find_floor_definition(R, v); + if (!result.first) { + is_assignment = false; + break; + } + } + if (!is_assignment) + continue; + + int cost = 0; + + if (abs((*e).get_coef(v)) != 1) + cost += 4; // divide cost + + int num_var = 0; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var() != v) { + num_var++; + if (abs(cvi.curr_coef()) != 1) + cost += 2; // multiply cost + if (cvi.curr_var()->kind() == Wildcard_Var) + cost += 10; // floor operation cost + else if (cvi.curr_var()->kind() == Global_Var && cvi.curr_var()->get_global_var()->arity() > 0) + cost += 20; // function cost + else if (cvi.curr_var()->kind() == Input_Var && + assigned_on_the_fly.size() >= cvi.curr_var()->get_position() && + assigned_on_the_fly[cvi.curr_var()->get_position()-1].first != NULL) + cost += assigned_on_the_fly[cvi.curr_var()->get_position()-1].second; // substitution cost on record + } + if ((*e).get_const() != 0) + num_var++; + if (num_var > 1) + cost += num_var - 1; // addition cost + + if (cost < min_cost) { + min_cost = cost; + eq = *e; + } + } + + return std::make_pair(eq, min_cost); +} + + +// +// find floor definition for variable v, e.g. m-c <= 4v <= m, (c is +// constant and 0 <= c < 4). this translates to v = floor(m, 4) and +// return 4v<=m in this case. All wildcards in such inequality are +// also floor defined. +// +std::pair<bool, GEQ_Handle> find_floor_definition(const Relation &R, Variable_ID v, std::set<Variable_ID> excluded_floor_vars) { + Conjunct *c = const_cast<Relation &>(R).single_conjunct(); + + excluded_floor_vars.insert(v); + for (GEQ_Iterator e = c->GEQs(); e; e++) { + coef_t a = (*e).get_coef(v); + if (a >= -1) + continue; + a = -a; + + bool interested = true; + for (std::set<Variable_ID>::const_iterator i = excluded_floor_vars.begin(); i != excluded_floor_vars.end(); i++) + if ((*i) != v && (*e).get_coef(*i) != 0) { + interested = false; + break; + } + if (!interested) + continue; + + // check if any wildcard is floor defined + bool has_undefined_wc = false; + for (Constr_Vars_Iter cvi(*e, true); cvi; cvi++) + if (excluded_floor_vars.find(cvi.curr_var()) == excluded_floor_vars.end()) { + std::pair<bool, GEQ_Handle> result = find_floor_definition(R, cvi.curr_var(), excluded_floor_vars); + if (!result.first) { + has_undefined_wc = true; + break; + } + } + if (has_undefined_wc) + continue; + + // find the matching upper bound for floor definition + for (GEQ_Iterator e2 = c->GEQs(); e2; e2++) + if ((*e2).get_coef(v) == a && (*e).get_const() + (*e2).get_const() < a) { + bool match = true; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if ((*e2).get_coef(cvi.curr_var()) != -cvi.curr_coef()) { + match = false; + break; + } + if (!match) + continue; + for (Constr_Vars_Iter cvi(*e2); cvi; cvi++) + if ((*e).get_coef(cvi.curr_var()) != -cvi.curr_coef()) { + match = false; + break; + } + if (match) + return std::make_pair(true, *e); + } + } + + return std::make_pair(false, GEQ_Handle()); +} + +// +// find the stride involving the specified variable, the stride +// equality can have other wildcards as long as they are defined as +// floor variables. +// +std::pair<EQ_Handle, Variable_ID> find_simplest_stride(const Relation &R, Variable_ID v) { + int best_num_var = INT_MAX; + coef_t best_coef; + EQ_Handle best_eq; + Variable_ID best_stride_wc; + for (EQ_Iterator e(const_cast<Relation &>(R).single_conjunct()->EQs()); e; e++) + if ((*e).has_wildcards() && (*e).get_coef(v) != 0) { + bool is_stride = true; + bool found_free = false; + int num_var = 0; + int num_floor = 0; + Variable_ID stride_wc; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: { + bool is_free = true; + for (GEQ_Iterator e2(const_cast<Relation &>(R).single_conjunct()->GEQs()); e2; e2++) + if ((*e2).get_coef(cvi.curr_var()) != 0) { + is_free = false; + break; + } + if (is_free) { + if (found_free) + is_stride = false; + else { + found_free = true; + stride_wc = cvi.curr_var(); + } + } + else { + std::pair<bool, GEQ_Handle> result = find_floor_definition(R, cvi.curr_var()); + if (result.first) + num_floor++; + else + is_stride = false; + } + break; + } + case Input_Var: + num_var++; + break; + default: + ; + } + + if (!is_stride) + break; + } + + if (is_stride) { + coef_t coef = abs((*e).get_coef(v)); + if (best_num_var == INT_MAX || coef < best_coef || + (coef == best_coef && num_var < best_num_var)) { + best_coef = coef; + best_num_var = num_var; + best_eq = *e; + best_stride_wc = stride_wc; + } + } + } + + if (best_num_var != INT_MAX) + return std::make_pair(best_eq, best_stride_wc); + else + return std::make_pair(EQ_Handle(), static_cast<Variable_ID>(NULL)); +} + +// +// convert relation to if-condition +// +CG_outputRepr *output_guard(CG_outputBuilder *ocg, const Relation &R, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) { + assert(R.n_out()==0); + + CG_outputRepr *result = NULL; + Conjunct *c = const_cast<Relation &>(R).single_conjunct(); + + // e.g. 4i=5*j + for (EQ_Iterator e = c->EQs(); e; e++) + if (!(*e).has_wildcards()) { + CG_outputRepr *lhs = NULL; + CG_outputRepr *rhs = NULL; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + CG_outputRepr *v = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + if (coef > 0) { + if (coef == 1) + lhs = ocg->CreatePlus(lhs, v); + else + lhs = ocg->CreatePlus(lhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + rhs = ocg->CreatePlus(rhs, v); + else + rhs = ocg->CreatePlus(rhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + coef_t c = (*e).get_const(); + + CG_outputRepr *term; + if (lhs == NULL) + term = ocg->CreateEQ(rhs, ocg->CreateInt(c)); + else { + if (c > 0) + rhs = ocg->CreateMinus(rhs, ocg->CreateInt(c)); + else if (c < 0) + rhs = ocg->CreatePlus(rhs, ocg->CreateInt(-c)); + else if (rhs == NULL) + rhs = ocg->CreateInt(0); + term = ocg->CreateEQ(lhs, rhs); + } + result = ocg->CreateAnd(result, term); + } + + // e.g. i>5j + for (GEQ_Iterator e = c->GEQs(); e; e++) + if (!(*e).has_wildcards()) { + CG_outputRepr *lhs = NULL; + CG_outputRepr *rhs = NULL; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + CG_outputRepr *v = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + if (coef > 0) { + if (coef == 1) + lhs = ocg->CreatePlus(lhs, v); + else + lhs = ocg->CreatePlus(lhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + rhs = ocg->CreatePlus(rhs, v); + else + rhs = ocg->CreatePlus(rhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + coef_t c = (*e).get_const(); + + CG_outputRepr *term; + if (lhs == NULL) + term = ocg->CreateLE(rhs, ocg->CreateInt(c)); + else { + if (c > 0) + rhs = ocg->CreateMinus(rhs, ocg->CreateInt(c)); + else if (c < 0) + rhs = ocg->CreatePlus(rhs, ocg->CreateInt(-c)); + else if (rhs == NULL) + rhs = ocg->CreateInt(0); + term = ocg->CreateGE(lhs, rhs); + } + result = ocg->CreateAnd(result, term); + } + + // e.g. 4i=5j+4alpha + for (EQ_Iterator e = c->EQs(); e; e++) + if ((*e).has_wildcards()) { + Variable_ID wc; + int num_wildcard = 0; + int num_positive = 0; + int num_negative = 0; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + if (cvi.curr_var()->kind() == Wildcard_Var) { + num_wildcard++; + wc = cvi.curr_var(); + } + else { + if (cvi.curr_coef() > 0) + num_positive++; + else + num_negative++; + } + } + + if (num_wildcard > 1) { + delete result; + throw codegen_error("Can't generate equality condition with multiple wildcards"); + } + int sign = (num_positive>=num_negative)?1:-1; + + CG_outputRepr *lhs = NULL; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + if (cvi.curr_var() != wc) { + CG_outputRepr *v = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + if (sign == 1) { + if (coef > 0) { + if (coef == 1) + lhs = ocg->CreatePlus(lhs, v); + else + lhs = ocg->CreatePlus(lhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + lhs = ocg->CreateMinus(lhs, v); + else + lhs = ocg->CreateMinus(lhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + else { + if (coef > 0) { + if (coef == 1) + lhs = ocg->CreateMinus(lhs, v); + else + lhs = ocg->CreateMinus(lhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + lhs = ocg->CreatePlus(lhs, v); + else + lhs = ocg->CreatePlus(lhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + } + } + coef_t c = (*e).get_const(); + if (sign == 1) { + if (c > 0) + lhs = ocg->CreatePlus(lhs, ocg->CreateInt(c)); + else if (c < 0) + lhs = ocg->CreateMinus(lhs, ocg->CreateInt(-c)); + } + else { + if (c > 0) + lhs = ocg->CreateMinus(lhs, ocg->CreateInt(c)); + else if (c < 0) + lhs = ocg->CreatePlus(lhs, ocg->CreateInt(-c)); + } + + lhs = ocg->CreateIntegerMod(lhs, ocg->CreateInt(abs((*e).get_coef(wc)))); + CG_outputRepr *term = ocg->CreateEQ(lhs, ocg->CreateInt(0)); + result = ocg->CreateAnd(result, term); + } + + // e.g. 4alpha<=i<=5alpha + for (GEQ_Iterator e = c->GEQs(); e; e++) + if ((*e).has_wildcards()) { + Variable_ID wc; + int num_wildcard = 0; + for (Constr_Vars_Iter cvi(*e, true); cvi; cvi++) + if (num_wildcard == 0) { + wc = cvi.curr_var(); + num_wildcard = 1; + } + else + num_wildcard++; + + if (num_wildcard > 1) { + delete result; + // e.g. c*alpha - x >= 0 (*) + // -d*alpha + y >= 0 (*) + // e1*alpha + f1*beta + g1 >= 0 (**) + // e2*alpha + f2*beta + g2 >= 0 (**) + // ... + // TODO: should generate a testing loop for alpha using its lower and + // upper bounds from (*) constraints and do the same if-condition test + // for beta from each pair of opposite (**) constraints as above, + // and exit the loop when if-condition satisfied. + throw codegen_error("Can't generate multiple wildcard GEQ guards right now"); + } + + coef_t c = (*e).get_coef(wc); + int sign = (c>0)?1:-1; + + GEQ_Iterator e2 = e; + e2++; + for ( ; e2; e2++) { + coef_t c2 = (*e2).get_coef(wc); + if (c2 == 0) + continue; + int sign2 = (c2>0)?1:-1; + if (sign != -sign2) + continue; + int num_wildcard2 = 0; + for (Constr_Vars_Iter cvi(*e2, true); cvi; cvi++) + num_wildcard2++; + if (num_wildcard2 > 1) + continue; + + GEQ_Handle lb, ub; + if (sign == 1) { + lb = (*e); + ub = (*e2); + } + else { + lb = (*e2); + ub = (*e); + } + + CG_outputRepr *lhs = NULL; + for (Constr_Vars_Iter cvi(lb); cvi; cvi++) + if (cvi.curr_var() != wc) { + CG_outputRepr *v = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + if (coef > 0) { + if (coef == 1) + lhs = ocg->CreateMinus(lhs, v); + else + lhs = ocg->CreateMinus(lhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + lhs = ocg->CreatePlus(lhs, v); + else + lhs = ocg->CreatePlus(lhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + coef_t c = lb.get_const(); + if (c > 0) + lhs = ocg->CreateMinus(lhs, ocg->CreateInt(c)); + else if (c < 0) + lhs = ocg->CreatePlus(lhs, ocg->CreateInt(-c)); + + CG_outputRepr *rhs = NULL; + for (Constr_Vars_Iter cvi(ub); cvi; cvi++) + if (cvi.curr_var() != wc) { + CG_outputRepr *v = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + if (coef > 0) { + if (coef == 1) + rhs = ocg->CreatePlus(rhs, v); + else + rhs = ocg->CreatePlus(rhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + rhs = ocg->CreateMinus(rhs, v); + else + rhs = ocg->CreateMinus(rhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + c = ub.get_const(); + if (c > 0) + rhs = ocg->CreatePlus(rhs, ocg->CreateInt(c)); + else if (c < 0) + rhs = ocg->CreateMinus(rhs, ocg->CreateInt(-c)); + + rhs = ocg->CreateIntegerFloor(rhs, ocg->CreateInt(-ub.get_coef(wc))); + rhs = ocg->CreateTimes(ocg->CreateInt(lb.get_coef(wc)), rhs); + CG_outputRepr *term = ocg->CreateLE(lhs, rhs); + result = ocg->CreateAnd(result, term); + } + } + + return result; +} + + +// +// return NULL if 0 +// +CG_outputRepr *output_inequality_repr(CG_outputBuilder *ocg, const GEQ_Handle &inequality, Variable_ID v, const Relation &R, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly, std::set<Variable_ID> excluded_floor_vars) { + const_cast<Relation &>(R).setup_names(); // hack + + coef_t a = inequality.get_coef(v); + assert(a != 0); + excluded_floor_vars.insert(v); + + CG_outputRepr *repr = NULL; + for (Constr_Vars_Iter cvi(inequality); cvi; cvi++) + if (cvi.curr_var() != v) { + CG_outputRepr *t; + if (cvi.curr_var()->kind() == Wildcard_Var) { + std::pair<bool, GEQ_Handle> result = find_floor_definition(R, cvi.curr_var(), excluded_floor_vars); + if (!result.first) { + delete repr; + throw codegen_error("Can't generate bound expression with wildcard not involved in floor definition"); + } + try { + t = output_inequality_repr(ocg, result.second, cvi.curr_var(), R, assigned_on_the_fly, excluded_floor_vars); + } + catch (const std::exception &e) { + delete repr; + throw e; + } + } + else + t = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + + coef_t coef = cvi.curr_coef(); + if (a > 0) { + if (coef > 0) { + if (coef == 1) + repr = ocg->CreateMinus(repr, t); + else + repr = ocg->CreateMinus(repr, ocg->CreateTimes(ocg->CreateInt(coef), t)); + } + else { + if (coef == -1) + repr = ocg->CreatePlus(repr, t); + else + repr = ocg->CreatePlus(repr, ocg->CreateTimes(ocg->CreateInt(-coef), t)); + } + } + else { + if (coef > 0) { + if (coef == 1) + repr = ocg->CreatePlus(repr, t); + else + repr = ocg->CreatePlus(repr, ocg->CreateTimes(ocg->CreateInt(coef), t)); + } + else { + if (coef == -1) + repr = ocg->CreateMinus(repr, t); + else + repr = ocg->CreateMinus(repr, ocg->CreateTimes(ocg->CreateInt(-coef), t)); + } + } + } + coef_t c = inequality.get_const(); + if (c > 0) { + if (a > 0) + repr = ocg->CreateMinus(repr, ocg->CreateInt(c)); + else + repr = ocg->CreatePlus(repr, ocg->CreateInt(c)); + } + else if (c < 0) { + if (a > 0) + repr = ocg->CreatePlus(repr, ocg->CreateInt(-c)); + else + repr = ocg->CreateMinus(repr, ocg->CreateInt(-c)); + } + + if (abs(a) == 1) + return repr; + else if (a > 0) + return ocg->CreateIntegerCeil(repr, ocg->CreateInt(a)); + else // a < 0 + return ocg->CreateIntegerFloor(repr, ocg->CreateInt(-a)); +} + + +// +// nothing special, just an alias +// +CG_outputRepr *output_upper_bound_repr(CG_outputBuilder *ocg, const GEQ_Handle &inequality, Variable_ID v, const Relation &R, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) { + assert(inequality.get_coef(v) < 0); + CG_outputRepr* zero_; + + zero_ = output_inequality_repr(ocg, inequality, v, R, assigned_on_the_fly); + + if(!zero_) + zero_ = ocg->CreateInt(0); + + return zero_; + +} + + +// +// output lower bound with respect to lattice +// +CG_outputRepr *output_lower_bound_repr(CG_outputBuilder *ocg, const GEQ_Handle &inequality, Variable_ID v, const EQ_Handle &stride_eq, Variable_ID wc, const Relation &R, const Relation &known, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) { + assert(inequality.get_coef(v) > 0); + CG_outputRepr* zero_; + if (wc == NULL || bound_must_hit_stride(inequality, v, stride_eq, wc, R, known)){ + zero_ = output_inequality_repr(ocg, inequality, v, R, assigned_on_the_fly); + if(!zero_) + zero_ = ocg->CreateInt(0); + + return zero_; + } + CG_outputRepr *strideBoundRepr = NULL; + int sign = (stride_eq.get_coef(v)>0)?1:-1; + for (Constr_Vars_Iter cvi(stride_eq); cvi; cvi++) { + Variable_ID v2 = cvi.curr_var(); + if (v2 == v || v2 == wc) + continue; + + CG_outputRepr *v_repr; + if (v2->kind() == Input_Var || v2->kind() == Global_Var) + v_repr = output_ident(ocg, R, v2, assigned_on_the_fly); + else if (v2->kind() == Wildcard_Var) { + std::pair<bool, GEQ_Handle> result = find_floor_definition(R, v2); + assert(result.first); + v_repr = output_inequality_repr(ocg, result.second, v2, R, assigned_on_the_fly); + } + + coef_t coef = cvi.curr_coef(); + if (sign < 0) { + if (coef > 0) { + if (coef == 1) + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, v_repr); + else + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, ocg->CreateTimes(ocg->CreateInt(coef), v_repr)); + } + else { // coef < 0 + if (coef == -1) + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, v_repr); + else + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, ocg->CreateTimes(ocg->CreateInt(-coef), v_repr)); + } + } + else { + if (coef > 0) { + if (coef == 1) + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, v_repr); + else + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, ocg->CreateTimes(ocg->CreateInt(coef), v_repr)); + } + else { // coef < 0 + if (coef == -1) + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, v_repr); + else + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, ocg->CreateTimes(ocg->CreateInt(-coef), v_repr)); + } + } + } + coef_t c = stride_eq.get_const(); + if (c > 0) { + if (sign < 0) + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, ocg->CreateInt(c)); + else + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, ocg->CreateInt(c)); + } + else if (c < 0) { + if (sign < 0) + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, ocg->CreateInt(-c)); + else + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, ocg->CreateInt(-c)); + } + + CG_outputRepr *repr = output_inequality_repr(ocg, inequality, v, R, assigned_on_the_fly); + CG_outputRepr *repr2 = ocg->CreateCopy(repr); + repr = ocg->CreatePlus(repr2, ocg->CreateIntegerMod(ocg->CreateMinus(strideBoundRepr, repr), ocg->CreateInt(abs(stride_eq.get_coef(wc))))); + + return repr; +} + + +// +// return loop control structure only +// +CG_outputRepr *output_loop(CG_outputBuilder *ocg, const Relation &R, int level, const Relation &known, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) { + std::pair<EQ_Handle, Variable_ID> result = find_simplest_stride(R, const_cast<Relation &>(R).set_var(level)); + if (result.second != NULL) + assert(abs(result.first.get_coef(const_cast<Relation &>(R).set_var(level))) == 1); + + std::vector<CG_outputRepr *> lbList, ubList; + try { + + coef_t const_lb = negInfinity, const_ub = posInfinity; + + for (GEQ_Iterator e(const_cast<Relation &>(R).single_conjunct()->GEQs()); e; e++) { + coef_t coef = (*e).get_coef(const_cast<Relation &>(R).set_var(level)); + + if (coef > 0) { + CG_outputRepr *repr = output_lower_bound_repr(ocg, *e, const_cast<Relation &>(R).set_var(level), result.first, result.second, R, known, assigned_on_the_fly); + if (repr == NULL) + repr = ocg->CreateInt(0); + lbList.push_back(repr); + + if ((*e).is_const(const_cast<Relation &>(R).set_var(level))){ + if(!result.second) { + + //no variables but v in constr + coef_t L,m; + L = -((*e).get_const()); + + m = (*e).get_coef(const_cast<Relation &>(R).set_var(level)); + coef_t sb = (int) (ceil(((float) L) /m)); + set_max(const_lb, sb); + } + else{ + + coef_t L,m,s,c; + L = -((*e).get_const()); + m = (*e).get_coef(const_cast<Relation &>(R).set_var(level)); + s = abs(result.first.get_coef(result.second)); + c = result.first.get_const(); + coef_t sb = (s * (int) (ceil( (float) (L - (c * m)) /(s*m))))+ c; + set_max(const_lb, sb); + + } + } + + } + else if (coef < 0) { + CG_outputRepr *repr = output_upper_bound_repr(ocg, *e, const_cast<Relation &>(R).set_var(level), R, assigned_on_the_fly); + if (repr == NULL) + repr = ocg->CreateInt(0); + ubList.push_back(repr); + + if ((*e).is_const(const_cast<Relation &>(R).set_var(level))) { + // no variables but v in constraint + set_min(const_ub,-(*e).get_const()/(*e).get_coef(const_cast<Relation &>(R).set_var(level))); + } + + } + } + + if(fillInBounds && lbList.size() == 1 && const_lb != negInfinity) + lowerBoundForLevel = const_lb; + + if(fillInBounds && const_ub != posInfinity) + upperBoundForLevel = const_ub; + if (lbList.size() == 0) + throw codegen_error("missing lower bound at loop level " + to_string(level)); + if (ubList.size() == 0) + throw codegen_error("missing upper bound at loop level " + to_string(level)); + } + catch (const std::exception &e) { + for (int i = 0; i < lbList.size(); i++) + delete lbList[i]; + for (int i = 0; i < ubList.size(); i++) + delete ubList[i]; + throw e; + } + + CG_outputRepr *lbRepr = NULL; + if (lbList.size() > 1) + lbRepr = ocg->CreateInvoke("max", lbList); + else // (lbList.size() == 1) + lbRepr = lbList[0]; + + CG_outputRepr *ubRepr = NULL; + if (ubList.size() > 1) + ubRepr = ocg->CreateInvoke("min", ubList); + else // (ubList.size() == 1) + ubRepr = ubList[0]; + + CG_outputRepr *stRepr; + if (result.second == NULL) + stRepr = ocg->CreateInt(1); + else + stRepr = ocg->CreateInt(abs(result.first.get_coef(result.second))); + CG_outputRepr *indexRepr = output_ident(ocg, R, const_cast<Relation &>(R).set_var(level), assigned_on_the_fly); + return ocg->CreateInductive(indexRepr, lbRepr, ubRepr, stRepr); +} + + +// +// parameter f_root is inside f_exists, not the other way around. +// return replicated variable in new relation, with all cascaded floor definitions +// using wildcards defined in the same way as in the original relation. +// +Variable_ID replicate_floor_definition(const Relation &R, const Variable_ID floor_var, + Relation &r, F_Exists *f_exists, F_And *f_root, + std::map<Variable_ID, Variable_ID> &exists_mapping) { + assert(R.n_out() == 0 && r.n_out() == 0 && R.n_inp() == r.n_inp()); + + std::set<Variable_ID> excluded_floor_vars; + std::stack<Variable_ID> to_fill; + to_fill.push(floor_var); + + while (!to_fill.empty()) { + Variable_ID v = to_fill.top(); + to_fill.pop(); + if (excluded_floor_vars.find(v) != excluded_floor_vars.end()) + continue; + + std::pair<bool, GEQ_Handle> result = find_floor_definition(R, v, excluded_floor_vars); + assert(result.first); + excluded_floor_vars.insert(v); + + GEQ_Handle h1 = f_root->add_GEQ(); + GEQ_Handle h2 = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(result.second); cvi; cvi++) { + Variable_ID v2 = cvi.curr_var(); + switch (v2->kind()) { + case Input_Var: { + int pos = v2->get_position(); + h1.update_coef(r.input_var(pos), cvi.curr_coef()); + h2.update_coef(r.input_var(pos), -cvi.curr_coef()); + break; + } + case Wildcard_Var: { + std::map<Variable_ID, Variable_ID>::iterator p = exists_mapping.find(v2); + Variable_ID v3; + if (p == exists_mapping.end()) { + v3 = f_exists->declare(); + exists_mapping[v2] = v3; + } + else + v3 = p->second; + h1.update_coef(v3, cvi.curr_coef()); + h2.update_coef(v3, -cvi.curr_coef()); + if (v2 != v) + to_fill.push(v2); + break; + } + case Global_Var: { + Global_Var_ID g = v2->get_global_var(); + Variable_ID v3; + if (g->arity() == 0) + v3 = r.get_local(g); + else + v3 = r.get_local(g, v2->function_of()); + h1.update_coef(v3, cvi.curr_coef()); + h2.update_coef(v3, -cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h1.update_const(result.second.get_const()); + h2.update_const(-result.second.get_const()-result.second.get_coef(v)-1); + } + + if (floor_var->kind() == Input_Var) + return r.input_var(floor_var->get_position()); + else if (floor_var->kind() == Wildcard_Var) + return exists_mapping[floor_var]; + else + assert(false); +} + + +// +// pick one guard condition from relation. it can involve multiple +// constraints when involving wildcards, as long as its complement +// is a single conjunct. +// +Relation pick_one_guard(const Relation &R, int level) { + assert(R.n_out()==0); + + Relation r = Relation::True(R.n_set()); + + for (GEQ_Iterator e(const_cast<Relation &>(R).single_conjunct()->GEQs()); e; e++) + if (!(*e).has_wildcards()) { + r.and_with_GEQ(*e); + r.simplify(); + r.copy_names(R); + r.setup_names(); + return r; + } + + for (EQ_Iterator e(const_cast<Relation &>(R).single_conjunct()->EQs()); e; e++) + if (!(*e).has_wildcards()) { + r.and_with_GEQ(*e); + r.simplify(); + r.copy_names(R); + r.setup_names(); + return r; + } + + for (EQ_Iterator e(const_cast<Relation &>(R).single_conjunct()->EQs()); e; e++) + if ((*e).has_wildcards()) { + int num_wildcard = 0; + int max_level = 0; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: + num_wildcard++; + break; + case Input_Var: + if (cvi.curr_var()->get_position() > max_level) + max_level = cvi.curr_var()->get_position(); + break; + default: + ; + } + + if (num_wildcard == 1 && max_level != level-1) { + r.and_with_EQ(*e); + r.simplify(); + r.copy_names(R); + r.setup_names(); + return r; + } + } + + for (GEQ_Iterator e(const_cast<Relation &>(R).single_conjunct()->GEQs()); e; e++) + if ((*e).has_wildcards()) { + int num_wildcard = 0; + int max_level = 0; + bool direction; + Variable_ID wc; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: + num_wildcard++; + wc = cvi.curr_var(); + direction = cvi.curr_coef()>0?true:false; + break; + case Input_Var: + if (cvi.curr_var()->get_position() > max_level) + max_level = cvi.curr_var()->get_position(); + break; + default: + ; + } + + if (num_wildcard == 1 && max_level != level-1) { + // find the pairing inequality + GEQ_Iterator e2 = e; + e2++; + for ( ; e2; e2++) { + int num_wildcard2 = 0; + int max_level2 = 0; + bool direction2; + Variable_ID wc2; + for (Constr_Vars_Iter cvi(*e2); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: + num_wildcard2++; + wc2 = cvi.curr_var(); + direction2 = cvi.curr_coef()>0?true:false; + break; + case Input_Var: + if (cvi.curr_var()->get_position() > max_level2) + max_level2 = cvi.curr_var()->get_position(); + break; + default: + ; + } + + if (num_wildcard2 == 1 && max_level2 != level-1 && wc2 == wc && direction2 == not direction) { + F_Exists *f_exists = r.and_with_and()->add_exists(); + Variable_ID wc3 = f_exists->declare(); + F_And *f_root = f_exists->add_and(); + GEQ_Handle h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: + h.update_coef(wc3, cvi.curr_coef()); + break; + case Input_Var: + h.update_coef(r.input_var(cvi.curr_var()->get_position()), cvi.curr_coef()); + break; + case Global_Var: { + Global_Var_ID g = cvi.curr_var()->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = r.get_local(g); + else + v = r.get_local(g, cvi.curr_var()->function_of()); + h.update_coef(v, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const((*e).get_const()); + + h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*e2); cvi; cvi++) { + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: + h.update_coef(wc3, cvi.curr_coef()); + break; + case Input_Var: + h.update_coef(r.input_var(cvi.curr_var()->get_position()), cvi.curr_coef()); + break; + case Global_Var: { + Global_Var_ID g = cvi.curr_var()->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = r.get_local(g); + else + v = r.get_local(g, cvi.curr_var()->function_of()); + h.update_coef(v, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const((*e2).get_const()); + + r.simplify(); + r.copy_names(R); + r.setup_names(); + return r; + } + } + } + } +} + + +// +// heavy lifting for code output for one leaf node +// +CG_outputRepr *leaf_print_repr(BoolSet<> active, const std::map<int, Relation> &guards, + CG_outputRepr *guard_repr, const Relation &known, + int indent, CG_outputBuilder *ocg, const std::vector<int> &remap, + const std::vector<Relation> &xforms, const std::vector<CG_outputRepr *> &stmts, + const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) { + if (active.num_elem() == 0) + return NULL; + + CG_outputRepr *stmt_list = NULL; + for (BoolSet<>::iterator i = active.begin(); i != active.end(); i++) { + std::map<int, Relation>::const_iterator j = guards.find(*i); + if (j == guards.end() || Must_Be_Subset(copy(known), copy(j->second))) { + Relation mapping = Inverse(copy((xforms[remap[*i]]))); + mapping.simplify(); + mapping.setup_names(); + std::vector<std::string> loop_vars; + for (int k = 1; k <= mapping.n_out(); k++) { + loop_vars.push_back(mapping.output_var(k)->name()); +// std::cout << "CG_Utils:: " << k << ", " << mapping.output_var(k)->name().c_str() << "\n"; + } + std::vector<CG_outputRepr *> sList = output_substitutions(ocg, mapping, assigned_on_the_fly); + stmt_list = ocg->StmtListAppend(stmt_list, ocg->CreateSubstitutedStmt((guard_repr==NULL)?indent:indent+1, stmts[remap[*i]]->clone(), loop_vars, sList)); + active.unset(*i); + } + } + + if (stmt_list != NULL) { + if (active.num_elem() != 0) + stmt_list = ocg->StmtListAppend(stmt_list, leaf_print_repr(active, guards, NULL, known, (guard_repr==NULL)?indent:indent+1, ocg, remap, xforms, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } + else { + Relation then_cond = find_best_guard(const_cast<std::map<int, Relation> &>(guards)[*(active.begin())], active, guards); + assert(!then_cond.is_obvious_tautology()); + Relation new_then_known = Intersection(copy(known), copy(then_cond)); + new_then_known.simplify(); + Relation else_cond = Complement(copy(then_cond)); + else_cond.simplify(); + Relation new_else_known = Intersection(copy(known), copy(else_cond)); + new_else_known.simplify(); + + BoolSet<> then_active(active.size()), else_active(active.size()), indep_active(active.size()); + std::map<int, Relation> then_guards, else_guards; + for (BoolSet<>::iterator i = active.begin(); i != active.end(); i++) { + Relation &r = const_cast<std::map<int, Relation> &>(guards)[*i]; + if (Must_Be_Subset(copy(r), copy(then_cond))) { + Relation r2 = Gist(copy(r), copy(then_cond), 1); + if (!r2.is_obvious_tautology()) + then_guards[*i] = r2; + then_active.set(*i); + } + else if (Must_Be_Subset(copy(r), copy(else_cond))) { + Relation r2 = Gist(copy(r), copy(else_cond), 1); + if (!r2.is_obvious_tautology()) + else_guards[*i] = r2; + else_active.set(*i); + } + else + indep_active.set(*i); + } + assert(!then_active.empty()); + + CG_outputRepr *new_guard_repr = output_guard(ocg, then_cond, assigned_on_the_fly); + if (else_active.empty() && indep_active.empty()) { + guard_repr = ocg->CreateAnd(guard_repr, new_guard_repr); + return leaf_print_repr(then_active, then_guards, guard_repr, new_then_known, indent, ocg, remap, xforms, stmts, assigned_on_the_fly); + } + else if (else_active.empty() && !indep_active.empty()) { + int new_indent = (guard_repr==NULL)?indent:indent+1; + stmt_list = leaf_print_repr(then_active, then_guards, new_guard_repr, new_then_known, new_indent, ocg, remap, xforms, stmts, assigned_on_the_fly); + stmt_list = ocg->StmtListAppend(stmt_list, leaf_print_repr(indep_active, guards, NULL, known, new_indent, ocg, remap, xforms, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } + else { // (!else_active.empty()) + int new_indent = (guard_repr==NULL)?indent:indent+1; + CG_outputRepr *then_stmt_list = leaf_print_repr(then_active, then_guards, NULL, new_then_known, new_indent+1, ocg, remap, xforms, stmts, assigned_on_the_fly); + CG_outputRepr *else_stmt_list = leaf_print_repr(else_active, else_guards, NULL, new_else_known, new_indent+1, ocg, remap, xforms, stmts, assigned_on_the_fly); + stmt_list = ocg->CreateIf(new_indent, new_guard_repr, then_stmt_list, else_stmt_list); + if (!indep_active.empty()) + stmt_list = ocg->StmtListAppend(stmt_list, leaf_print_repr(indep_active, guards, NULL, known, new_indent, ocg, remap, xforms, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } + } +} + + +// +// heavy lifting for code output for one level of loop nodes +// +CG_outputRepr *loop_print_repr(const std::vector<CG_loop *> &loops, int start, int end, + const Relation &guard, CG_outputRepr *guard_repr, + int indent, CG_outputBuilder *ocg, const std::vector<CG_outputRepr *> &stmts, + const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) { + if (start >= end) + return NULL; + + Relation R = Gist(copy(loops[start]->guard_), copy(guard), 1); + if (Must_Be_Subset(Intersection(copy(loops[start]->known_), copy(guard)), copy(R))) { + int new_indent = (guard_repr==NULL)?indent:indent+1; + int i = start+1; + for ( ; i < end; i++) + if (!Gist(copy(loops[i]->guard_), copy(guard), 1).is_obvious_tautology()) + break; + CG_outputRepr *stmt_list = NULL; + for (int j = start; j < i; j++) + stmt_list = ocg->StmtListAppend(stmt_list, loops[j]->printRepr(false, new_indent, ocg, stmts, assigned_on_the_fly)); + stmt_list = ocg->StmtListAppend(stmt_list, loop_print_repr(loops, i, end, guard, NULL, new_indent, ocg, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } + + Relation then_cond = find_best_guard(R, loops, start, end); + assert(!then_cond.is_obvious_tautology()); + Relation else_cond = Complement(copy(then_cond)); + else_cond.simplify(); + + std::vector<CG_loop *> then_loops, else_loops, indep_loops; + int i = start; + for ( ; i < end; i++) + if (!Must_Be_Subset(copy(loops[i]->guard_), copy(then_cond))) + break; + int j = i; + for ( ; j < end; j++) + if (!Must_Be_Subset(copy(loops[j]->guard_), copy(else_cond))) + break; + assert(i>start); + + CG_outputRepr *new_guard_repr = output_guard(ocg, then_cond, assigned_on_the_fly); + if (j == i && end == j) { + guard_repr = ocg->CreateAnd(guard_repr, new_guard_repr); + Relation new_guard = Intersection(copy(guard), copy(then_cond)); + new_guard.simplify(); + return loop_print_repr(loops, start, end, new_guard, guard_repr, indent, ocg, stmts, assigned_on_the_fly); + } + else if (j == i && end > j) { + int new_indent = (guard_repr==NULL)?indent:indent+1; + Relation new_guard = Intersection(copy(guard), copy(then_cond)); + new_guard.simplify(); + CG_outputRepr *stmt_list = loop_print_repr(loops, start, i, new_guard, new_guard_repr, new_indent, ocg, stmts, assigned_on_the_fly); + stmt_list = ocg->StmtListAppend(stmt_list, loop_print_repr(loops, j, end, guard, NULL, new_indent, ocg, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } + else { // (j > i) + int new_indent = (guard_repr==NULL)?indent:indent+1; + Relation then_new_guard = Intersection(copy(guard), copy(then_cond)); + then_new_guard.simplify(); + CG_outputRepr *then_stmt_list = loop_print_repr(loops, start, i, then_new_guard, NULL, new_indent+1, ocg, stmts, assigned_on_the_fly); + Relation else_new_guard = Intersection(copy(guard), copy(else_cond)); + else_new_guard.simplify(); + CG_outputRepr *else_stmt_list = loop_print_repr(loops, i, j, else_new_guard, NULL, new_indent+1, ocg, stmts, assigned_on_the_fly); + CG_outputRepr *stmt_list = ocg->CreateIf(new_indent, new_guard_repr, then_stmt_list, else_stmt_list); + stmt_list = ocg->StmtListAppend(stmt_list, loop_print_repr(loops, j, end, guard, NULL, new_indent, ocg, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } +} + +} diff --git a/omegalib/code_gen/src/code_gen.cc b/omegalib/code_gen/src/code_gen.cc new file mode 100644 index 0000000..168c86b --- /dev/null +++ b/omegalib/code_gen/src/code_gen.cc @@ -0,0 +1,656 @@ +/***************************************************************************** + Copyright (C) 1994-2000 University of Maryland + Copyright (C) 2008 University of Southern California + Copyright (C) 2009-2010 University of Utah + All Rights Reserved. + + Purpose: + Start code generation process here. + + Notes: + + History: + 04/24/96 MMGenerateCode implementation, added by D people. Lei Zhou +*****************************************************************************/ + +#include <omega.h> +#include <omega/Rel_map.h> +#include <basic/Collection.h> +#include <basic/Bag.h> +#include <basic/Map.h> +#include <basic/util.h> +#include <basic/omega_error.h> +#include <math.h> +#include <vector> + +#include <code_gen/CG.h> +#include <code_gen/code_gen.h> +#include <code_gen/CG_outputBuilder.h> +#include <code_gen/CG_outputRepr.h> +#include <code_gen/CG_stringBuilder.h> +#include <code_gen/CG_stringRepr.h> +#include <code_gen/output_repr.h> + +namespace omega { + + +int last_level;// Should not be global, but it is. +SetTuple new_IS; +SetTupleTuple projected_nIS; +Tuple<CG_outputRepr *> statementInfo; +RelTuple transformations; + +//protonu--adding stuff to make Chun's code work with Gabe's +Tuple< Tuple<int> > smtNonSplitLevels; +Tuple< Tuple<std::string> > loopIdxNames;//per stmt +std::vector< std::pair<int, std::string> > syncs; + +//protonu-putting this in for now, not sure what all these do +//This lovely ugly hack allows us to extract hard upper-bounds at +//specific loop levels +int checkLoopLevel; +int stmtForLoopCheck; +int upperBoundForLevel; +int lowerBoundForLevel; +bool fillInBounds; + +//trick to static init checkLoopLevel to 0 +class JunkStaticInit{ public: JunkStaticInit(){ checkLoopLevel=0; fillInBounds=false;} }; +static JunkStaticInit junkInitInstance__; + +//end--protonu. + + +CG_result * gen_recursive(int level, IntTuple &isActive); + + +int code_gen_debug=0; + + +SetTuple filter_function_symbols(SetTuple &sets, bool keep_fs){ + SetTuple new_sets(sets.size()); + for(int i = 1; i <= sets.size(); i++) { + Relation R = sets[i]; + Relation &S = new_sets[i]; + assert(R.is_set()); + + S = Relation(R.n_set()); + S.copy_names(R); + F_Exists *fe = S.add_exists(); + F_Or *fo = fe->add_or(); + for(DNF_Iterator D(R.query_DNF()); D; D++) { + F_And *fa = fo->add_and(); + Variable_ID_Tuple &oldlocals = (*D)->locals(); + Section<Variable_ID> newlocals = fe->declare_tuple(oldlocals.size()); + + /* copy constraints. This is much more difficult than it needs + to be, but add_EQ(Constraint_Handle) doesn't work because it can't + keep track of existentially quantified varaibles across calls. + Sigh. */ + + for(EQ_Iterator e(*D); e; e++) + if((max_fs_arity(*e) > 0) == keep_fs){ + EQ_Handle n = fa->add_EQ(); + for(Constr_Vars_Iter cvi(*e,false);cvi;cvi++) + if((*cvi).var->kind() == Wildcard_Var) + n.update_coef(newlocals[oldlocals.index((*cvi).var)], + (*cvi).coef); + else + if((*cvi).var->kind() == Global_Var) + n.update_coef(S.get_local((*cvi).var->get_global_var(), + (*cvi).var->function_of()), + (*cvi).coef); + else + n.update_coef((*cvi).var,(*cvi).coef); + n.update_const((*e).get_const()); + n.finalize(); + } + + for(GEQ_Iterator g(*D); g; g++) + if((max_fs_arity(*g) > 0) == keep_fs) { + GEQ_Handle n = fa->add_GEQ(); + for(Constr_Vars_Iter cvi(*g,false);cvi;cvi++) + if((*cvi).var->kind() == Wildcard_Var) + n.update_coef(newlocals[oldlocals.index((*cvi).var)], + (*cvi).coef); + else + if((*cvi).var->kind() == Global_Var) + n.update_coef(S.get_local((*cvi).var->get_global_var(), + (*cvi).var->function_of()), + (*cvi).coef); + else + n.update_coef((*cvi).var,(*cvi).coef); + n.update_const((*g).get_const()); + n.finalize(); + } + } + S.finalize(); + } + + return new_sets; +} + + +RelTuple strip_function_symbols(SetTuple &sets) { + return filter_function_symbols(sets,false); +} + +RelTuple extract_function_symbols(SetTuple &sets) { + return filter_function_symbols(sets,true); +} + + +std::string MMGenerateCode(RelTuple &T, SetTuple &old_IS, Relation &known, int effort) { + Tuple<CG_outputRepr *> nameInfo; + for (int stmt = 1; stmt <= T.size(); stmt++) + nameInfo.append(new CG_stringRepr("s" + to_string(stmt))); + + CG_stringBuilder ocg; + CG_stringRepr *sRepr = static_cast<CG_stringRepr *>(MMGenerateCode(&ocg, T, old_IS, nameInfo, known, effort)); + + for (int i = 1; i <= nameInfo.size(); i++) + delete nameInfo[i]; + if (sRepr != NULL) + return GetString(sRepr); + else + return std::string(); +} + + +//***************************************************************************** +// MMGenerateCode implementation, added by D people. Lei Zhou, Apr. 24, 96 +//***************************************************************************** +CG_outputRepr* MMGenerateCode(CG_outputBuilder* ocg, RelTuple &T, SetTuple &old_IS, const Tuple<CG_outputRepr *> &stmt_content, Relation &known, int effort) { + int stmts = T.size(); + if (stmts == 0) + return ocg->CreateComment(1, "No statements found!"); + if (!known.is_null()) + known.simplify(); + + // prepare iteration spaces by splitting disjoint conjunctions + int maxStmt = 1; + last_level = 0; + for (int stmt = 1; stmt <= stmts; stmt++) { + int old_dim = T[stmt].n_out(); + if (old_dim > last_level) + last_level = old_dim; + + for (int i = 1; i <= old_IS[stmt].n_set(); i++) + T[stmt].name_input_var(i, old_IS[stmt].set_var(i)->name()); + for (int i = 1; i <= old_dim; i++) + T[stmt].name_output_var(i, std::string("t")+to_string(i)); + T[stmt].setup_names(); + + Relation R = Range(Restrict_Domain(copy(T[stmt]), copy(old_IS[stmt]))); + R.simplify(); + while(R.is_upper_bound_satisfiable()) { + new_IS.reallocate(maxStmt); + transformations.reallocate(maxStmt); + statementInfo.reallocate(maxStmt); + DNF *dnf = R.query_DNF(); + DNF_Iterator c(dnf); + Relation R2 = Relation(R, *c); + R2.simplify(); + if (R2.is_inexact()) + throw codegen_error("unknown constraint in loop bounds"); + if (known.is_null()) { + new_IS[maxStmt] = R2; + transformations[maxStmt] = T[stmt]; + statementInfo[maxStmt] = stmt_content[stmt]; + maxStmt++; + } + else { + Relation R2_extended = copy(R2); + Relation known_extended = copy(known); + if (R2.n_set() > known.n_set()) + known_extended = Extend_Set(known_extended, R2.n_set()-known.n_set()); + else if (R2.n_set() < known.n_set()) + R2_extended = Extend_Set(R2_extended, known.n_set()-R2.n_set()); + if (Intersection(R2_extended, known_extended).is_upper_bound_satisfiable()) { + new_IS[maxStmt] = R2; + transformations[maxStmt] = T[stmt]; + statementInfo[maxStmt] = stmt_content[stmt]; + maxStmt++; + } + } + c.next(); + if (!c.live()) + break; + if(code_gen_debug) { + fprintf(DebugFile, "splitting iteration space for disjoint form\n"); + fprintf(DebugFile, "Original iteration space: \n"); + R.print_with_subs(DebugFile); + fprintf(DebugFile, "First conjunct: \n"); + R2.print_with_subs(DebugFile); + } + Relation remainder(R, *c); + c.next(); + while (c.live()) { + remainder = Union(remainder, Relation(R, *c)); + c.next(); + } + R = Difference(remainder, copy(R2)); + R.simplify(); + if(code_gen_debug) { + fprintf(DebugFile, "Remaining iteration space: \n"); + R.print_with_subs(DebugFile); + } + } + } + + // reset number of statements + stmts = maxStmt-1; + if(stmts == 0) + return ocg->CreateComment(1, "No points in any of the iteration spaces!"); + + // entend iteration spaces to maximum dimension + for (int stmt = 1; stmt <= stmts; stmt++) { + int old_dim = new_IS[stmt].n_set(); + if (old_dim < last_level) { + new_IS[stmt] = Extend_Set(new_IS[stmt], last_level-old_dim); + F_And *f_root = new_IS[stmt].and_with_and(); + for (int i = old_dim+1; i <= last_level; i++) { + EQ_Handle h = f_root->add_EQ(); + h.update_coef(new_IS[stmt].set_var(i), 1); + h.update_const(posInfinity); + } + } + } + + // standarize the known condition + if(known.is_null()) { + known = Relation::True(last_level); + } + known = Extend_Set(known, last_level-known.n_set()); + for (int i = 1; i <= last_level; i++) + known.name_set_var(i, std::string("t")+to_string(i)); + known.setup_names(); + + // prepare projected subspaces for each loop level + projected_nIS.clear(); + projected_nIS.reallocate(last_level); + for(int i = 1; i <= last_level; i++ ) { + projected_nIS[i].reallocate(stmts); + } + for (int stmt = 1; stmt <= stmts; stmt++) { + if (last_level > 0) + projected_nIS[last_level][stmt] = new_IS[stmt]; + for (int i = last_level-1; i >= 1; i--) { + projected_nIS[i][stmt] = Project(copy(projected_nIS[i+1][stmt]), i+1, Set_Var); + projected_nIS[i][stmt].simplify(); + } + } + + // recursively generate AST + IntTuple allStmts(stmts); + for(int i = 1; i <= stmts; i++) + allStmts[i] = 1; + CG_result *cg = gen_recursive(1, allStmts); + + // always force finite bounds + cg = cg->recompute(known, known); + cg = cg->force_finite_bounds(); + + // loop overhead removal based on actual nesting depth -- by chun 09/17/2008 + for (int i = 1; i <= min(effort, cg->depth()); i++) + cg = cg->liftOverhead(i); + + // merge adjacent if-conditions -- by chun 10/24/2006 + cg->hoistGuard(); + + // really print out the loop + //CG_outputRepr* sRepr = cg->printRepr(ocg, 1, std::vector<CG_outputRepr *>(last_level, NULL)); + CG_outputRepr* sRepr = cg->printRepr(ocg, 1, std::vector<CG_outputRepr *>(last_level)); + delete cg; + cg = NULL; + projected_nIS.clear(); + transformations.clear(); + new_IS.clear(); + + return sRepr; +} + +//protonu--overload the above MMGenerateCode to take into the CUDA-CHiLL +CG_outputRepr* MMGenerateCode(CG_outputBuilder* ocg, RelTuple &T, SetTuple &old_IS, + const Tuple<CG_outputRepr *> &stmt_content, Relation &known, + Tuple< IntTuple >& smtNonSplitLevels_, + std::vector< std::pair<int, std::string> > syncs_, + const Tuple< Tuple<std::string> >& loopIdxNames_, + int effort) { + int stmts = T.size(); + if (stmts == 0) + return ocg->CreateComment(1, "No statements found!"); + if (!known.is_null()) + known.simplify(); + + //protonu-- + //easier to handle this as a global + smtNonSplitLevels = smtNonSplitLevels_; + syncs = syncs_; + loopIdxNames = loopIdxNames_; + //end-protonu + + + + // prepare iteration spaces by splitting disjoint conjunctions + int maxStmt = 1; + last_level = 0; + for (int stmt = 1; stmt <= stmts; stmt++) { + int old_dim = T[stmt].n_out(); + if (old_dim > last_level) + last_level = old_dim; + + for (int i = 1; i <= old_IS[stmt].n_set(); i++) + T[stmt].name_input_var(i, old_IS[stmt].set_var(i)->name()); + for (int i = 1; i <= old_dim; i++) + T[stmt].name_output_var(i, std::string("t")+to_string(i)); + T[stmt].setup_names(); + + Relation R = Range(Restrict_Domain(copy(T[stmt]), copy(old_IS[stmt]))); + R.simplify(); + while(R.is_upper_bound_satisfiable()) { + new_IS.reallocate(maxStmt); + transformations.reallocate(maxStmt); + statementInfo.reallocate(maxStmt); + + //protonu--putting in fix provided by Mark Hall + smtNonSplitLevels.reallocate(maxStmt); + //end-protonu + + + DNF *dnf = R.query_DNF(); + DNF_Iterator c(dnf); + Relation R2 = Relation(R, *c); + R2.simplify(); + if (R2.is_inexact()) + throw codegen_error("unknown constraint in loop bounds"); + if (known.is_null()) { + new_IS[maxStmt] = R2; + transformations[maxStmt] = T[stmt]; + statementInfo[maxStmt] = stmt_content[stmt]; + maxStmt++; + } + else { + Relation R2_extended = copy(R2); + Relation known_extended = copy(known); + if (R2.n_set() > known.n_set()) + known_extended = Extend_Set(known_extended, R2.n_set()-known.n_set()); + else if (R2.n_set() < known.n_set()) + R2_extended = Extend_Set(R2_extended, known.n_set()-R2.n_set()); + if (Intersection(R2_extended, known_extended).is_upper_bound_satisfiable()) { + new_IS[maxStmt] = R2; + transformations[maxStmt] = T[stmt]; + statementInfo[maxStmt] = stmt_content[stmt]; + maxStmt++; + } + } + c.next(); + if (!c.live()) + break; + if(code_gen_debug) { + fprintf(DebugFile, "splitting iteration space for disjoint form\n"); + fprintf(DebugFile, "Original iteration space: \n"); + R.print_with_subs(DebugFile); + fprintf(DebugFile, "First conjunct: \n"); + R2.print_with_subs(DebugFile); + } + Relation remainder(R, *c); + c.next(); + while (c.live()) { + remainder = Union(remainder, Relation(R, *c)); + c.next(); + } + R = Difference(remainder, copy(R2)); + R.simplify(); + if(code_gen_debug) { + fprintf(DebugFile, "Remaining iteration space: \n"); + R.print_with_subs(DebugFile); + } + } + } + + // reset number of statements + stmts = maxStmt-1; + if(stmts == 0) + return ocg->CreateComment(1, "No points in any of the iteration spaces!"); + + // entend iteration spaces to maximum dimension + for (int stmt = 1; stmt <= stmts; stmt++) { + int old_dim = new_IS[stmt].n_set(); + if (old_dim < last_level) { + new_IS[stmt] = Extend_Set(new_IS[stmt], last_level-old_dim); + F_And *f_root = new_IS[stmt].and_with_and(); + for (int i = old_dim+1; i <= last_level; i++) { + EQ_Handle h = f_root->add_EQ(); + h.update_coef(new_IS[stmt].set_var(i), 1); + h.update_const(posInfinity); + } + } + } + + // standarize the known condition + if(known.is_null()) { + known = Relation::True(last_level); + } + known = Extend_Set(known, last_level-known.n_set()); + for (int i = 1; i <= last_level; i++) + known.name_set_var(i, std::string("t")+to_string(i)); + known.setup_names(); + + // prepare projected subspaces for each loop level + projected_nIS.clear(); + projected_nIS.reallocate(last_level); + for(int i = 1; i <= last_level; i++ ) { + projected_nIS[i].reallocate(stmts); + } + for (int stmt = 1; stmt <= stmts; stmt++) { + if (last_level > 0) + projected_nIS[last_level][stmt] = new_IS[stmt]; + for (int i = last_level-1; i >= 1; i--) { + projected_nIS[i][stmt] = Project(copy(projected_nIS[i+1][stmt]), i+1, Set_Var); + projected_nIS[i][stmt].simplify(); + } + } + + // recursively generate AST + IntTuple allStmts(stmts); + for(int i = 1; i <= stmts; i++) + allStmts[i] = 1; + CG_result *cg = gen_recursive(1, allStmts); + + // always force finite bounds + cg = cg->recompute(known, known); + cg = cg->force_finite_bounds(); + + // loop overhead removal based on actual nesting depth -- by chun 09/17/2008 + for (int i = 1; i <= min(effort, cg->depth()); i++) + cg = cg->liftOverhead(i); + + // merge adjacent if-conditions -- by chun 10/24/2006 + cg->hoistGuard(); + + // really print out the loop + //CG_outputRepr* sRepr = cg->printRepr(ocg, 1, std::vector<CG_outputRepr *>(last_level, NULL)); + CG_outputRepr* sRepr = cg->printRepr(ocg, 1, std::vector<CG_outputRepr *>(last_level )); + delete cg; + cg = NULL; + projected_nIS.clear(); + transformations.clear(); + new_IS.clear(); + + return sRepr; +} + +CG_result *gen_recursive(int level, IntTuple &isActive) { + int stmts = isActive.size(); + + Set<int> active; + int s; + for(s = 1; s <= stmts; s++) + if(isActive[s]) active.insert(s); + + assert (active.size() >= 1); + if(level > last_level) return new CG_leaf(isActive); + + if (active.size() == 1) + return new CG_loop(isActive,level, gen_recursive(level+1,isActive)); + + bool constantLevel = true; + + int test_rel_size; + coef_t start,finish; + finish = -(posInfinity-1); // -(MAXINT-1); + start = posInfinity; // MAXINT; + Tuple<coef_t> when(stmts); + for(s=1; s<=stmts; s++) if (isActive[s]) { + coef_t lb,ub; + test_rel_size = projected_nIS[level][s].n_set(); + projected_nIS[level][s].single_conjunct() + ->query_variable_bounds( + projected_nIS[level][s].set_var(level), + lb,ub); + if(code_gen_debug) { + fprintf(DebugFile, "IS%d: " coef_fmt " <= t%d <= " coef_fmt "\n",s, + lb,level,ub); + projected_nIS[level][s].prefix_print(DebugFile); + } + if (lb != ub) { + constantLevel = false; + break; + } + else { + set_max(finish,lb); + set_min(start,lb); + when[s] = lb; + } + } + + + if (constantLevel && finish-start <= stmts) { + IntTuple newActive(isActive.size()); + for(int i=1; i<=stmts; i++) + newActive[i] = isActive[i] && when[i] == start; + CG_result *r = new CG_loop(isActive,level, + gen_recursive(level+1,newActive)); + for(coef_t time = start+1; time <= finish; time++) { + int count = 0; + for(int i=1; i<=stmts; i++) { + newActive[i] = isActive[i] && when[i] == time; + if (newActive[i]) count++; + } + if (count) { + Relation test_rel(test_rel_size); + GEQ_Handle g = test_rel.and_with_GEQ(); + g.update_coef(test_rel.set_var(level),-1); + g.update_const(time-1); + + r = new CG_split(isActive,level,test_rel,r, + new CG_loop(isActive,level, + gen_recursive(level+1,newActive))); + } + } + return r; + } + +// Since the Hull computation is approximate, we will get regions that +// have no stmts. (since we will have split on constraints on the +// hull, and thus we are looking at a region outside the convex hull +// of all the iteration spaces.) +#if 1 + Relation hull = Hull(projected_nIS[level],isActive,1); +#else + Relation hull = Hull(projected_nIS[level],isActive,0); +#endif + + if(code_gen_debug) { + fprintf(DebugFile, "Hull (level %d) is:\n",level); + hull.prefix_print(DebugFile); + } + + + IntTuple firstChunk(isActive); + IntTuple secondChunk(isActive); + + //protonu-warn Chun about this change + //This does some fancy splitting of statements into loops with the + //fewest dimentions, but that's not necessarily what we want when + //code-gening for CUDA. smtNonSplitLevels keeps track per-statment of + //the levels that should not be split on. + bool checkForSplits = true; + for (int s = 1; s <= isActive.size(); s++){ + if (isActive[s]) { + if(s < smtNonSplitLevels.size() && smtNonSplitLevels[s].index(level-2) != 0){ + checkForSplits = false; + break; + } + } + } + + //protonu-modifying the next for loop + for (int s = 1; checkForSplits && s <= isActive.size(); s++) + if (isActive[s]) { + Relation gist = Gist(copy(projected_nIS[level][s]),copy(hull),1); + if (gist.is_obvious_tautology()) break; + gist.simplify(); + Conjunct *s_conj = gist.single_conjunct(); + for(GEQ_Iterator G(s_conj); G; G++) { + Relation test_rel(gist.n_set()); + test_rel.and_with_GEQ(*G); + Variable_ID v = set_var(level); + coef_t sign = (*G).get_coef(v); + if(sign > 0) test_rel = Complement(test_rel); + if(code_gen_debug) { + fprintf(DebugFile, "Considering split from stmt %d:\n",s); + test_rel.prefix_print(DebugFile); + } + + firstChunk[s] = sign <= 0; + secondChunk[s] = sign > 0; + int numberFirst = sign <= 0; + int numberSecond = sign > 0; + + for (int s2 = 1; s2 <= isActive.size(); s2++) + if (isActive[s2] && s2 != s) { + if(code_gen_debug) + fprintf(DebugFile,"Consider stmt %d\n",s2); + bool t = Intersection(copy(projected_nIS[level][s2]), + copy(test_rel)).is_upper_bound_satisfiable(); + bool f = Difference(copy(projected_nIS[level][s2]), + copy(test_rel)).is_upper_bound_satisfiable(); + assert(t || f); + if(code_gen_debug && t&&f) + fprintf(DebugFile, "Slashes stmt %d\n",s2); + if (t&&f) goto nextGEQ; + if(code_gen_debug) { + if (t) + fprintf(DebugFile, "true for stmt %d\n",s2); + else + fprintf(DebugFile, "false for stmt %d\n",s2); + } + if (t) numberFirst++; + else numberSecond++; + firstChunk[s2] = t; + secondChunk[s2] = !t; + } + + assert(numberFirst+numberSecond>1 && "Can't handle wildcard in iteration space"); + if(code_gen_debug) + fprintf(DebugFile, "%d true, %d false\n", + numberFirst, + numberSecond); + if (numberFirst && numberSecond) { + // Found a dividing constraint + return new CG_split(isActive,level,test_rel, + gen_recursive(level,firstChunk), + gen_recursive(level,secondChunk)); + } + nextGEQ: ; + } + } + + // No way found to divide stmts without splitting, generate loop + + return new CG_loop(isActive,level, gen_recursive(level+1,isActive)); +} + +} diff --git a/omegalib/code_gen/src/codegen.cc b/omegalib/code_gen/src/codegen.cc new file mode 100755 index 0000000..92ca702 --- /dev/null +++ b/omegalib/code_gen/src/codegen.cc @@ -0,0 +1,378 @@ +/***************************************************************************** + Copyright (C) 1994-2000 the Omega Project Team + Copyright (C) 2005-2011 Chun Chen + All Rights Reserved. + + Purpose: + CodeGen class as entry point for code generation. + + Notes: + Loop variable name prefix should not cause any possible name conflicts + with original loop variables wrapped in statement holder. This guarantees + that variable substitution done correctly in the generated code. + + History: + 04/24/96 MMGenerateCode, added by Fortran D people. Lei Zhou + 09/17/08 loop overhead removal based on actual nesting depth -- by chun + 03/05/11 fold MMGenerateCode into CodeGen class, Chun Chen +*****************************************************************************/ + +#include <typeinfo> +#include <omega.h> +#include <basic/util.h> +#include <math.h> +#include <vector> +#include <algorithm> + +#include <code_gen/CG.h> +#include <code_gen/codegen.h> +#include <code_gen/CG_outputBuilder.h> +#include <code_gen/codegen_error.h> + +namespace omega { + +const std::string CodeGen::loop_var_name_prefix = "t"; +const int CodeGen::var_substitution_threshold = 10; + +//Anand--adding stuff to make Chun's code work with Gabe's +std::vector< std::vector<int> > smtNonSplitLevels; +std::vector< std::vector<std::string> > loopIdxNames;//per stmt +std::vector< std::pair<int, std::string> > syncs; + + + +CodeGen::CodeGen(const std::vector<Relation> &xforms, const std::vector<Relation> &IS, const Relation &known, std::vector< std::vector<int> > smtNonSplitLevels_ , std::vector< std::vector<std::string> > loopIdxNames_, std::vector< std::pair<int, std::string> > syncs_) { + // check for sanity of parameters + int num_stmt = IS.size(); + if (xforms.size() != num_stmt) + throw std::invalid_argument("number of iteration spaces does not match number of transformations"); + known_ = copy(known); + if (known_.n_out() != 0) + throw std::invalid_argument("known condition must be a set relation"); + if (known_.is_null()) + known_ = Relation::True(0); + else + known_.simplify(2, 4); + if (!known_.is_upper_bound_satisfiable()) + return; + if (known_.number_of_conjuncts() > 1) + throw std::invalid_argument("only one conjunct allowed in known condition"); + xforms_ = xforms; + for (int i = 0; i < num_stmt; i++) { + xforms_[i].simplify(); + if (!xforms_[i].has_single_conjunct()) + throw std::invalid_argument("mapping relation must have only one conjunct"); + if (xforms_[i].n_inp() != IS[i].n_inp() || IS[i].n_out() != 0) + throw std::invalid_argument("illegal iteration space or transformation arity"); + } + + + //protonu-- + //easier to handle this as a global + smtNonSplitLevels = smtNonSplitLevels_; + syncs = syncs_; + loopIdxNames = loopIdxNames_; + //end-protonu + + + + // find the maximum iteration space dimension we are going to operate on + int num_level = known_.n_inp(); + for (int i = 0; i < num_stmt; i++) + if (xforms_[i].n_out() > num_level) + num_level = xforms_[i].n_out(); + known_ = Extend_Set(known_, num_level-known_.n_inp()); + for (int i = 1; i <= num_level; i++) + known_.name_set_var(i, loop_var_name_prefix + to_string(i)); + known_.setup_names(); + + // split disjoint conjunctions in original iteration spaces + std::vector<Relation> new_IS; + for (int i = 0; i < num_stmt; i++) { + for (int j = 1; j <= IS[i].n_inp(); j++) + xforms_[i].name_input_var(j, const_cast<std::vector<Relation> &>(IS)[i].input_var(j)->name()); + for (int j = 1; j <= xforms_[i].n_out(); j++) + xforms_[i].name_output_var(j, loop_var_name_prefix + to_string(j)); + xforms_[i].setup_names(); + + Relation R = Range(Restrict_Domain(copy(xforms_[i]), copy(IS[i]))); + R = Intersection(Extend_Set(R, num_level-R.n_inp()), copy(known_)); + R.simplify(2, 4); + if (R.is_inexact()) + throw codegen_error("cannot generate code for inexact iteration spaces"); + + while(R.is_upper_bound_satisfiable()) { + DNF *dnf = R.query_DNF(); + DNF_Iterator c(dnf); + Relation R2 = Relation(R, *c); + R2.simplify(); + new_IS.push_back(copy(R2)); + remap_.push_back(i); + c.next(); + if (!c.live()) + break; + Relation remainder(R, *c); + c.next(); + while (c.live()) { + remainder = Union(remainder, Relation(R, *c)); + c.next(); + } + R = Difference(remainder, R2); + R.simplify(2, 4); + } + } + + // number of new statements after splitting + num_stmt = new_IS.size(); + if(!smtNonSplitLevels.empty()) + smtNonSplitLevels.resize(num_stmt); + // assign a dummy value to loops created for the purpose of expanding to maximum dimension + for (int i = 0; i < num_stmt; i++) { + if (xforms[remap_[i]].n_out() < num_level) { + F_And *f_root = new_IS[i].and_with_and(); + for (int j = xforms[remap_[i]].n_out()+1; j <= num_level; j++) { + EQ_Handle h = f_root->add_EQ(); + h.update_coef(new_IS[i].set_var(j), 1); + h.update_const(posInfinity); + } + new_IS[i].simplify(); + } + } + + // calculate projected subspaces for each loop level once and save for CG tree manipulation later + projected_IS_ = std::vector<std::vector<Relation> >(num_level); + for (int i = 0; i < num_level; i++) + projected_IS_[i] = std::vector<Relation>(num_stmt); + for (int i = 0; i < num_stmt; i++) { + if (num_level > 0) + projected_IS_[num_level-1][i] = new_IS[i]; + for (int j = num_level-1; j >= 1; j--) { + projected_IS_[j-1][i] = Project(copy(projected_IS_[j][i]), j+1, Set_Var); + projected_IS_[j-1][i].simplify(2, 4); + } + } +} + + +CG_result *CodeGen::buildAST(int level, const BoolSet<> &active, bool split_on_const, const Relation &restriction) { + if (level > num_level()) + return new CG_leaf(this, active); + + int num_active_stmt = active.num_elem(); + if (num_active_stmt == 0) + return NULL; + else if (num_active_stmt == 1) + return new CG_loop(this, active, level, buildAST(level+1, active, true, restriction)); + + // use estimated constant bounds for fast non-overlap iteration space splitting + if (split_on_const) { + std::vector<std::pair<std::pair<coef_t, coef_t>, int> > bounds; + + for (BoolSet<>::const_iterator i = active.begin(); i != active.end(); i++) { + Relation r = Intersection(copy(projected_IS_[level-1][*i]), copy(restriction)); + r.simplify(2, 4); + if (!r.is_upper_bound_satisfiable()) + continue; + coef_t lb, ub; + r.single_conjunct()->query_variable_bounds(r.set_var(level),lb,ub); + bounds.push_back(std::make_pair(std::make_pair(lb, ub), *i)); + } + sort(bounds.begin(), bounds.end()); + + std::vector<Relation> split_cond; + std::vector<CG_result *> split_child; + + coef_t prev_val = -posInfinity; + coef_t next_val = bounds[0].first.second; + BoolSet<> next_active(active.size()); + int i = 0; + while (i < bounds.size()) { + if (bounds[i].first.first <= next_val) { + next_active.set(bounds[i].second); + next_val = max(next_val, bounds[i].first.second); + i++; + } + else { + Relation r(num_level()); + F_And *f_root = r.add_and(); + if (prev_val != -posInfinity) { + GEQ_Handle h = f_root->add_GEQ(); + h.update_coef(r.set_var(level), 1); + h.update_const(-prev_val-1); + } + if (next_val != posInfinity) { + GEQ_Handle h = f_root->add_GEQ(); + h.update_coef(r.set_var(level), -1); + h.update_const(next_val); + } + r.simplify(); + + Relation new_restriction = Intersection(copy(r), copy(restriction)); + new_restriction.simplify(2, 4); + CG_result *child = buildAST(level, next_active, false, new_restriction); + if (child != NULL) { + split_cond.push_back(copy(r)); + split_child.push_back(child); + } + next_active.unset_all(); + prev_val = next_val; + next_val = bounds[i].first.second; + } + } + if (!next_active.empty()) { + Relation r = Relation::True(num_level()); + if (prev_val != -posInfinity) { + F_And *f_root = r.and_with_and(); + GEQ_Handle h = f_root->add_GEQ(); + h.update_coef(r.set_var(level), 1); + h.update_const(-prev_val-1); + r.simplify(); + } + Relation new_restriction = Intersection(copy(r), copy(restriction)); + new_restriction.simplify(2, 4); + CG_result *child = buildAST(level, next_active, false, new_restriction); + if (child != NULL) { + split_cond.push_back(copy(r)); + split_child.push_back(child); + } + } + + if (split_child.size() == 0) + return NULL; + else if (split_child.size() == 1) + return split_child[0]; + else + return new CG_split(this, active, split_cond, split_child); + } + // check bound conditions exhaustively for non-overlap iteration space splitting + else { + std::vector<Relation> Rs(active.size()); + for (BoolSet<>::const_iterator i = active.begin(); i != active.end(); i++) { + Rs[*i] = Intersection(Approximate(copy(projected_IS_[level-1][*i])), copy(restriction)); + Rs[*i].simplify(2, 4); + } + Relation hull = SimpleHull(Rs); + + //protonu-warn Chun about this change + //This does some fancy splitting of statements into loops with the + //fewest dimentions, but that's not necessarily what we want when + //code-gening for CUDA. smtNonSplitLevels keeps track per-statment of + //the levels that should not be split on. + bool checkForSplits = true; + for (BoolSet<>::const_iterator i = active.begin(); i != active.end(); i++) { + if(*i < smtNonSplitLevels.size()) + for(int k = 0; k <smtNonSplitLevels[*i].size(); k++) + if(smtNonSplitLevels[*i][k] == (level-2)){ + checkForSplits = false; + break; + } + } + + + + + for (BoolSet<>::const_iterator i = active.begin(); i != active.end() && checkForSplits; i++) { + Relation r = Gist(copy(Rs[*i]), copy(hull), 1); + if (r.is_obvious_tautology()) + continue; + r = EQs_to_GEQs(r); + + for (GEQ_Iterator e = r.single_conjunct()->GEQs(); e; e++) { + if ((*e).has_wildcards()) + continue; + + Relation cond = Relation::True(num_level()); + BoolSet<> first_chunk(active.size()); + BoolSet<> second_chunk(active.size()); + + if ((*e).get_coef(hull.set_var(level)) > 0) { + cond.and_with_GEQ(*e); + cond = Complement(cond);; + cond.simplify(); + second_chunk.set(*i); + } + else if ((*e).get_coef(hull.set_var(level)) < 0) { + cond.and_with_GEQ(*e); + cond.simplify(); + first_chunk.set(*i); + } + else + continue; + + bool is_proper_split_cond = true; + for (BoolSet<>::const_iterator j = active.begin(); j != active.end(); j++) + if ( *j != *i) { + bool in_first = Intersection(copy(Rs[*j]), copy(cond)).is_upper_bound_satisfiable(); + bool in_second = Difference(copy(Rs[*j]), copy(cond)).is_upper_bound_satisfiable(); + + if (in_first && in_second) { + is_proper_split_cond = false; + break; + } + + if (in_first) + first_chunk.set(*j); + else if (in_second) + second_chunk.set(*j); + } + + if (is_proper_split_cond && first_chunk.num_elem() != 0 && second_chunk.num_elem() != 0) { + CG_result *first_cg = buildAST(level, first_chunk, false, copy(cond)); + CG_result *second_cg = buildAST(level, second_chunk, false, Complement(copy(cond))); + if (first_cg == NULL) + return second_cg; + else if (second_cg == NULL) + return first_cg; + else { + std::vector<Relation> split_cond; + std::vector<CG_result *> split_child; + split_cond.push_back(copy(cond)); + split_child.push_back(first_cg); + split_cond.push_back(Complement(copy(cond))); + split_child.push_back(second_cg); + + return new CG_split(this, active, split_cond, split_child); + } + } + } + } + return new CG_loop(this, active, level, buildAST(level+1, active, true, restriction)); + } +} + + +CG_result *CodeGen::buildAST(int effort) { + if (remap_.size() == 0) + return NULL; + + CG_result *cgr = buildAST(1, ~BoolSet<>(remap_.size()), true, Relation::True(num_level())); + if (cgr == NULL) + return NULL; + + + // break down the complete iteration space condition to levels of bound/guard condtions + cgr = cgr->recompute(cgr->active_, copy(known_), copy(known_)); + + + + if (cgr == NULL) + return NULL; + + // calculate each loop's nesting depth + int depth = cgr->populateDepth(); + + + // redistribute guard condition locations by additional splittings + std::pair<CG_result *, Relation> result = cgr->liftOverhead(min(effort,depth), false); + + // since guard conditions are postponed for non-loop levels, hoist them now. + // this enables proper if-condition simplication when outputting actual code. + result.first->hoistGuard(); + + + + + return result.first; +} + +} diff --git a/omegalib/code_gen/src/cscope.out b/omegalib/code_gen/src/cscope.out new file mode 100644 index 0000000..ac4e74f --- /dev/null +++ b/omegalib/code_gen/src/cscope.out @@ -0,0 +1,89773 @@ +cscope 15 $HOME/suif-cuda-omega-latest/code_gen/src 0000481316 + @CG.cc + +21 + ~<omega.h +> + +22 + ~<¡ršg.h +> + +23 + ~<basic/omega_”rÜ.h +> + +24 + ~<code_g’/CG.h +> + +25 + ~<code_g’/CG_ouutBužd”.h +> + +26 + ~<code_g’/CG_ouutR•r.h +> + +27 + ~<code_g’/CG_¡ršgBužd”.h +> + +28 + ~<code_g’/ouut_»´.h +> + +29 + ~<¡ack +> + +31 +Çme¥aû + + gomega + { + +33
+Tu¶e +< +R–©iÚ +> +Ãw_IS +; + +34
+Tu¶e +<Tu¶e< +R–©iÚ +> > +´ojeùed_nIS +; + +35
+Tu¶e +< +CG_ouutR•r + *> +¡©em’tInfo +; + +36
+Tu¶e +< +R–©iÚ +> +ŒªsfÜm©iÚs +; + +37
+Ï¡_Ëv– +; + +39 +CG_»suÉ + * +g’_»cursive +( +Ëv– +, +IÁTu¶e + & +isAùive +); + +43 +Çme¥aû + + gomega + { + +45
+Tu¶e +< +IÁTu¶e +> +smtNÚS¶™Lev–s +; + +46
+Tu¶e +<Tu¶e< +¡d +:: +¡ršg +> > +loÝIdxNames +; + +47
+¡d +:: +veùÜ +<¡d:: +·œ +<, std:: +¡ršg +> > +syncs +; + +48
+checkLoÝLev– +; + +49
+¡mtFÜLoÝCheck +; + +50
+uµ”BoundFÜLev– +; + +51
+low”BoundFÜLev– +; + +52
+boÞ + +fžlInBounds +; + +58 + g¡d +:: +¡ršg + +CG_»suÉ +:: +´št +( +šd’t +) { + +59 +CG_¡ršgBužd” + +ocg +; + +60 +CG_ouutR•r + * + g»´ + = +´štR•r +(& +ocg +, +šd’t +, + +61 +¡d +:: +veùÜ +< +CG_ouutR•r + *>( +Ï¡_Ëv– +, + +62 +¡©ic_ÿ¡ +< +CG_ouutR•r + *>( +NULL +))); + +63 ià( + g»´ + =ð +NULL +) + +64 +¡d +:: +¡ršg +(); + +66 +G‘SŒšg +( +»´ +); + +73 + gCG_¥l™ +:: +CG_¥l™ +( +IÁTu¶e + & +aùive +, +lvl +, cÚ¡ +R–©iÚ + & +cÚd_ +, + +74 +CG_»suÉ + * +T +, CG_»suÉ * +F +) { + +75 +R–©iÚ + + gcÚd + = +cÝy +( +cÚd_ +); + +76 +as£¹ +( +cÚd +. +has_sšgË_cÚjunù +()); + +78 +cÛf_t + + gc + = 0; + +79 + gpos + = -1; + +80 +GEQ_I‹¿tÜ + +G +( +cÚd +. +sšgË_cÚjunù +()); + +81 ià( + gG +) { + +82 +CÚ¡r_V¬s_I‹r + +cvi +(* +G +, +çl£ +); + gcvi +; cvi++) + +83 ià((* + gcvi +). + gcÛf + && (*cvi). + gv¬ +-> +kšd +(è=ð +IÅut_V¬ + + +84 && (* +cvi +). +v¬ +-> +g‘_pos™iÚ +(è> +pos +) { + +85 +pos + = (* +cvi +). +v¬ +-> +g‘_pos™iÚ +(); + +86 + gc + = (* +cvi +). +cÛf +; + +89 #iâdeà +NDEBUG + + +90 ià( + gpos + > + glvl + + 1) { + +91 +årštf +( +DebugFže +, "IÎeg® s¶™‡ˆlvÈ%d\n", +lvl +); + +92 + gcÚd +. +´efix_´št +( +DebugFže +); + +93 + gcode_g’_debug + = 1; + +97 +as£¹ +( +pos + =ð0 ||…o <ð +lvl + + 1); + +99 ià( + gpos + > 0 && + gc + > 0) { + +100 +CG_»suÉ + * + gfoo + = +T +; + +101 + gT + = +F +; + +102 + gF + = +foo +; + +103 ià( + gcode_g’_debug +) { + +104 +årštf +( +DebugFže +, + +105 "Rev”sšg cÏu£ iÀÃw s¶™‚od©†vÈ%d\n", +lvl +); + +106 + gcÚd +. +´efix_´št +( +DebugFže +); + +108 + gcÚd + = +Com¶em’t +( +cÚd +); + +110 + gcÚd +. +sim¶ify +(); + +112 +as£¹ +( +cÚd +. +has_sšgË_cÚjunù +()); + +115 +as£¹ +( +EQ_I‹¿tÜ +( +cÚd +. +sšgË_cÚjunù +())); + +117 + gisAùive + = +aùive +; + +118 + gcÚd™iÚ + = +cÚd +; + +119 + gËv– + = +lvl +; + +120 + gŒueCÏu£ + = +T +; + +121 + gçl£CÏu£ + = +F +; + +124 + g¡d +:: +¡ršg + +CG_¥l™ +:: +´štSŒuùu» +( +šd’t +) { + +125 +¡d +:: +¡ršg + +»suÉ + = +G‘Ind’tS·ûs +( +šd’t +) + "// split‡t " + +126 + +to_¡ršg +(( *è +this +è+ "\n" + +G‘Ind’tS·ûs +( +šd’t +) + +127 + "// gu¬d:" + +gu¬d +. +´št_fÜmuÏ_to_¡ršg +() + "\n" + +128 + +G‘Ind’tS·ûs +( +šd’t +) + "// if " + +129 + +cÚd™iÚ +. +´št_fÜmuÏ_to_¡ršg +() + "hen\n" + +130 + +ŒueCÏu£ +-> +´štSŒuùu» +( +šd’t + + 1è+ +G‘Ind’tS·ûs +(indent) + +131 + "//ƒl£\n" + +çl£CÏu£ +-> +´štSŒuùu» +( +šd’t + + 1); + +132 + g»suÉ +; + +135 +CG_ouutR•r +* + gCG_¥l™ +:: +´štR•r +( +CG_ouutBužd” +* +ocg +, +šd’t +, + +136 cÚ¡ +¡d +:: +veùÜ +< +CG_ouutR•r + *> & +assigÃd_Ú_the_æy +) { + +138 ià(! +Mu¡_Be_Sub£t +( +cÝy +( +»¡riùiÚs +), cÝy( +known +))) + +139 +´štf +("------------wrong------------------\n"); + +141 +CG_ouutR•r +* + g¡mtLi¡ +; + +143 +CG_ouutR•r + * + gù¾R•r + = +NULL +; + +144 ià(! + ggu¬d +. +is_nuÎ +(è&& !gu¬d. +is_obvious_utÞogy +()) { + +145 + gù¾R•r + = +ouutGu¬d +( +ocg +, +gu¬d +, +assigÃd_Ú_the_æy +); + +146 + gšd’t +++; + +148 ià( + gù¾R•r + !ð +NULL +) + +149 +¡mtLi¡ + = +ocg +-> +C»©eIf +( +šd’t + - 1, +ù¾R•r +, + +150 +ŒueCÏu£ +-> +´štR•r +( +ocg +, +šd’t +, +assigÃd_Ú_the_æy +), + +151 +çl£CÏu£ +-> +´štR•r +( +ocg +, +šd’t +, +assigÃd_Ú_the_æy +)); + +153 + g¡mtLi¡ + = +ocg +-> +StmtLi¡Aµ’d +( + +154 +ŒueCÏu£ +-> +´štR•r +( +ocg +, +šd’t +, +assigÃd_Ú_the_æy +), + +155 +çl£CÏu£ +-> +´štR•r +( +ocg +, +šd’t +, +assigÃd_Ú_the_æy +)); + +157 + g¡mtLi¡ +; + +160 +CG_»suÉ + * + gCG_¥l™ +:: +liáOv”h—d +( +d•th +) { + +161 +as£¹ +( +d•th + >= 1); + +162 + gŒueCÏu£ + = +ŒueCÏu£ +-> +liáOv”h—d +( +d•th +); + +163 + gçl£CÏu£ + = +çl£CÏu£ +-> +liáOv”h—d +( +d•th +); + +164 + gthis +; + +167 +CG_»suÉ + * + gCG_¥l™ +:: +fÜû_fš™e_bounds +() { + +168 +ŒueCÏu£ + =rueCÏu£-> +fÜû_fš™e_bounds +(); + +169 + gçl£CÏu£ + = +çl£CÏu£ +-> +fÜû_fš™e_bounds +(); + +170 + gthis +; + +173 +R–©iÚ + + gCG_¥l™ +:: +fšdOv”h—d +( +liáTo +) { + +174 +R–©iÚ + +r + = +ŒueCÏu£ +-> +fšdOv”h—d +( +liáTo +); + +175 ià( + gr +. +is_obvious_utÞogy +()) + +176 + gr + = +çl£CÏu£ +-> +fšdOv”h—d +( +liáTo +); + +177 + gr +; + +180 +CG_»suÉ + * + gCG_¥l™ +:: +»compu‹ +(cÚ¡ +R–©iÚ + & +k +, cÚ¡ R–©iÚ & +r +) { + +181 + gknown + = +cÝy +( +k +); + +182 + g»¡riùiÚs + = +cÝy +( +r +); + +184 + gnumAùive + = 0; + +185 + gs + = 1; s <ð +isAùive +. +size +(); s++) + +186 ià( + gisAùive +[ +s +]) { + +187 +R–©iÚ + + gI + = +´ojeùed_nIS +[ +Ëv– +][ +s +]; + +188 ià(! +IÁ”£ùiÚ +( +cÝy +( +»¡riùiÚs +), +I +). +is_uµ”_bound_§tisfŸbË +()) + +189 + gisAùive +[ +s +] = 0; + +191 + gnumAùive +++; + +193 ià( + gnumAùive + == 0) { + +194 +d–‘e + +this +; + +195 +Ãw + + gCG_nuÎ +; + +196 } ià( + gnumAùive + == 1 && 0) { + +199 +CG_»suÉ + * +cg + = +g’_»cursive +( +Ëv– +, +isAùive +); + +200 + gcg + = +cg +-> +»compu‹ +( +k +, +r +); + +201 +d–‘e + + gthis +; + +202 + gcg +; + +205 +R–©iÚ + + gÃw_»¡riùiÚs + = +IÁ”£ùiÚ +( +cÝy +( +»¡riùiÚs +), + +206 +cÝy +( +cÚd™iÚ +)); + +207 + gÃw_»¡riùiÚs +. +sim¶ify +(); + +208 + gŒueCÏu£ + = +ŒueCÏu£ +-> +»compu‹ +( +known +, +Ãw_»¡riùiÚs +); + +209 + gÃw_»¡riùiÚs + = +Difã»nû +( +cÝy +( +»¡riùiÚs +), cÝy( +cÚd™iÚ +)); + +210 + gÃw_»¡riùiÚs +. +sim¶ify +(); + +211 + gçl£CÏu£ + = +çl£CÏu£ +-> +»compu‹ +( +known +, +Ãw_»¡riùiÚs +); + +213 ià( + gŒueCÏu£ +-> +isNuÎ +()) { + +214 +CG_»suÉ + * + gcg + = +çl£CÏu£ +; + +215 + gçl£CÏu£ + = +NULL +; + +216 +d–‘e + + gthis +; + +217 + gcg +; + +219 ià( + gçl£CÏu£ +-> +isNuÎ +()) { + +220 +CG_»suÉ + * + gcg + = +ŒueCÏu£ +; + +221 + gŒueCÏu£ + = +NULL +; + +222 +d–‘e + + gthis +; + +223 + gcg +; + +225 + gthis +; + +228 +R–©iÚ + + gCG_¥l™ +:: +hoi¡Gu¬d +() { + +229 +R–©iÚ + +gu¬d1 + = +ŒueCÏu£ +-> +hoi¡Gu¬d +(); + +230 +R–©iÚ + + ggu¬d2 + = +çl£CÏu£ +-> +hoi¡Gu¬d +(); + +231 ià( + ggu¬d +. +is_nuÎ +()) + +232 + ggu¬d + = +R–©iÚ +:: +True +( +cÚd™iÚ +. +n_£t +()); + +234 ià(! + ggu¬d1 +. +is_obvious_utÞogy +(è&& ! + ggu¬d2 +.is_obvious_tautology() + +235 && +Mu¡_Be_Sub£t +( +cÝy +( +gu¬d1 +), cÝy( +gu¬d2 +)) + +236 && +Mu¡_Be_Sub£t +( +cÝy +( +gu¬d2 +), cÝy( +gu¬d1 +))) { + +237 + gŒueCÏu£ +-> +»moveGu¬d +(); + +238 + gçl£CÏu£ +-> +»moveGu¬d +(); + +239 + ggu¬d + = +IÁ”£ùiÚ +( +gu¬d +, +gu¬d1 +); + +242 + ggu¬d +; + +249 +R–©iÚ + + gCG_Ëaf +:: +fšdOv”h—d +( +liáTo +) { + +250 +s + = 1; + gs + <ð +isAùive +. +size +(); s++) + +251 ià( + gisAùive +[ +s +]) { + +252 + gbb + = ! +gu¬d +[ +s +]. +is_obvious_utÞogy +(); + +253 ià( + gbb +) { + +254 ià( + gcode_g’_debug +) + +255 +årštf +( +DebugFže +, + +257 +s +, +gu¬d +[s]. +´št_fÜmuÏ_to_¡ršg +(). +c_¡r +()); + +258 +R–©iÚ + + gr + = +pickOv”h—d +( +gu¬d +[ +s +], +liáTo +); + +259 ià(! + gr +. +is_obvious_utÞogy +()) + +260 + gr +; + +263 + gR–©iÚ +:: +True +( +known +. +n_£t +()); + +266 + g¡d +:: +¡ršg + +CG_Ëaf +:: +´štSŒuùu» +() { + +267 +¡d +:: +¡ršg + +»suÉ +; + +268 + gs + = 1; s <ð +isAùive +. +size +(); s++) + +269 ià( + gisAùive +[ +s +]) { + +270 + g»suÉ + +ð +¡d +:: +¡ršg +("s"è+ +to_¡ršg +( +s +); + +272 + g»suÉ + + "\n"; + +275 +CG_ouutR•r +* + gCG_Ëaf +:: +´štR•r +( +CG_ouutBužd” +* +ocg +, +šd’t +, + +276 cÚ¡ +¡d +:: +veùÜ +< +CG_ouutR•r + *> & +assigÃd_Ú_the_æy +) { + +278 ià(! +Mu¡_Be_Sub£t +( +cÝy +( +»¡riùiÚs +), cÝy( +known +))) + +279 +´štf +("------------wrong------------------\n"); + +281 + g¡d +:: +¡ršg + +»suÉ +; + +282 +CG_ouutR•r +* + g¡mtLi¡ + = +NULL +; + +283 +CG_ouutR•r +* + g¡mtNode + = +NULL +; + +285 + gTu¶e +<> + gwÜkšg +; + +287 ià( + gcode_g’_debug + > 1) { + +288 + g»suÉ + = "known: " + +known +. +´št_fÜmuÏ_to_¡ršg +(); + +289 + g¡mtLi¡ + = +ocg +-> +StmtLi¡Aµ’d +( +¡mtLi¡ +, + +290 +ocg +-> +C»©eComm’t +( +šd’t +, +»suÉ +)); + +293 + gs + = 1; s <ð +isAùive +. +size +(); s++) + +294 ià( + gisAùive +[ +s +]) { + +295 ià( + ggu¬d +[ +s +]. +is_obvious_utÞogy +()) { + +296 + g¡mtNode + = +ouutS‹m’t +( +ocg +, +¡©em’tInfo +[ +s +]-> +þÚe +(), + +297 +šd’t +, +ŒªsfÜm©iÚs +[ +s +], +known +, +assigÃd_Ú_the_æy +); + +298 + g¡mtLi¡ + = +ocg +-> +StmtLi¡Aµ’d +( +¡mtLi¡ +, +¡mtNode +); + +300 ià( + gcode_g’_debug + > 1) { + +301 + g»suÉ + = "restrictions: " + +302 + +»¡riùiÚs +. +´št_fÜmuÏ_to_¡ršg +(); + +303 + g¡mtLi¡ + = +ocg +-> +StmtLi¡Aµ’d +( +¡mtLi¡ +, + +304 +ocg +-> +C»©eComm’t +( +šd’t +, +»suÉ +)); + +306 + gwÜkšg +. +³nd +( +s +); + +311 + gi + = 1; i <ð +wÜkšg +. +size +(); i++) + +312 ià( + gwÜkšg +[ +i +] != 0) { + +313 +R–©iÚ + +g + = +IÁ”£ùiÚ +( +cÝy +( +gu¬d +[ +wÜkšg +[ +i +]]), cÝy( +known +)); + +314 + g¡mtNode + = +ouutS‹m’t +( +ocg +, +¡©em’tInfo +[ +wÜkšg +[ +i +]]-> +þÚe +(), + +315 +šd’t + + 1, +ŒªsfÜm©iÚs +[ +wÜkšg +[ +i +]], +g +, + +316 +assigÃd_Ú_the_æy +); + +318 + gj + = +i + + 1; j <ð +wÜkšg +. +size +(); j++) + +319 ià( + gwÜkšg +[ +j +] != 0) { + +320 ià( +Mu¡_Be_Sub£t +( +cÝy +( +gu¬d +[ +wÜkšg +[ +i +]]), + +321 +cÝy +( +gu¬d +[ +wÜkšg +[ +j +]])) + +322 && +Mu¡_Be_Sub£t +( +cÝy +( +gu¬d +[ +wÜkšg +[ +j +]]), + +323 +cÝy +( +gu¬d +[ +wÜkšg +[ +i +]]))) { + +324 +¡mtNode + = +ocg +-> +StmtLi¡Aµ’d +(stmtNode, + +325 +ouutS‹m’t +( +ocg +, + +326 +¡©em’tInfo +[ +wÜkšg +[ +j +]]-> +þÚe +(), + +327 +šd’t + + 1, +ŒªsfÜm©iÚs +[ +wÜkšg +[ +j +]], + +328 +g +, +assigÃd_Ú_the_æy +)); + +329 + gwÜkšg +[ +j +] = 0; + +333 +CG_ouutR•r + * + gifGu¬d + = +ouutGu¬d +( +ocg +, +gu¬d +[ +wÜkšg +[ +i +]], + +334 +assigÃd_Ú_the_æy +); + +335 + g¡mtNode + = +ocg +-> +C»©eIf +( +šd’t +, +ifGu¬d +, +¡mtNode +, +NULL +); + +336 + g¡mtLi¡ + = +ocg +-> +StmtLi¡Aµ’d +( +¡mtLi¡ +, +¡mtNode +); + +339 + g¡mtLi¡ +; + +342 +CG_»suÉ +* + gCG_Ëaf +:: +»compu‹ +(cÚ¡ +R–©iÚ + & +k +, cÚ¡ R–©iÚ & +r +) { + +343 + gknown + = +cÝy +( +k +); + +344 + g»¡riùiÚs + = +cÝy +( +r +); + +346 + ggu¬d +. +»®loÿ‹ +( +isAùive +. +size +()); + +348 +boÞ + + gªyAùive + = +çl£ +; + +349 + gs + = 1; s <ð +isAùive +. +size +(); s++) + +350 ià( + gisAùive +[ +s +]) { + +351 +R–©iÚ + + gI + = +IÁ”£ùiÚ +( +cÝy +( +»¡riùiÚs +), cÝy( +Ãw_IS +[ +s +])); + +352 ià(! + gI +. +is_uµ”_bound_§tisfŸbË +()) + +353 + gisAùive +[ +s +] = 0; + +355 + gªyAùive + = +Œue +; + +356 +as£¹ +(! +I +. +is_nuÎ +()); + +357 + ggu¬d +[ +s +] = +Gi¡ +( +cÝy +( +I +), cÝy( +known +), 1); + +363 ià(! + gªyAùive +) { + +364 +d–‘e + + gthis +; + +365 +Ãw + +CG_nuÎ +(); + +367 + gthis +; + +370 +R–©iÚ + + gCG_Ëaf +:: +hoi¡Gu¬d +() { + +371 +s +; + +372 + gs + = 1; s <ð +isAùive +. +size +(è&& !isAùive[ +s +]; s++) + +375 ià( + gs + > + gisAùive +. +size +()) + +376 + gR–©iÚ +:: +True +(1); + +378 +R–©iÚ + + ggu¬d1 + = +gu¬d +[ +s +]; + +380 + gi + = +s + + 1; i <ð +isAùive +. +size +(); i++) + +381 ià( + gisAùive +[ +i +] + +382 && !( +Mu¡_Be_Sub£t +( +cÝy +( +gu¬d1 +), cÝy( +gu¬d +[ +i +])) + +383 && +Mu¡_Be_Sub£t +( +cÝy +( +gu¬d +[ +i +]), cÝy( +gu¬d1 +)))) + +384 + gR–©iÚ +:: +True +( +gu¬d1 +. +n_£t +()); + +386 + ggu¬d1 +; + +389 + gCG_Ëaf +:: +»moveGu¬d +() { + +390 +i + = 1; + gi + <ð +isAùive +. +size +(); i++) + +391 ià( + gisAùive +[ +i +]) + +392 + ggu¬d +[ +i +] = +R–©iÚ +:: +True +( +gu¬d +[i]. +n_£t +()); + +399 +CG_»suÉ + * + gCG_loÝ +:: +fÜû_fš™e_bounds +() { + +400 ià(! +ÃedLoÝ + + +401 || ( +hasBound +( +bounds +, +Ëv– +, 0) && hasBound(bounds,†evel, 1))) { + +402 + gbody + = +body +-> +fÜû_fš™e_bounds +(); + +403 + gthis +; + +406 ià( + gcode_g’_debug +) + +407 +årštf +( +DebugFže +, "Don't have finite bounds in:\n%s\n\n", + +408 +this +-> +´št +(2). +c_¡r +()); + +409 +boÞ + + gbb + = ! +hasBound +( +bounds +, +Ëv– +, 0); + +410 + gdœeùiÚ + = +bb + ? 0 : 1; + +411 + gs +; + +412 +R–©iÚ + + gS +; + +413 + gs + = 1; s <ð +isAùive +. +size +(); s++) + +414 ià( + gisAùive +[ +s +]) + +415 ià( +fšd_ªy_cÚ¡¿št +( +s +, +Ëv– +, +»¡riùiÚs +, +dœeùiÚ +, +S +, + +416 +çl£ +)) + +420 ià( + gS +. +is_nuÎ +()) + +421 + gs + = 1; s <ð +isAùive +. +size +(); s++) + +422 ià( + gisAùive +[ +s +]) + +423 ià( +fšd_ªy_cÚ¡¿št +( +s +, +Ëv– +, +»¡riùiÚs +, +dœeùiÚ +, +S +, + +424 +Œue +)) + +427 ià( + gS +. +is_nuÎ +()) { + +429 +årštf +( +DebugFže +,"hasBound(%s,%d,%sè§id f®£, buˆov”h—d wa utÞogy\n", +I +. +´št_fÜmuÏ_to_¡ršg +(). +c_¡r +(), +Ëv– +, +dœeùiÚ +?"upper bound":"lower bound"); + +431 +throw + +codeg’_”rÜ +("unableo force finite bounds"); + +436 +´štf +("S¶™šg oÀ%s\n", +S +. +´št_fÜmuÏ_to_¡ršg +(). +c_¡r +()); + +438 +CG_»suÉ + * + g¥l + = +Ãw + +CG_¥l™ +( +isAùive +, +Ëv– +, +S +, +this +,his-> +þÚe +()); + +439 + g¥l + = +¥l +-> +»compu‹ +( +cÝy +( +known +), cÝy( +»¡riùiÚs +)); + +441 ià( + gcode_g’_debug +) + +442 +årštf +( +DebugFže +,"S¶™ oÀtØü—‹ fš™bounds:\n%s\n\n", +¥l +-> +´št +(2). +c_¡r +()); + +444 + g¥l +-> +fÜû_fš™e_bounds +(); + +447 +CG_»suÉ + * + gCG_loÝ +:: +liáOv”h—d +( +d•th +) { + +448 +as£¹ +( +d•th + >= 1); + +449 ià( + gthis +-> +d•th +(è< + gd•th +) + +450 + gthis +; + +451 ià(!( + gÃedLoÝ + && + gthis +-> +d•th +() == depth)) { + +452 +body + = body-> +liáOv”h—d +( +d•th +); + +453 + gthis +; + +456 +R–©iÚ + + gc + = +body +-> +fšdOv”h—d +( +Ëv– +); + +457 ià( + gc +. +is_obvious_utÞogy +()) + +458 + gthis +; + +459 +as£¹ +( +c +. +is_uµ”_bound_§tisfŸbË +()); + +460 + g¡d +:: +¡ršg + +befÜe +; + +461 ià( + gcode_g’_debug +) { + +462 + gbefÜe + = +´št +(1); + +464 +CG_»suÉ + * + gs + = +Ãw + +CG_¥l™ +( +isAùive +, +Ëv– +, +c +, +this +,his-> +þÚe +()); + +466 + gs + = +s +-> +»compu‹ +( +cÝy +( +known +), cÝy( +»¡riùiÚs +)); + +467 ià( + gcode_g’_debug +) { + +468 + g¡d +:: +¡ršg + +aá” + = +s +-> +´št +(1); + +469 +årštf +( +DebugFže +, "Lifted out overhead of %s\n", + +470 +c +. +´št_fÜmuÏ_to_¡ršg +(). +c_¡r +()); + +471 +årštf +( +DebugFže +, "äom:\n%s\n", +befÜe +. +c_¡r +()); + +472 +årštf +( +DebugFže +, "tØg‘:\n%s--\n", +aá” +. +c_¡r +()); + +474 + gs + = +s +-> +liáOv”h—d +( +d•th +); + +475 + gs +; + +478 + g¡d +:: +¡ršg + +CG_loÝ +:: +´štSŒuùu» +( +šd’t +) { + +479 +¡d +:: +¡ršg + +s + = ""; + +480 + gšdÁ + = +šd’t +; + +481 + gs + +ð +G‘Ind’tS·ûs +( +šd’t +è+ "//†oÝ" + ( +ÃedLoÝ + ? "" : "(single)") + +482 + " fÜ" + +to_¡ršg +( +Ëv– +è+ "‡ˆ" +o_¡ršg(( *è +this +) + +484 + gs + +ð +G‘Ind’tS·ûs +( +šd’t +) + "// known: " + +485 + +known +. +´št_fÜmuÏ_to_¡ršg +() + "\n"; + +486 + gs + +ð +G‘Ind’tS·ûs +( +šd’t +) + "// guard: " + +487 + +gu¬d +. +´št_fÜmuÏ_to_¡ršg +() + "\n"; + +488 + gs + +ð +G‘Ind’tS·ûs +( +šd’t +) + "// bounds: " + +489 + +bounds +. +´št_fÜmuÏ_to_¡ršg +() + "\n"; + +492 + gi + = 1; i <ð +isAùive +. +size +(); i++) + +493 ià( + gisAùive +[ +i +]) { + +494 + gs + +ð +G‘Ind’tS·ûs +( +šd’t +è+ "// " + "s" + +to_¡ršg +( +i +) + ":" + +495 + +´ojeùed_nIS +[ +Ëv– +][ +i +]. +´št_fÜmuÏ_to_¡ršg +() + "\n"; + +498 + gs + + + gbody +-> +´štSŒuùu» +( +šdÁ + + 1è+ +G‘Ind’tS·ûs +(indnt + 1) + +502 +CG_ouutR•r +* + gCG_loÝ +:: +´štR•r +( +CG_ouutBužd” +* +ocg +, +šd’t +, + +503 cÚ¡ +¡d +:: +veùÜ +< +CG_ouutR•r + *> & +assigÃd_Ú_the_æy +) { + +505 ià(! +Mu¡_Be_Sub£t +( +cÝy +( +»¡riùiÚs +), cÝy( +known +))) + +506 +´štf +("------------wrong------------------\n"); + +529 +CG_ouutR•r +* + ggu¬dR•r + = +ouutGu¬d +( +ocg +, +gu¬d +, +assigÃd_Ú_the_æy +); + +530 +R–©iÚ + + g’fÜûd + = +IÁ”£ùiÚ +( +cÝy +( +known +), cÝy( +gu¬d +)); + +531 + g’fÜûd +. +sim¶ify +(); + +536 + g¡d +:: +veùÜ +< +CG_ouutR•r + *> +aÙf + = +assigÃd_Ú_the_æy +; + +538 + g¡d +:: +·œ +< +CG_ouutR•r + *, + gboÞ +> + geqR•r + = +ouutAssignm’t +( +ocg +, +bounds +, + +539 +bounds +. +£t_v¬ +( +Ëv– +), +’fÜûd +, +gu¬dR•r +, +aÙf +); + +540 ià(! + geqR•r +. + g£cÚd +) + +541 + gaÙf +[ +Ëv– + - 1] = +eqR•r +. +fœ¡ +; + +543 + gšdÁ + = +šd’t +; + +544 ià( + ggu¬dR•r + !ð +NULL +) + +545 +šdÁ +++; + +548 ià( + gcheckLoÝLev– +) { + +549 ià( + gËv– + =ð +checkLoÝLev– +) { + +550 +boÞ + +¡mtP»£Á + = +çl£ +; + +551 + gs + = 1; s <ð +isAùive +. +size +(); s++) { + +552 ià( + gisAùive +[ +s +] && + gs + - 1 =ð +¡mtFÜLoÝCheck +) + +553 +¡mtP»£Á + = +Œue +; + +555 ià( + g¡mtP»£Á +) { + +556 + gfžlInBounds + = +Œue +; + +563 + g¡d +:: +·œ +< +CG_ouutR•r + *, + gboÞ +> + gù¾R•r + = +ouutBounds +( +ocg +, +bounds +, + +564 +bounds +. +£t_v¬ +( +Ëv– +), +šdÁ +, +’fÜûd +, +aÙf +); + +567 + gfžlInBounds + = +çl£ +; + +570 +R–©iÚ + + gËá_ov” + = +Gi¡ +( +cÝy +( +bounds +), cÝy( +’fÜûd +), 1); + +572 ià(! + gËá_ov” +. +is_obvious_utÞogy +()) + +573 +´štf +("=============something wrong===============\n"); + +575 +CG_ouutR•r + * + gloÝR•r + = +NULL +; + +576 ià( + geqR•r +. + g£cÚd +) { + +577 +CG_ouutR•r + * + gbodyR•r + = +body +-> +´štR•r +( +ocg +, +šdÁ +, +aÙf +); + +578 +CG_ouutR•r + * + gassignR•r + = +ocg +-> +C»©eAssignm’t +( +šdÁ +, + +579 +ocg +-> +C»©eId’t +( +bounds +. +£t_v¬ +( +Ëv– +)-> +Çme +()), +eqR•r +. +fœ¡ +); + +580 + gloÝR•r + = +ocg +-> +StmtLi¡Aµ’d +( +assignR•r +, +bodyR•r +); + +581 } ià( + gù¾R•r +. + g£cÚd +) { + +582 +CG_ouutR•r + * + gbodyR•r + = +body +-> +´štR•r +( +ocg +, +šdÁ + + 1, +aÙf +); + +583 + gloÝR•r + = +ocg +-> +C»©eLoÝ +( +šdÁ +, +ù¾R•r +. +fœ¡ +, +bodyR•r +); + +585 #ifdeà +BUILDCUDA + + +591 +boÞ + + gblockLoÝ + = +çl£ +; + +592 +boÞ + + gth»adLoÝ + = +çl£ +; + +593 +boÞ + + gsync + = +çl£ +; + +594 + gfœ¡AùiveStmt + = -1; + +595 + gs + = 1; s <ð +isAùive +. +size +(); s++) { + +596 ià( + gisAùive +[ +s +]) { + +597 ià( + gfœ¡AùiveStmt + < 0) + +598 + gfœ¡AùiveStmt + = +s +; + +602 + gidx + = +smtNÚS¶™Lev–s +[ +s +]. +šdex +( +Ëv– +); + +603 ià( + gidx + == 1) { + +604 +blockLoÝ + = +Œue +; + +607 ià( + gidx + == 2) { + +608 +th»adLoÝ + = +Œue +; + +612 ià( + gblockLoÝ + && + gth»adLoÝ +) { + +613 +årštf +( +¡d”r +, + +615 +Ëv– +); + +616 + gth»adLoÝ + = +çl£ +; + +618 + g¡d +:: +¡ršg + +´eã¼edIdx +; + +619 ià( + gloÝIdxNames +. +size +() + +620 && ( + gËv– + / 2è- 1 < + gloÝIdxNames +[ +fœ¡AùiveStmt +]. +size +()) + +621 + g´eã¼edIdx + = +loÝIdxNames +[ +fœ¡AùiveStmt +][( +Ëv– + / 2)]; + +622 + gs + = 1; s <ð +isAùive +. +size +(); s++) { + +623 ià( + gisAùive +[ +s +]) { + +624 + gi + = 0; i < + gsyncs +. +size +(); i++) { + +625 ià( + gsyncs +[ +i +]. + gfœ¡ + =ð +s + - 1 + +626 && +¡rcmp +( +syncs +[ +i +]. +£cÚd +. +c_¡r +(), + +627 +´eã¼edIdx +. +c_¡r +()) == 0) { + +628 +sync + = +Œue +; + +634 ià( + gth»adLoÝ + || + gblockLoÝ + || + g´eã¼edIdx +. +Ëngth +() != 0) { + +635 +buf +[1024]; + +636 + g¡d +:: +¡ršg + +loÝ +; + +637 ià( + gblockLoÝ +) + +638 + gloÝ + = "blockLoop "; + +639 ià( + gth»adLoÝ +) + +640 + gloÝ + = "threadLoop "; + +641 ià( + g´eã¼edIdx +. +Ëngth +(è!ð0 && +sync +) { + +642 +¥rštf +( +buf +, "~cuda~ %¥»ã¼edIdx: % sync", +loÝ +. +c_¡r +(), + +643 +´eã¼edIdx +. +c_¡r +()); + +644 } ià( + g´eã¼edIdx +. +Ëngth +() != 0) { + +645 +¥rštf +( +buf +, "~cuda~ %¥»ã¼edIdx: %s", +loÝ +. +c_¡r +(), + +646 +´eã¼edIdx +. +c_¡r +()); + +648 +¥rštf +( +buf +, "~cuda~ %s", +loÝ +. +c_¡r +()); + +651 #ifdeà +BUILD_ROSE + + +652 + gloÝR•r + = +ocg +-> +C»©eA‰ribu‹ +( +loÝR•r +, +buf +); + +658 + gloÝR•r + = +ocg +-> +StmtLi¡Aµ’d +(ocg-> +C»©eComm’t +( +šdÁ +, +buf +), + +659 +loÝR•r +); + +668 } ià( + gù¾R•r +. + gfœ¡ + !ð +NULL +) { + +669 +CG_ouutR•r + * +bodyR•r + = +body +-> +´štR•r +( +ocg +, +šdÁ +, +aÙf +); + +670 + gloÝR•r + = +ocg +-> +StmtLi¡Aµ’d +( +ù¾R•r +. +fœ¡ +, +bodyR•r +); + +672 + gloÝR•r + = +body +-> +´štR•r +( +ocg +, +šdÁ +, +aÙf +); + +674 ià( + ggu¬dR•r + !ð +NULL +) + +675 +loÝR•r + = +ocg +-> +C»©eIf +( +šd’t +, +gu¬dR•r +,†oÝR•r, +NULL +); + +677 +d–‘e + + gaÙf +[ +Ëv– + - 1]; + +678 + gloÝR•r +; + +757 +R–©iÚ + + gCG_loÝ +:: +fšdOv”h—d +( +liáTo +) { + +760 ià( +ÃedLoÝ +) { + +761 +bb + = ! +gu¬d +. +is_obvious_utÞogy +(); + +762 ià( + gbb +) { + +764 +årštf +( +DebugFže +,"Tryingo„emove overhead on guard of†oop %x‡t†evel %d: %s\n", + +765 ( *è +this +, +Ëv– +, +gu¬d +. +´št_fÜmuÏ_to_¡ršg +(). +c_¡r +()); + +767 +R–©iÚ + + gr + = +pickOv”h—d +( +gu¬d +, +liáTo +); + +768 ià(! + gr +. +is_obvious_utÞogy +()) + +769 + gr +; + +771 +R–©iÚ + + gb + = +bounds +; + +772 +R–©iÚ + + gr + = +mšMaxOv”h—d +( +b +, +Ëv– +); + +773 ià(! + gr +. +is_obvious_utÞogy +()) { + +775 +årštf +( +DebugFže +,"Tryingo„emove minMax overhead on guard of†oop %x‡t†evel %d: %s\n", + +776 ( *è +this +, +Ëv– +, +gu¬d +. +´št_fÜmuÏ_to_¡ršg +(). +c_¡r +()); + +778 + gr +; + +781 +R–©iÚ + + gr + = +body +-> +fšdOv”h—d +( +liáTo +); + +782 ià( + gr +. +is_obvious_utÞogy +()) + +783 + gr +; + +797 + gr + = +IÁ”£ùiÚ +( +r +, +cÝy +( +bounds +)); + +799 + gr + = +´ojeù_Úto_Ëv–s +( +r +, +Ëv– +, 0); + +801 + gr + = +Gi¡ +( +r +, +cÝy +( +bounds +), 1); + +804 + gr +; + +807 +CG_»suÉ + * + gCG_loÝ +:: +»compu‹ +(cÚ¡ +R–©iÚ + & +k +, cÚ¡ R–©iÚ & +r +) { + +808 + gknown + = +cÝy +( +k +); + +809 + g»¡riùiÚs + = +cÝy +( +r +); + +813 +boÞ + + gªyAùive + = +çl£ +; + +814 + gs + = 1; s <ð +isAùive +. +size +(); s++) + +815 ià( + gisAùive +[ +s +]) { + +816 ià(! +IÁ”£ùiÚ +( +cÝy +( +»¡riùiÚs +), + +817 +cÝy +( +´ojeùed_nIS +[ +Ëv– +][ +s +])). +is_uµ”_bound_§tisfŸbË +()) { + +818 + gisAùive +[ +s +] = 0; + +820 + gªyAùive + = +Œue +; + +823 ià(! + gªyAùive +) { + +824 +d–‘e + + gthis +; + +825 +Ãw + +CG_nuÎ +(); + +832 +R–©iÚ + + ghuÎ + = +HuÎ +( +´ojeùed_nIS +[ +Ëv– +], +isAùive +, 1, +Œue +, + +833 +cÝy +( +»¡riùiÚs +)); + +834 + ghuÎ + = +IÁ”£ùiÚ +( +huÎ +, +cÝy +( +»¡riùiÚs +)); + +835 + ghuÎ +. +sim¶ify +(2, 4); + +838 + gÃedLoÝ + = +Œue +; + +839 +EQ_I‹¿tÜ + + ge + = +huÎ +. +sšgË_cÚjunù +()-> +EQs +();ƒ;ƒ++) { + +840 ià(!(* + ge +). +has_wždÿrds +(è&& (*e). +g‘_cÛf +( +huÎ +. +£t_v¬ +( +Ëv– +)) != 0) { + +841 +ÃedLoÝ + = +çl£ +; + +842 + gbounds + = +R–©iÚ +:: +True +( +huÎ +. +n_£t +()); + +843 + gbounds +. +ªd_w™h_EQ +(* +e +); + +844 + gbounds +. +sim¶ify +(); + +845 + gbounds +. +cÝy_Çmes +( +huÎ +); + +846 + gbounds +. +£tup_Çmes +(); + +852 ià( + gÃedLoÝ +) { + +853 + ghuÎ + = +Gi¡ +( +huÎ +, +cÝy +( +known +), 1); + +854 +R–©iÚ + + gb + = +huÎ +; + +856 + gbounds + = +R–©iÚ +( +huÎ +. +n_£t +()); + +857 +F_Exi¡s + * + gã + = +bounds +. +add_ªd +()-> +add_exi¡s +(); + +858 +F_And + * + gf_roÙ + = +ã +-> +add_ªd +(); + +861 +boÞ + + ghas_uÄesÞved_bound + = +çl£ +; + +863 +CÚjunù + * + gc + = +b +. +sšgË_cÚjunù +(); + +864 +V¬ŸbË_ID + + gv + = +b +. +£t_v¬ +( +Ëv– +); + +865 + g¡d +:: +m + < +V¬ŸbË_ID +, + gV¬ŸbË_ID + > + gexi¡s_mpšg +; + +866 + g¡d +:: +¡ack + < +¡d +:: +·œ +< +GEQ_HªdË +, + gV¬ŸbË_ID +> > + gæoÜ_geq_¡ack +; + +867 + g¡d +:: +£t + < +V¬ŸbË_ID + > +æoÜ_v¬_£t +; + +870 +GEQ_I‹¿tÜ + +gi +( +c +); + ggi +; gi++) + +871 ià((* + ggi +). +g‘_cÛf +( +v +) != 0) { + +872 +boÞ + +is_·¹_of_bound + = +Œue +; + +873 +GEQ_HªdË + + gh2 +; + +874 +CÚ¡r_V¬s_I‹r + +cvi +(* +gi +, +Œue +); + gcvi +; cvi++) + +875 ià(! +fšdFloÜIÃqu®™y +( +b +, +cvi +. +cu¼_v¬ +(), +h2 +, +v +)) { + +876 + ghas_uÄesÞved_bound + = +Œue +; + +877 + gis_·¹_of_bound + = +çl£ +; + +880 ià(! + gis_·¹_of_bound +) + +883 +GEQ_HªdË + + gh + = +f_roÙ +-> +add_GEQ +(); + +884 +CÚ¡r_V¬s_I‹r + +cvi +(* +gi +); + gcvi +; cvi++) { + +885 +V¬ŸbË_ID + + gv2 + = +cvi +. +cu¼_v¬ +(); + +886 + gv2 +-> +kšd +()) { + +887 + gIÅut_V¬ +: { + +888 +pos + = +v2 +-> +g‘_pos™iÚ +(); + +889 + gh +. +upd©e_cÛf +( +bounds +. +£t_v¬ +( +pos +), +cvi +. +cu¼_cÛf +()); + +892 + gExi¡s_V¬ +: + +893 +Wždÿrd_V¬ +: { + +894 +¡d +:: +m +< +V¬ŸbË_ID +, + gV¬ŸbË_ID +>:: +™”©Ü + +p + = + +895 +exi¡s_mpšg +. +fšd +( +v2 +); + +896 +V¬ŸbË_ID + + ge +; + +897 ià( + gp + =ð +exi¡s_mpšg +. +’d +()) { + +898 +e + = +ã +-> +deþ¬e +(); + +899 + gexi¡s_mpšg +[ +v2 +] = +e +; + +901 + ge + = (* +p +). +£cÚd +; + +902 + gh +. +upd©e_cÛf +( +e +, +cvi +. +cu¼_cÛf +()); + +904 ià( + gæoÜ_v¬_£t +. +fšd +( +v2 +è=ð +æoÜ_v¬_£t +. +’d +()) { + +905 +fšdFloÜIÃqu®™y +( +b +, +v2 +, +h2 +, +v +); + +906 + gæoÜ_geq_¡ack +. +push +( +¡d +:: +make_·œ +( +h2 +, +v2 +)); + +907 + gæoÜ_v¬_£t +. +š£¹ +( +v2 +); + +911 + gGlob®_V¬ +: { + +912 +Glob®_V¬_ID + +g + = +v2 +-> +g‘_glob®_v¬ +(); + +913 +V¬ŸbË_ID + + gv3 +; + +914 ià( + gg +-> +¬™y +() == 0) + +915 +v3 + = +bounds +. +g‘_loÿl +( +g +); + +917 + gv3 + = +bounds +. +g‘_loÿl +( +g +, +v2 +-> +funùiÚ_of +()); + +918 + gh +. +upd©e_cÛf +( +v3 +, +cvi +. +cu¼_cÛf +()); + +922 +as£¹ +(0); + +925 + gh +. +upd©e_cÚ¡ +((* +gi +). +g‘_cÚ¡ +()); + +929 ! + gæoÜ_geq_¡ack +. +em±y +()) { + +930 + g¡d +:: +·œ + < +GEQ_HªdË +, + gV¬ŸbË_ID + > + gp + = +æoÜ_geq_¡ack +. +tÝ +(); + +931 + gæoÜ_geq_¡ack +. +pÝ +(); + +933 +GEQ_HªdË + + gh1 + = +f_roÙ +-> +add_GEQ +(); + +934 +GEQ_HªdË + + gh2 + = +f_roÙ +-> +add_GEQ +(); + +935 +CÚ¡r_V¬s_I‹r + +cvi +( +p +. +fœ¡ +); + gcvi +; cvi++) { + +936 +V¬ŸbË_ID + + gv2 + = (* +cvi +). +v¬ +; + +937 + gv2 +-> +kšd +()) { + +938 + gIÅut_V¬ +: { + +939 +pos + = +v2 +-> +g‘_pos™iÚ +(); + +940 + gh1 +. +upd©e_cÛf +( +bounds +. +šput_v¬ +( +pos +), +cvi +. +cu¼_cÛf +()); + +941 + gh2 +. +upd©e_cÛf +( +bounds +. +šput_v¬ +( +pos +), - +cvi +. +cu¼_cÛf +()); + +944 + gExi¡s_V¬ +: + +945 +Wždÿrd_V¬ +: { + +946 +¡d +:: +m +< +V¬ŸbË_ID +, + gV¬ŸbË_ID +>:: +™”©Ü + +p2 + = + +947 +exi¡s_mpšg +. +fšd +( +v2 +); + +948 +V¬ŸbË_ID + + ge +; + +949 ià( + gp2 + =ð +exi¡s_mpšg +. +’d +()) { + +950 +e + = +ã +-> +deþ¬e +(); + +951 + gexi¡s_mpšg +[ +v2 +] = +e +; + +953 + ge + = (* +p2 +). +£cÚd +; + +954 + gh1 +. +upd©e_cÛf +( +e +, +cvi +. +cu¼_cÛf +()); + +955 + gh2 +. +upd©e_cÛf +( +e +, - +cvi +. +cu¼_cÛf +()); + +957 ià( + gæoÜ_v¬_£t +. +fšd +( +v2 +è=ð +æoÜ_v¬_£t +. +’d +()) { + +958 +GEQ_HªdË + +h3 +; + +959 +fšdFloÜIÃqu®™y +( +b +, +v2 +, +h3 +, +v +); + +960 + gæoÜ_geq_¡ack +. +push +( +¡d +:: +make_·œ +( +h3 +, +v2 +)); + +961 + gæoÜ_v¬_£t +. +š£¹ +( +v2 +); + +965 + gGlob®_V¬ +: { + +966 +Glob®_V¬_ID + +g + = +v2 +-> +g‘_glob®_v¬ +(); + +967 +V¬ŸbË_ID + + gv3 +; + +968 ià( + gg +-> +¬™y +() == 0) + +969 +v3 + = +bounds +. +g‘_loÿl +( +g +); + +971 + gv3 + = +bounds +. +g‘_loÿl +( +g +, +v2 +-> +funùiÚ_of +()); + +972 + gh1 +. +upd©e_cÛf +( +v3 +, +cvi +. +cu¼_cÛf +()); + +973 + gh2 +. +upd©e_cÛf +( +v3 +, - +cvi +. +cu¼_cÛf +()); + +977 +as£¹ +(0); + +980 + gh1 +. +upd©e_cÚ¡ +( +p +. +fœ¡ +. +g‘_cÚ¡ +()); + +981 + gh2 +. +upd©e_cÚ¡ +(- +p +. +fœ¡ +. +g‘_cÚ¡ +()); + +982 + gh2 +. +upd©e_cÚ¡ +(- +p +. +fœ¡ +. +g‘_cÛf +Õ. +£cÚd +) - 1); + +985 ià( + ghas_uÄesÞved_bound +) { + +986 + gb + = +Aµroxim©e +( +b +); + +987 + gb +. +sim¶ify +(); + +988 + gc + = +b +. +sšgË_cÚjunù +(); + +990 +GEQ_I‹¿tÜ + +gi +( +c +); + ggi +; gi++) + +991 ià((* + ggi +). +g‘_cÛf +( +v +) != 0) + +992 +f_roÙ +-> +add_GEQ +(* +gi +); + +996 +R–©iÚ + + gthe_gcs + = +g»©e¡_commÚ_¡• +( +´ojeùed_nIS +[ +Ëv– +], +isAùive +, + +997 +Ëv– +, +known +); + +998 + gbounds + = +IÁ”£ùiÚ +( +bounds +, +cÝy +( +the_gcs +)); + +999 + gbounds +. +sim¶ify +(); + +1000 + gbounds +. +cÝy_Çmes +( +huÎ +); + +1001 + gbounds +. +£tup_Çmes +(); + +1005 ià( + gÃedLoÝ +) { + +1006 + ggu¬d + = +Gi¡ +( +cÝy +( +huÎ +), cÝy( +bounds +)); + +1007 + ggu¬d + = +Projeù +( +gu¬d +, gu¬d. +£t_v¬ +( +Ëv– +)); + +1008 + ggu¬d + = +Gi¡ +( +gu¬d +, +cÝy +( +known +)); + +1009 + ggu¬d +. +sim¶ify +(); + +1014 + ggu¬d + = +R–©iÚ +:: +True +( +huÎ +. +n_£t +()); + +1016 + ggu¬d +. +cÝy_Çmes +( +huÎ +); + +1017 + ggu¬d +. +£tup_Çmes +(); + +1020 +R–©iÚ + + g’fÜûd + = +IÁ”£ùiÚ +( +cÝy +( +bounds +), cÝy( +gu¬d +)); + +1021 + g’fÜûd +. +sim¶ify +(); + +1022 +R–©iÚ + + gÃw_known + = +IÁ”£ùiÚ +( +cÝy +( +known +), cÝy( +’fÜûd +)); + +1023 + gÃw_known +. +sim¶ify +(); + +1024 +R–©iÚ + + gÃw_»¡riùiÚs + = +IÁ”£ùiÚ +( +cÝy +( +»¡riùiÚs +), + +1025 +cÝy +( +’fÜûd +)); + +1026 + gÃw_»¡riùiÚs +. +sim¶ify +(); + +1027 + gbody + = +body +-> +»compu‹ +( +Ãw_known +, +Ãw_»¡riùiÚs +); + +1028 + gthis +; + +1031 +R–©iÚ + + gCG_loÝ +:: +hoi¡Gu¬d +() { + +1032 +R–©iÚ + +r + = +body +-> +hoi¡Gu¬d +(); + +1033 ià(! + gr +. +is_obvious_utÞogy +()) { + +1035 +boÞ + + g³¬ + = +çl£ +; + +1036 +DNF_I‹¿tÜ + +di +( +r +. +qu”y_DNF +()); + gdi +; di++) { + +1037 +GEQ_I‹¿tÜ + +gi +((* +di +)-> +GEQs +()); + ggi +; gi++) + +1038 ià((* + ggi +). +g‘_cÛf +( +r +. +£t_v¬ +( +Ëv– +)) != 0) { + +1039 +³¬ + = +Œue +; + +1042 ià( + g³¬ +) + +1045 +EQ_I‹¿tÜ + +ei +((* +di +)-> +EQs +()); + gei +;ƒi++) + +1046 ià((* + gei +). +g‘_cÛf +( +r +. +£t_v¬ +( +Ëv– +)) != 0) { + +1047 +³¬ + = +Œue +; + +1050 ià( + g³¬ +) + +1054 ià(! + g³¬ +) { + +1055 + gbody +-> +»moveGu¬d +(); + +1056 + ggu¬d + = +IÁ”£ùiÚ +( +gu¬d +, +r +); + +1062 ià( + gÃedLoÝ +) + +1063 + gR–©iÚ +:: +True +( +bounds +. +n_£t +()); + +1065 + ggu¬d +; + + @CG_roseBuilder.cc + +15 + ~<¡ack +> + +16 + ~<code_g’/CG_ro£Bužd”.h +> + +17 + ~<¡ršg +> + +19 + gœ_”rÜ +: +public + +¡d +:: +ruÁime_”rÜ + { + +20 +œ_”rÜ +(cÚ¡ +¡d +:: +¡ršg + & +msg +) : + +21 +¡d +:: +ruÁime_”rÜ +( +msg +) { + +25 +usšg + +Çme¥aû + + gSageBužd” +; + +26 +usšg + +Çme¥aû + + gSageIÁ”çû +; + +27 +usšg + +Çme¥aû + + gOmpSuµÜt +; + +29 +Çme¥aû + + gomega + { + +34 * + gk_ocg_comm’t +; + +52 + gCG_ro£Bužd” +:: +CG_ro£Bužd” +( +SgGlob® +* +glob® +, SgGlob®* +fœ¡ScÝe +, + +53 +SgSymbÞTabË +* +symb +, SgSymbÞTabË* +symb2 +, +SgNode +* +roÙ +) : + +54 +glob®_ +( +glob® +), +glob®_scÝe +( +fœ¡ScÝe +), +symb_ +( +symb +), +symb2_ +( + +55 +symb2 +), +roÙ_ +( +roÙ +) { + +58 + gCG_ro£Bužd” +::~ +CG_ro£Bužd” +() { + +64 +CG_ouutR•r +* +CG_ro£Bužd” +:: +C»©ePÏûHÞd” +(, CG_ouutR•¸* +¡mt +, + +65 +Tu¶e +< +CG_ouutR•r +*> & +funcLi¡ +, Tu¶e< +¡d +:: +¡ršg +> & +loÝ_v¬s +) const { + +67 +SgS‹m’tPŒLi¡ +* +li¡ + = +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +¡mt +)-> +li¡_ +; + +68 +SgNode + * + gŠl +; + +69 +SgS‹m’t +* + g¡©em’t +; + +70 ià( + gli¡ + !ð +NULL +) { + +73 +d–‘e + +¡mt +; + +74 + gi + = 1; i <ð +funcLi¡ +. +size +(); i++) { + +76 ià(( + gfuncLi¡ +[ +i +] =ð +NULL +è&& (˜< +funcLi¡ +. +size +())) + +78 ià(( + gfuncLi¡ +[ +i +] =ð +NULL +è&& (˜=ð +funcLi¡ +. +size +())) + +81 +CG_ro£R•r + * + g»´ + = +¡©ic_ÿ¡ +<CG_ro£R•r*>( +funcLi¡ +[ +i +]); + +82 +SgEx´essiÚ +* + gÝ + = +»´ +-> +Ý_ +; + +84 + gSgS‹m’tPŒLi¡ +:: +™”©Ü + +™ + = (* +li¡ +). +begš +(); + +85 + g™ + !ð(* +li¡ +). +’d +(); it++) { + +86 + g¡©em’t + = (* +™ +); + +87 + gŠl + = +isSgNode +( +¡©em’t +); + +91 + gj +; + +92 + gnÙ_š_symb_ +; + +94 + gnÙ_š_symb_ + = 0; + +96 +SgV¬ŸbËSymbÞ + * + gvs + = +symb_ +-> +fšd_v¬ŸbË +( + +97 +SgName +( +loÝ_v¬s +[ +i +]. +c_¡r +())); + +99 ià( + gvs + =ð +NULL +) { + +101 +nÙ_š_symb_ + = 1; + +103 + gvs + = +symb2_ +-> +fšd_v¬ŸbË +( +SgName +( +loÝ_v¬s +[ +i +]. +c_¡r +())); + +105 ià( + gvs + !ð +NULL +) { + +109 +¡d +:: +veùÜ +< +SgV¬RefExp + *> +¬¿y + = +sub¡™u‹ +( +Šl +, + +110 (cÚ¡ +SgV¬ŸbËSymbÞ +*è +vs +, +Ý +, +roÙ_ +); + +111 + g¡d +:: +veùÜ +< +SgV¬RefExp + *>:: +™”©Ü + +™ + = + +112 +¬¿y +. +begš +(); + g™ + !ð¬¿y. +’d +(); it++) { + +115 ià( +isSgV¬RefExp +( +Ý +)) { + +116 ià( +¡rcmp +( + +117 +isSgV¬RefExp +( +Ý +)-> +g‘_symbÞ +()-> +g‘_Çme +(). +g‘SŒšg +(). +c_¡r +(), + +118 +vs +-> +g‘_Çme +(). +g‘SŒšg +(). +c_¡r +())) { + +120 (* + g™ +)-> +£t_symbÞ +( + +121 +isSgV¬RefExp +( +Ý +)-> +g‘_symbÞ +()); + +127 } ià( +isSgEx´essiÚ +( +Ý +)) { + +129 ià( +isSgBš¬yOp +((* +™ +)-> +g‘_·»Á +())) + +130 +isSgBš¬yOp +((* +™ +)-> +g‘_·»Á +())-> +»¶aû_ex´essiÚ +( + +131 * +™ +, +Ý +); + +143 +d–‘e + + g»´ +; + +144 + gfuncLi¡ +[ +i +] = +NULL +; + +146 ià( + gfuncLi¡ +[ +i +] !ð +NULL +) + +147 +throw + +œ_”rÜ +("not freed…roperly"); + +151 +Ãw + +CG_ro£R•r +( +li¡ +); + +154 + gŠl + = +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +¡mt +)-> +Šl_ +; + +157 ià( + gŠl + =ð +NULL +) + +158 +throw + +œ_”rÜ +("both†ist‡ndnl‡re‚ull!!"); + +160 +d–‘e + + g¡mt +; + +161 + gj +; + +162 + gnÙ_š_symb_ +; + +163 + gi + = 1; i <ð +funcLi¡ +. +size +(); i++) { + +164 + gnÙ_š_symb_ + = 0; + +166 ià(( + gfuncLi¡ +[ +i +] =ð +NULL +è&& (˜< +funcLi¡ +. +size +())) + +168 ià(( + gfuncLi¡ +[ +i +] =ð +NULL +è&& (˜=ð +funcLi¡ +. +size +())) + +171 +CG_ro£R•r + * + g»´ + = +¡©ic_ÿ¡ +<CG_ro£R•r*>( +funcLi¡ +[ +i +]); + +172 +SgEx´essiÚ +* + gÝ + = +»´ +-> +Ý_ +; + +173 +d–‘e + + g»´ +; + +174 + gfuncLi¡ +[ +i +] = +NULL +; + +176 +SgV¬ŸbËSymbÞ + * + gvs + = +symb_ +-> +fšd_v¬ŸbË +( + +177 +SgName +( +loÝ_v¬s +[ +i +]. +c_¡r +())); + +179 ià( + gvs + =ð +NULL +) { + +181 +nÙ_š_symb_ + = 1; + +183 + gvs + = +symb2_ +-> +fšd_v¬ŸbË +( +SgName +( +loÝ_v¬s +[ +i +]. +c_¡r +())); + +185 ià( + gvs + !ð +NULL +) { + +188 +¡d +:: +veùÜ +< +SgV¬RefExp + *> +¬¿y + = +sub¡™u‹ +( +Šl +, +vs +, +Ý +, + +189 +roÙ_ +); + +191 ià( + gnÙ_š_symb_ + && +isSgV¬RefExp +( +Ý +)) { + +192 ià( +¡rcmp +( + +193 +isSgV¬RefExp +( +Ý +)-> +g‘_symbÞ +()-> +g‘_Çme +(). +g‘SŒšg +(). +c_¡r +(), + +194 +vs +-> +g‘_Çme +(). +g‘SŒšg +(). +c_¡r +())) { + +205 + g¡d +:: +veùÜ +< +SgV¬RefExp + *>:: +™”©Ü + +j + = +¬¿y +. +begš +(); + +206 + gj + !ð +¬¿y +. +’d +(); j++) { + +209 ià( +isSgV¬RefExp +( +Ý +)) { + +210 ià( +¡rcmp +( + +211 +isSgV¬RefExp +( +Ý +)-> +g‘_symbÞ +()-> +g‘_Çme +(). +g‘SŒšg +(). +c_¡r +(), + +212 +vs +-> +g‘_Çme +(). +g‘SŒšg +(). +c_¡r +())) { + +213 (* + gj +)-> +£t_symbÞ +( +isSgV¬RefExp +( +Ý +)-> +g‘_symbÞ +()); + +218 } ià( +isSgEx´essiÚ +( +Ý +)) { + +220 ià( +isSgBš¬yOp +((* +j +)-> +g‘_·»Á +())) + +221 +isSgBš¬yOp +((* +j +)-> +g‘_·»Á +())-> +»¶aû_ex´essiÚ +( + +222 * +j +, +Ý +); + +297 +Ãw + +CG_ro£R•r +( +Šl +); + +305 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eAssignm’t +(, CG_ouutR•¸* +lhs +, + +306 +CG_ouutR•r + * +rhs +) const { + +307 ià( + glhs + =ð +NULL + || +rhs + == NULL) { + +308 +årštf +( +¡d”r +, "Code generation: Missing†hs or„hs\n"); + +309 + gNULL +; + +312 +SgEx´essiÚ +* + g¤c + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +rhs +)-> +Ý_ +; + +313 +SgEx´essiÚ +* + gd¡ + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +lhs +)-> +Ý_ +; + +315 +SgEx´S‹m’t +* + gšs + = +buždAssignS‹m’t +( +d¡ +, +¤c +); + +316 + g¤c +-> +£t_·»Á +( +šs +); + +317 + gd¡ +-> +£t_·»Á +( +šs +); + +319 +SgS‹m’tPŒLi¡ +* + gÃw_li¡ + = +Ãw + SgStatementPtrList; + +321 (* + gÃw_li¡ +). +push_back +( +isSgS‹m’t +( +šs +)); + +323 +d–‘e + + glhs +; + +324 +d–‘e + + grhs +; + +326 +Ãw + +CG_ro£R•r +( +Ãw_li¡ +); + +333 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eInvoke +(cÚ¡ +¡d +:: +¡ršg + & +âame +, + +334 +Tu¶e +< +CG_ouutR•r +*> & +li¡ +) const { + +336 ià( + gâame + =ð +¡d +:: +¡ršg +("max"è|| +âame + == std::string("min")) { + +337 ià( +li¡ +. +size +() == 0) { + +338 +NULL +; + +339 } ià( + gli¡ +. +size +() == 1) { + +340 +li¡ +[1]; + +342 + gÏ¡ + = +li¡ +. +size +(); + +343 +SgEx´essiÚ +* + gÝ2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +li¡ +[ +Ï¡ +])-> +Ý_ +; + +344 +d–‘e + + gli¡ +[ +Ï¡ +]; + +345 + gli¡ +. +d–‘e_Ï¡ +(); + +346 +CG_ro£R•r + * + g»´ + = +¡©ic_ÿ¡ +<CG_ro£R•r*>( +C»©eInvoke +( +âame +, + +347 +li¡ +)); + +348 +SgEx´essiÚ +* + gÝ1 + = +»´ +-> +Ý_ +; + +350 +SgEx´essiÚ + * + gšs +; + +351 +SgEx´Li¡Exp +* + g¬g_li¡ + = +buždEx´Li¡Exp +(); + +352 +³ndEx´essiÚ +( +¬g_li¡ +, +Ý1 +); + +353 +³ndEx´essiÚ +( +¬g_li¡ +, +Ý2 +); + +354 +SgV¬RefExp +* + gÝaque_v¬ +; + +356 ià( + gâame + =ð +¡d +:: +¡ršg +("max")) { + +357 +Ýaque_v¬ + = +buždO·queV¬RefExp +("__ro£_gt", +glob®_ +); + +358 + gšs + = +isSgEx´essiÚ +( + +359 +buždFunùiÚC®lExp +( +Ýaque_v¬ +, +¬g_li¡ +)); + +362 + gÝaque_v¬ + = +buždO·queV¬RefExp +("__ro£_É", +glob®_ +); + +363 + gšs + = +isSgEx´essiÚ +( + +364 +buždFunùiÚC®lExp +( +Ýaque_v¬ +, +¬g_li¡ +)); + +366 + g»´ +-> + gÝ_ + = +šs +; + +368 + g»´ +; + +371 +årštf +( +¡d”r +, + +373 + gNULL +; + +381 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eComm’t +(, + +382 cÚ¡ +¡d +:: +¡ršg + & +comm’tText +) const { + +383 ià( +comm’tText + =ð +¡d +:: +¡ršg +("")) { + +384 +NULL +; + +387 +SgLoÿ‹dNode + * + gŠl + = +Ãw + SgLocatedNode(); + +388 +buždComm’t +( +Šl +, "//omega_comm’t: " + +comm’tText +); + +390 +Ãw + +CG_ro£R•r +( +isSgNode +( +Šl +)); + +397 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eIf +(, CG_ouutR•¸* +gu¬dLi¡ +, + +398 +CG_ouutR•r + * +Œue_¡mtLi¡ +, CG_ouutR•¸* +çl£_¡mtLi¡ +) const { + +404 ià( + gŒue_¡mtLi¡ + =ð +NULL + && +çl£_¡mtLi¡ + == NULL) { + +405 +d–‘e + +gu¬dLi¡ +; + +406 + gNULL +; + +407 } ià( + ggu¬dLi¡ + =ð +NULL +) { + +408 +StmtLi¡Aµ’d +( +Œue_¡mtLi¡ +, +çl£_¡mtLi¡ +); + +411 +SgEx´essiÚ +* + gh—d” + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +gu¬dLi¡ +)-> +Ý_ +; + +413 +SgS‹m’tPŒLi¡ + * + gth’_·¹1 +, * + g–£_·¹1 +; + +414 +SgS‹m’t +* + gth’_·¹ +; + +415 +SgS‹m’t +* + g–£_·¹ +; + +416 +SgBasicBlock +* + gth’_·¹2 +; + +417 +SgBasicBlock +* + g–£_·¹2 +; + +418 ià( + gŒue_¡mtLi¡ + !ð +NULL +) { + +419 +th’_·¹1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +Œue_¡mtLi¡ +)-> +li¡_ +; + +420 ià( + gth’_·¹1 + !ð +NULL +) { + +421 +th’_·¹ + = *((* +th’_·¹1 +). +begš +()); + +423 ià((* + gth’_·¹1 +). +size +() > 1) { + +424 + gth’_·¹2 + = +buždBasicBlock +(); + +425 + gSgS‹m’tPŒLi¡ +:: +™”©Ü + +™ + = (* +th’_·¹1 +). +begš +(); + +426 + g™ + !ð(* +th’_·¹1 +). +’d +(); it++) { + +427 + gth’_·¹2 +-> +³nd_¡©em’t +(* +™ +); + +430 + gth’_·¹ + = +isSgS‹m’t +( +th’_·¹2 +); + +434 + gth’_·¹ + = +isSgS‹m’t +( + +435 +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +Œue_¡mtLi¡ +)-> +Šl_ +); + +437 + gth’_·¹ + = +NULL +; + +439 ià( + gçl£_¡mtLi¡ + !ð +NULL +) { + +440 +–£_·¹1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +çl£_¡mtLi¡ +)-> +li¡_ +; + +441 ià( + g–£_·¹1 + !ð +NULL +) { + +442 +–£_·¹ + = *((* +–£_·¹1 +). +begš +()); + +443 ià((* + g–£_·¹1 +). +size +() > 1) { + +444 + g–£_·¹2 + = +buždBasicBlock +(); + +445 + gSgS‹m’tPŒLi¡ +:: +™”©Ü + +™2 + = (* +–£_·¹1 +). +begš +(); + +446 + g™2 + !ð(* +–£_·¹1 +). +’d +(); it2++) { + +447 + g–£_·¹2 +-> +³nd_¡©em’t +(* +™2 +); + +450 + g–£_·¹ + = +isSgS‹m’t +( +–£_·¹2 +); + +454 + g–£_·¹ + = +isSgS‹m’t +( + +455 +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +çl£_¡mtLi¡ +)-> +Šl_ +); + +457 + g–£_·¹ + = +NULL +; + +460 +SgIfStmt +* + gti + = +buždIfStmt +( +h—d” +, +isSgS‹m’t +( +th’_·¹ +), + +461 +isSgS‹m’t +( +–£_·¹ +)); + +468 +d–‘e + + ggu¬dLi¡ +; + +469 +d–‘e + + gŒue_¡mtLi¡ +; + +470 +d–‘e + + gçl£_¡mtLi¡ +; + +472 +Ãw + +CG_ro£R•r +( +isSgNode +( +ti +)); + +479 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eInduùive +(CG_ouutR•¸* +šdex +, + +480 +CG_ouutR•r + * +low” +, CG_ouutR•¸* +uµ” +, CG_ouutR•¸* +¡• +) const { + +482 ià( + gšdex + =ð +NULL + || +low” + =ðNULL || +uµ” + == NULL) { + +483 +årštf +( +¡d”r +, + +485 + gNULL +; + +488 ià( + g¡• + =ð +NULL +) + +489 +¡• + = +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +buždIÁV® +(1))); + +491 +SgV¬RefExp + * + gšdex_sym + = +isSgV¬RefExp +( + +492 +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +šdex +)-> +Ý_ +); + +493 +SgEx´essiÚ +* + glow”_bound + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +low” +)-> +Ý_ +; + +494 +SgEx´essiÚ +* + guµ”_bound + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +uµ” +)-> +Ý_ +; + +495 +SgEx´essiÚ +* + g¡•_size + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +¡• +)-> +Ý_ +; + +501 +SgS‹m’t +* + gfÜ_š™_¡mt + = +buždAssignS‹m’t +( +šdex_sym +, +low”_bound +); + +502 +SgLessOrEqu®Op +* + gcÚd + = +buždLessOrEqu®Op +( +šdex_sym +, +uµ”_bound +); + +503 +SgEx´S‹m’t +* + g‹¡ + = +buždEx´S‹m’t +( +cÚd +); + +504 +SgPlusAssignOp +* + gšüem’t + = +buždPlusAssignOp +( +šdex_sym +, +¡•_size +); + +505 +SgFÜS‹m’t + * + gfÜ_¡mt + = +buždFÜS‹m’t +( +fÜ_š™_¡mt +, + +506 +isSgS‹m’t +( +‹¡ +), +šüem’t +, +NULL +); + +508 +d–‘e + + gšdex +; + +509 +d–‘e + + glow” +; + +510 +d–‘e + + guµ” +; + +511 +d–‘e + + g¡• +; + +513 +Ãw + +CG_ro£R•r +( +isSgNode +( +fÜ_¡mt +)); + +520 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eA‰ribu‹ +(CG_ouutR•¸* +cÚŒÞ +, + +521 cÚ¡ +¡d +:: +¡ršg + & +comm’tText +) const { + +523 +SgNode + * +Šl + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +cÚŒÞ +)-> +Šl_ +; + +525 + gŠl +-> +£tA‰ribu‹ +("omega_comm’t", +Ãw + +A¡TextA‰ribu‹ +( +comm’tText +)); + +527 + g¡©ic_ÿ¡ +< + gCG_ro£R•r +*>( + gcÚŒÞ +); + +534 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eLoÝ +(, CG_ouutR•¸* +cÚŒÞ +, + +535 +CG_ouutR•r + * +¡mtLi¡ +) const { + +536 ià( + g¡mtLi¡ + =ð +NULL +) { + +537 +d–‘e + +cÚŒÞ +; + +538 + gNULL +; + +539 } ià( + gcÚŒÞ + =ð +NULL +) { + +540 +årštf +( +¡d”r +, "Code generation:‚o inductive forhis†oop\n"); + +541 + g¡mtLi¡ +; + +544 +SgNode + * + gŠl + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +cÚŒÞ +)-> +Šl_ +; + +545 +SgFÜS‹m’t + * + gtf + = +isSgFÜS‹m’t +( +Šl +); + +547 +SgS‹m’tPŒLi¡ + * + gbody + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +¡mtLi¡ +)-> +li¡_ +; + +549 ià( + gbody + !ð +NULL +) { + +550 ià(!((* +body +). +em±y +())) { + +551 ià((* +body +). +size +() == 1) { + +553 +tf +-> +£t_loÝ_body +(*((* +body +). +begš +())); + +554 (*((* + gbody +). +begš +()))-> +£t_·»Á +( +tf +); + +564 +SgBasicBlock +* + gbb + = +buždBasicBlock +(); + +565 + gbb +-> +£t_·»Á +( +tf +); + +566 + gSgS‹m’tPŒLi¡ +:: +™”©Ü + +™ + = (* +body +). +begš +(); + +567 + g™ + !ð(* +body +). +’d +(); it++) { + +568 + gbb +-> +³nd_¡©em’t +(* +™ +); + +569 (* + g™ +)-> +£t_·»Á +( +bb +); + +571 + gtf +-> +£t_loÝ_body +( +bb +); + +576 +SgNode +* + gŠl2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +¡mtLi¡ +)-> +Šl_ +; + +578 ià( + gŠl2 + !ð +NULL +) { + +579 +tf +-> +£t_loÝ_body +( +isSgS‹m’t +( +Šl2 +)); + +580 + gŠl2 +-> +£t_·»Á +( +tf +); + +584 +d–‘e + + g¡mtLi¡ +; + +586 + gcÚŒÞ +; + +592 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eIÁ +( +_i +) const { + +593 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +buždIÁV® +( +_i +))); + +596 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eId’t +(cÚ¡ +¡d +:: +¡ršg + & +_s +) const { + +598 +SgV¬ŸbËSymbÞ + * +vs + = +symb_ +-> +fšd_v¬ŸbË +( +SgName +( +_s +. +c_¡r +())); + +599 +SgV¬ŸbËSymbÞ + * + gvs2 + = +symb2_ +-> +fšd_v¬ŸbË +( +SgName +( +_s +. +c_¡r +())); + +601 ià( + gvs + =ð +NULL + && +vs2 + == NULL) { + +603 +SgV¬ŸbËDeþ¬©iÚ +* +deâ + = +buždV¬ŸbËDeþ¬©iÚ +( + +604 +SgName +( +_s +. +c_¡r +()), +buždIÁTy³ +()); + +605 + gSgIn™ŸlizedNamePŒLi¡ +& + gv¬ŸbËs + = +deâ +-> +g‘_v¬ŸbËs +(); + +606 + gSgIn™ŸlizedNamePŒLi¡ +:: +cÚ¡_™”©Ü + +i + = +v¬ŸbËs +. +begš +(); + +607 +SgIn™ŸlizedName +* + gš™ŸlizedName + = * +i +; + +608 + gvs + = +Ãw + +SgV¬ŸbËSymbÞ +( +š™ŸlizedName +); + +609 +´•’dS‹m’t +( +deâ +, +isSgScÝeS‹m’t +( +roÙ_ +)); + +611 + gvs +-> +£t_·»Á +( +symb2_ +); + +612 + gsymb2_ +-> +š£¹ +( +SgName +( +_s +. +c_¡r +()), +vs +); + +613 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +buždV¬RefExp +( +vs +))); + +619 ià(! +isSgEx´essiÚ +( +buždV¬RefExp +( +SgName +( +_s +. +c_¡r +())))) + +620 +throw + +œ_”rÜ +("error in Create ident!!"); + +621 ià( + gvs2 + !ð +NULL +) + +622 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +buždV¬RefExp +( +vs2 +))); + +624 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +buždV¬RefExp +( +vs +))); + +631 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©ePlus +(CG_ouutR•¸* +lÝ +, + +632 +CG_ouutR•r + * +rÝ +) const { + +633 ià( + grÝ + =ð +NULL +) { + +634 +lÝ +; + +635 } ià( + glÝ + =ð +NULL +) { + +636 +rÝ +; + +639 +SgEx´essiÚ +* + gÝ1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +lÝ +)-> +Ý_ +; + +640 +SgEx´essiÚ +* + gÝ2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +rÝ +)-> +Ý_ +; + +642 +SgAddOp + * + gšs + = +buždAddOp +( +Ý1 +, +Ý2 +); + +643 + gÝ1 +-> +£t_·»Á +( +šs +); + +644 + gÝ2 +-> +£t_·»Á +( +šs +); + +645 +d–‘e + + glÝ +; + +646 +d–‘e + + grÝ +; + +648 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +šs +)); + +652 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eMšus +(CG_ouutR•¸* +lÝ +, + +653 +CG_ouutR•r + * +rÝ +) const { + +654 ià( + grÝ + =ð +NULL +) { + +655 +lÝ +; + +656 } ià( + glÝ + =ð +NULL +) { + +657 +SgEx´essiÚ + * +Ý + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +rÝ +)-> +Ý_ +; + +658 +SgMšusOp + * + gšs + = +buždMšusOp +( +Ý +); + +660 +d–‘e + + grÝ +; + +662 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +šs +)); + +664 +SgEx´essiÚ +* + gÝ1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +lÝ +)-> +Ý_ +; + +665 +SgEx´essiÚ +* + gÝ2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +rÝ +)-> +Ý_ +; + +667 +SgSubŒaùOp + * + gšs + = +buždSubŒaùOp +( +Ý1 +, +Ý2 +); + +668 + gÝ1 +-> +£t_·»Á +( +šs +); + +669 + gÝ2 +-> +£t_·»Á +( +šs +); + +670 +d–‘e + + glÝ +; + +671 +d–‘e + + grÝ +; + +672 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +šs +)); + +677 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eTimes +(CG_ouutR•¸* +lÝ +, + +678 +CG_ouutR•r + * +rÝ +) const { + +679 ià( + grÝ + =ð +NULL + || +lÝ + == NULL) { + +680 ià( +rÝ + !ð +NULL +) { + +681 +rÝ +-> +þ—r +(); + +682 +d–‘e + + grÝ +; + +684 ià( + glÝ + !ð +NULL +) { + +685 +lÝ +-> +þ—r +(); + +686 +d–‘e + + glÝ +; + +688 + gNULL +; + +691 +SgEx´essiÚ +* + gÝ1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +lÝ +)-> +Ý_ +; + +692 +SgEx´essiÚ +* + gÝ2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +rÝ +)-> +Ý_ +; + +694 +SgMuÉlyOp + * + gšs + = +buždMuÉlyOp +( +Ý1 +, +Ý2 +); + +695 + gÝ1 +-> +£t_·»Á +( +šs +); + +696 + gÝ2 +-> +£t_·»Á +( +šs +); + +697 +d–‘e + + glÝ +; + +698 +d–‘e + + grÝ +; + +700 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +šs +)); + +704 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eIÁeg”Divide +(CG_ouutR•¸* +lÝ +, + +705 +CG_ouutR•r + * +rÝ +) const { + +706 ià( + grÝ + =ð +NULL +) { + +707 +årštf +( +¡d”r +, "Code generation: divide by NULL\n"); + +708 + gNULL +; + +709 } ià( + glÝ + =ð +NULL +) { + +710 +d–‘e + +rÝ +; + +711 + gNULL +; + +715 +SgEx´essiÚ +* + gÝ1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +lÝ +)-> +Ý_ +; + +716 +SgEx´essiÚ +* + gÝ2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +rÝ +)-> +Ý_ +; + +719 +SgDivideOp + * + gšs + = +buždDivideOp +( +Ý1 +, +Ý2 +); + +721 +d–‘e + + glÝ +; + +722 +d–‘e + + grÝ +; + +724 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +šs +)); + +728 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eIÁeg”Mod +(CG_ouutR•¸* +lÝ +, + +729 +CG_ouutR•r + * +rÝ +) const { + +730 ià( + grÝ + =ð +NULL + || +lÝ + == NULL) { + +731 +NULL +; + +734 +SgEx´essiÚ +* + gÝ1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +lÝ +)-> +Ý_ +; + +735 +SgEx´essiÚ +* + gÝ2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +rÝ +)-> +Ý_ +; + +738 +SgModOp + * + gšs + = +buždModOp +( +Ý1 +, +Ý2 +); + +740 +d–‘e + + glÝ +; + +741 +d–‘e + + grÝ +; + +743 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +šs +)); + +750 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eAnd +(CG_ouutR•¸* +lÝ +, + +751 +CG_ouutR•r + * +rÝ +) const { + +752 ià( + grÝ + =ð +NULL + || +lÝ + == NULL) { + +753 +NULL +; + +756 +SgEx´essiÚ +* + gÝ1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +lÝ +)-> +Ý_ +; + +757 +SgEx´essiÚ +* + gÝ2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +rÝ +)-> +Ý_ +; + +759 +SgAndOp + * + gšs + = +buždAndOp +( +Ý1 +, +Ý2 +); + +761 +d–‘e + + glÝ +; + +762 +d–‘e + + grÝ +; + +764 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +šs +)); + +771 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eGE +(CG_ouutR•¸* +lÝ +, + +772 +CG_ouutR•r + * +rÝ +) const { + +773 +C»©eLE +( +rÝ +, +lÝ +); + +776 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eLE +(CG_ouutR•¸* +lÝ +, + +777 +CG_ouutR•r + * +rÝ +) const { + +778 ià( + grÝ + =ð +NULL + || +lÝ + == NULL) { + +779 +NULL +; + +782 +SgEx´essiÚ +* + gÝ1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +lÝ +)-> +Ý_ +; + +783 +SgEx´essiÚ +* + gÝ2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +rÝ +)-> +Ý_ +; + +785 +SgLessOrEqu®Op + * + gšs + = +buždLessOrEqu®Op +( +Ý1 +, +Ý2 +); + +787 +d–‘e + + glÝ +; + +788 +d–‘e + + grÝ +; + +790 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +šs +)); + +794 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eEQ +(CG_ouutR•¸* +lÝ +, + +795 +CG_ouutR•r + * +rÝ +) const { + +796 ià( + grÝ + =ð +NULL + || +lÝ + == NULL) { + +797 +NULL +; + +800 +SgEx´essiÚ +* + gÝ1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +lÝ +)-> +Ý_ +; + +801 +SgEx´essiÚ +* + gÝ2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r +*>( +rÝ +)-> +Ý_ +; + +803 +SgEqu®™yOp + * + gšs + = +buždEqu®™yOp +( +Ý1 +, +Ý2 +); + +805 +d–‘e + + glÝ +; + +806 +d–‘e + + grÝ +; + +808 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +šs +)); + +815 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eStmtLi¡ +(CG_ouutR•¸* +sšgËtÚ +) const { + +819 ià( +sšgËtÚ + =ð +NULL +) { + +820 +Ãw + +CG_ro£R•r +Òew +SgS‹m’tPŒLi¡ +); + +823 +SgS‹m’tPŒLi¡ + * + gŠl + = +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +sšgËtÚ +)-> +li¡_ +; + +824 +SgNode +* + gsgn + = +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +sšgËtÚ +)-> +Šl_ +; + +826 ià( + gŠl + =ð +NULL +) + +827 +Šl + = +Ãw + +SgS‹m’tPŒLi¡ +; + +829 ià( + gsgn + =ð +NULL +) { + +830 +SgEx´essiÚ +* +Ý + = +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +sšgËtÚ +)-> +Ý_ +; + +832 ià( + gÝ + !ð +NULL +) + +833 (* +Šl +). +push_back +( + +834 +buždEx´S‹m’t +( + +835 +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +sšgËtÚ +)-> +Ý_ +)); + +838 (* + gŠl +). +push_back +( +isSgS‹m’t +( +sgn +)); + +840 +d–‘e + + gsšgËtÚ +; + +841 +Ãw + +CG_ro£R•r +( +Šl +); + +850 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +StmtLi¡In£¹La¡ +(CG_ouutR•¸* +li¡ +, + +851 +CG_ouutR•r + * +node +) const { + +852 +StmtLi¡Aµ’d +( +li¡ +, +node +); + +855 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +StmtLi¡Aµ’d +(CG_ouutR•¸* +li¡1 +, + +856 +CG_ouutR•r + * +li¡2 +) const { + +858 ià( + gli¡2 + =ð +NULL +) { + +859 +li¡1 +; + +860 } ià( + gli¡1 + =ð +NULL +) { + +861 +li¡2 +; + +868 +SgS‹m’tPŒLi¡ +* + gÃw_li¡ +; + +870 +SgS‹m’tPŒLi¡ +* + gŠl1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +li¡1 +)-> +li¡_ +; + +871 +SgS‹m’tPŒLi¡ +* + gŠl2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +li¡2 +)-> +li¡_ +; + +872 +SgNode +* + gÚe + = +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +li¡1 +)-> +Šl_ +; + +873 +SgNode +* + gtwo + = +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +li¡2 +)-> +Šl_ +; + +875 +SgEx´essiÚ +* + gexp1 + = +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +li¡1 +)-> +Ý_ +; + +876 +SgEx´essiÚ +* + gexp2 + = +¡©ic_ÿ¡ +< +CG_ro£R•r + *>( +li¡2 +)-> +Ý_ +; + +878 ià( + gexp1 + || + gexp2 +) + +879 +throw + +œ_”rÜ +("error in stmtlistappend!!"); + +895 ià(( + gŠl1 + =ð +NULL +è&& ( +Šl2 + == NULL)) { + +897 ià(( +Úe + !ð +NULL +è&& ( +two + != NULL)) { + +899 +Ãw_li¡ + = +Ãw + +SgS‹m’tPŒLi¡ +; + +901 (* + gÃw_li¡ +). +push_back +( +isSgS‹m’t +( +Úe +)); + +902 (* + gÃw_li¡ +). +push_back +( +isSgS‹m’t +( +two +)); + +904 +CG_ro£R•r +* + gÃw_»p + = +Ãw + CG_ro£R•r( +Ãw_li¡ +); + +906 + g¡©ic_ÿ¡ +< + gCG_ouutR•r + *>( + gÃw_»p +); + +908 } ià(( + gÚe + !ð +NULL +è&& ( +two + == NULL)) { + +910 +¡©ic_ÿ¡ +< +CG_ouutR•r + *>( +Ãw + +CG_ro£R•r +( +Úe +)); + +912 } ià(( + gtwo + !ð +NULL +è&& ( +Úe + == NULL)) { + +913 +¡©ic_ÿ¡ +< +CG_ouutR•r + *>( +Ãw + +CG_ro£R•r +( +two +)); + +918 ià(( + gŠl2 + !ð +NULL +è&& ( +Šl1 + == NULL)) { + +925 ià( +Úe + =ð +NULL +) + +926 +li¡2 +; + +929 (* + gŠl2 +). +push_back +( +isSgS‹m’t +( +Úe +)); + +931 + g¡©ic_ÿ¡ +< + gCG_ouutR•r + *>( +Ãw + +CG_ro£R•r +( +Šl2 +)); + +933 } ià(( + gŠl1 + !ð +NULL +è&& ( +Šl2 + == NULL)) { + +934 ià( +two + =ð +NULL +) + +935 +li¡1 +; + +938 (* + gŠl1 +). +push_back +( +isSgS‹m’t +( +two +)); + +940 + g¡©ic_ÿ¡ +< + gCG_ouutR•r + *>( +Ãw + +CG_ro£R•r +( +Šl1 +)); + +944 } ià(( + gŠl1 + !ð +NULL +è&& ( +Šl2 + != NULL)) { + +946 +SgS‹m’tPŒLi¡ +:: +™”©Ü + +™ + = (* +Šl2 +). +begš +(); + +947 + g™ + !ð(* +Šl2 +). +’d +(); it++) { + +948 (* + gŠl1 +). +push_back +(* +™ +); + +954 + g¡©ic_ÿ¡ +< + gCG_ouutR•r + *>( +Ãw + +CG_ro£R•r +( +Šl1 +)); + +1002 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eDim3 +(cÚ¡ * +v¬Name +, +¬g1 +, + +1003 +¬g2 +) const { + +1005 +SgName + +ty³_Çme +("dim3"); + +1006 +SgCÏssSymbÞ + * + gty³_symbÞ + = +glob®_scÝe +-> +lookup_þass_symbÞ +( +ty³_Çme +); + +1007 +SgCÏssDeþ¬©iÚ + * + gty³_deþ + = +isSgCÏssDeþ¬©iÚ +( + +1008 +ty³_symbÞ +-> +g‘_deþ¬©iÚ +()); + +1012 +SgFunùiÚSymbÞ + * + gùÜ_symbÞ + = +glob®_scÝe +-> +lookup_funùiÚ_symbÞ +( + +1013 +SgName +("dim3")); + +1015 +SgEx´Li¡Exp + * + gùÜ_¬gs + = +buždEx´Li¡Exp +( +buždIÁV® +( +¬g1 +), + +1016 +buždIÁV® +( +¬g2 +)); + +1018 +SgFunùiÚC®lExp + * + gdim3_func_ÿÎ + = +buždFunùiÚC®lExp +( + +1019 +buždFunùiÚRefExp +( +ùÜ_symbÞ +-> +g‘_deþ¬©iÚ +()), +ùÜ_¬gs +); + +1021 + gjošed_¡r +[20]; + +1023 +¡rýy +( +jošed_¡r +, "dim3 "); + +1024 +¡rÿt +( +jošed_¡r +, +v¬Name +); + +1026 +SgEx´S‹m’t +* + gdeþ + = +buždAssignS‹m’t +( + +1027 +buždO·queV¬RefExp +( +jošed_¡r +, +isSgScÝeS‹m’t +( +roÙ_ +)), + +1028 +dim3_func_ÿÎ +); + +1030 +SgS‹m’tPŒLi¡ + * + gŠl2 + = +Ãw + SgStatementPtrList; + +1033 (* + gŠl2 +). +push_back +( +deþ +); + +1034 +Ãw + +CG_ro£R•r +( +Šl2 +); + +1037 +CG_ouutR•r +* + gCG_ro£Bužd” +:: +C»©eDim3 +(cÚ¡ * +v¬Name +, +¬g1 +, + +1038 +¬g2 +, +¬g3 +) const { + +1040 +SgName + +ty³_Çme +("dim3"); + +1041 +SgCÏssSymbÞ + * + gty³_symbÞ + = +glob®_scÝe +-> +lookup_þass_symbÞ +( +ty³_Çme +); + +1042 +SgCÏssDeþ¬©iÚ + * + gty³_deþ + = +isSgCÏssDeþ¬©iÚ +( + +1043 +ty³_symbÞ +-> +g‘_deþ¬©iÚ +()); + +1047 +SgFunùiÚSymbÞ + * + gùÜ_symbÞ + = +glob®_scÝe +-> +lookup_funùiÚ_symbÞ +( + +1048 +SgName +("dim3")); + +1050 +SgEx´Li¡Exp + * + gùÜ_¬gs + = +buždEx´Li¡Exp +( +buždIÁV® +( +¬g1 +), + +1051 +buždIÁV® +( +¬g2 +), buždIÁV®( +¬g3 +)); + +1053 +SgFunùiÚC®lExp + * + gdim3_func_ÿÎ + = +buždFunùiÚC®lExp +( + +1054 +buždFunùiÚRefExp +( +ùÜ_symbÞ +-> +g‘_deþ¬©iÚ +()), +ùÜ_¬gs +); + +1056 + gjošed_¡r +[20]; + +1058 +¡rýy +( +jošed_¡r +, "dim3 "); + +1059 +¡rÿt +( +jošed_¡r +, +v¬Name +); + +1061 +SgEx´S‹m’t +* + gdeþ + = +buždAssignS‹m’t +( + +1062 +buždO·queV¬RefExp +( +jošed_¡r +, +isSgScÝeS‹m’t +( +roÙ_ +)), + +1063 +dim3_func_ÿÎ +); + +1065 +SgS‹m’tPŒLi¡ + * + gŠl2 + = +Ãw + SgStatementPtrList; + +1068 (* + gŠl2 +). +push_back +( +deþ +); + +1069 +Ãw + +CG_ro£R•r +( +Šl2 +); + +1144 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +sub¡™u‹ +( +SgNode + * +š +, cÚ¡ +SgV¬ŸbËSymbÞ + * +sym +, + +1145 +SgEx´essiÚ +* +ex´ +, +SgNode +* +roÙ +) { + +1147 +SgS‹m’t +* + g¡mt +; + +1148 +SgEx´essiÚ +* + gÝ +; + +1149 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +¬¿ys +; + +1151 ià( + gš + !ð +NULL +) { + +1152 ià( +¡mt + = +isSgS‹m’t +( +š +)) { + +1153 ià( +isSgBasicBlock +( +¡mt +)) { + +1154 +SgS‹m’tPŒLi¡ +& +¡mts + = + +1155 +isSgBasicBlock +( +¡mt +)-> +g‘_¡©em’ts +(); + +1156 + gi + = 0; i < + g¡mts +. +size +(); i++) { + +1157 + g¡mts +[ +i +]-> +£t_·»Á +( +¡mt +); + +1158 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a + = +sub¡™u‹ +( + +1159 +isSgNode +( +¡mts +[ +i +]), +sym +, +ex´ +, +roÙ +); + +1160 + g¡d +:: +cÝy +( +a +. +begš +(),‡. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1162 } ià( +isSgFÜS‹m’t +( +¡mt +)) { + +1163 +SgFÜS‹m’t + * + gŠf + = +isSgFÜS‹m’t +( +¡mt +); + +1164 + gŠf +-> +g‘_fÜ_š™_¡mt +()-> +£t_·»Á +( +Šf +); + +1165 + gŠf +-> +g‘_‹¡ +()-> +£t_·»Á +( +Šf +); + +1166 + gŠf +-> +g‘_šüem’t +()-> +£t_·»Á +( +Šf +); + +1167 + gŠf +-> +g‘_loÝ_body +()-> +£t_·»Á +( +Šf +); + +1168 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a + = +sub¡™u‹ +( + +1169 +isSgNode +( +Šf +-> +g‘_fÜ_š™_¡mt +()), +sym +, +ex´ +, +roÙ +); + +1170 + g¡d +:: +cÝy +( +a +. +begš +(),‡. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1171 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a1 + = +sub¡™u‹ +( + +1172 +isSgNode +( +Šf +-> +g‘_‹¡ +()), +sym +, +ex´ +, +roÙ +); + +1173 + g¡d +:: +cÝy +( +a1 +. +begš +(),‡1. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1174 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a2 + = +sub¡™u‹ +( + +1175 +isSgNode +( +Šf +-> +g‘_šüem’t +()), +sym +, +ex´ +, +roÙ +); + +1176 + g¡d +:: +cÝy +( +a2 +. +begš +(),‡2. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1177 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a3 + = +sub¡™u‹ +( + +1178 +isSgNode +( +Šf +-> +g‘_loÝ_body +()), +sym +, +ex´ +, +roÙ +); + +1179 + g¡d +:: +cÝy +( +a3 +. +begš +(),‡3. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1188 ià( +isSgV¬ŸbËDeþ¬©iÚ +( +¡mt +)) { + +1189 ià( +SgEx´essiÚ + * + gš™ + = + +1190 +isSgV¬ŸbËDeþ¬©iÚ +( +¡mt +)-> +g‘_v¬ŸbËs +(). +äÚt +()-> +g‘_š™Ÿliz” +()) { + +1191 ià( +isSgAssignIn™Ÿliz” +( +š™ +)) { + +1192 +¡d +:: +veùÜ +< +SgV¬RefExp + *> +a + = +sub¡™u‹ +( + +1193 +isSgAssignIn™Ÿliz” +( +š™ +)-> +g‘_Ý”ªd +(), +sym +, + +1194 +ex´ +, +roÙ +); + +1195 + g¡d +:: +cÝy +( +a +. +begš +(),‡. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1198 } ià( +isSgIfStmt +( +¡mt +)) { + +1199 +SgIfStmt +* + gŠi + = +isSgIfStmt +( +¡mt +); + +1200 + gŠi +-> +g‘_cÚd™iÚ® +()-> +£t_·»Á +( +Ši +); + +1201 + gŠi +-> +g‘_Œue_body +()-> +£t_·»Á +( +Ši +); + +1202 + gŠi +-> +g‘_çl£_body +()-> +£t_·»Á +( +Ši +); + +1203 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a + = +sub¡™u‹ +( + +1204 +isSgNode +( +Ši +-> +g‘_cÚd™iÚ® +()), +sym +, +ex´ +, +roÙ +); + +1205 + g¡d +:: +cÝy +( +a +. +begš +(),‡. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1206 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a1 + = +sub¡™u‹ +( + +1207 +isSgNode +( +Ši +-> +g‘_Œue_body +()), +sym +, +ex´ +, +roÙ +); + +1208 + g¡d +:: +cÝy +( +a1 +. +begš +(),‡1. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1209 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a2 + = +sub¡™u‹ +( + +1210 +isSgNode +( +Ši +-> +g‘_çl£_body +()), +sym +, +ex´ +, +roÙ +); + +1211 + g¡d +:: +cÝy +( +a2 +. +begš +(),‡2. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1212 } ià( +isSgEx´S‹m’t +( +¡mt +)) { + +1213 ( +isSgEx´S‹m’t +( +¡mt +)-> +g‘_ex´essiÚ +())-> +£t_·»Á +( + +1214 +isSgEx´S‹m’t +( +¡mt +)); + +1215 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a + = +sub¡™u‹ +( + +1216 +isSgNode +( +isSgEx´S‹m’t +( +¡mt +)-> +g‘_ex´essiÚ +()), + +1217 +sym +, +ex´ +, +roÙ +); + +1218 + g¡d +:: +cÝy +( +a +. +begš +(),‡. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1222 + gÝ + = +isSgEx´essiÚ +( +š +); + +1224 + g¡d +:: +¡ršg + +y + = +sym +-> +g‘_Çme +(). +g‘SŒšg +(); + +1226 ià( +isSgBš¬yOp +( +Ý +)) { + +1228 +isSgBš¬yOp +( +Ý +)-> +g‘_lhs_Ý”ªd +()-> +£t_·»Á +(op); + +1229 +isSgBš¬yOp +( +Ý +)-> +g‘_rhs_Ý”ªd +()-> +£t_·»Á +(op); + +1231 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a + = +sub¡™u‹ +( + +1232 +isSgBš¬yOp +( +Ý +)-> +g‘_lhs_Ý”ªd +(), +sym +, +ex´ +, +roÙ +); + +1233 + g¡d +:: +cÝy +( +a +. +begš +(),‡. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1234 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a1 + = +sub¡™u‹ +( + +1235 +isSgBš¬yOp +( +Ý +)-> +g‘_rhs_Ý”ªd +(), +sym +, +ex´ +, +roÙ +); + +1236 + g¡d +:: +cÝy +( +a1 +. +begš +(),‡1. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1237 } ià( +isSgUÇryOp +( +Ý +)) { + +1238 +isSgUÇryOp +( +Ý +)-> +g‘_Ý”ªd +()-> +£t_·»Á +(op); + +1239 + g¡d +:: +veùÜ +< +SgV¬RefExp + *> +a + = +sub¡™u‹ +( + +1240 +isSgUÇryOp +( +Ý +)-> +g‘_Ý”ªd +(), +sym +, +ex´ +, +roÙ +); + +1241 + g¡d +:: +cÝy +( +a +. +begš +(),‡. +’d +(), +back_š£¹” +( +¬¿ys +)); + +1242 } ià( +isSgV¬RefExp +( +Ý +)) { + +1243 + g¡d +:: +¡ršg + +z + = + +1244 +isSgV¬RefExp +( +Ý +)-> +g‘_symbÞ +()-> +g‘_Çme +(). +g‘SŒšg +(); + +1245 ià(! +¡rcmp +( +z +. +c_¡r +(), +y +.c_str())) { + +1247 + g¬¿ys +. +push_back +( +isSgV¬RefExp +( +Ý +)); + +1273 + g¬¿ys +; + + @CG_roseRepr.cc + +14 + ~<code_g’/CG_ro£R•r.h +> + +15 + ~<¡dio.h +> + +16 + ~<¡ršg.h +> + +17 + ~<c¡ršg +> + +18 +Çme¥aû + + gomega + { + +23 + gCG_ro£R•r +:: +CG_ro£R•r +(): +Šl_ +( +NULL +), +Ý_ +(NULL), +li¡_ +(NULL){ + +27 + gCG_ro£R•r +:: +CG_ro£R•r +( +SgNode + * +Šl +): +Šl_ +ÑÆ), +Ý_ +( +NULL +), +li¡_ +(NULL) { + +30 + gCG_ro£R•r +:: +CG_ro£R•r +( +SgEx´essiÚ +* +Ý +): +Šl_ +( +NULL +), +Ý_ +(Ý), +li¡_ +(NULL){ + +32 + gCG_ro£R•r +:: +CG_ro£R•r +( +SgS‹m’tPŒLi¡ +* +¡mŽi¡ +): +Šl_ +( +NULL +), +Ý_ +(NULL), +li¡_ +(stmtlist){ + +35 + gCG_ro£R•r +::~ +CG_ro£R•r +() { + +40 +CG_ouutR•r +* +CG_ro£R•r +:: +þÚe +() { + +42 ifÐ +Šl_ + !ð +NULL +) { + +43 +SgT»eCÝy + +tc +; + +44 +SgNode + * + gŠl + = +Šl_ +-> +cÝy +( +tc +); + +45 + gŠl +-> +£t_·»Á +( +Šl_ +-> +g‘_·»Á +()); + +46 +Ãw + +CG_ro£R•r +( +Šl +); + +48 if( + gÝ_ + !ð +NULL +) + +50 +SgT»eCÝy + +tc1 +; + +51 +SgNode +* + gÝ + = +isSgNode +( +Ý_ +)-> +cÝy +( +tc1 +); + +53 + gÝ +-> +£t_·»Á +( +isSgNode +( +Ý_ +)-> +g‘_·»Á +()); + +54 +Ãw + +CG_ro£R•r +( +isSgEx´essiÚ +( +Ý +)); + +56 if( + gli¡_ + !ð +NULL +) + +58 +SgS‹m’tPŒLi¡ +* +li¡2 + = +Ãw + SgStatementPtrList; + +60 + gSgS‹m’tPŒLi¡ +:: +™”©Ü + +™ + = (* +li¡_ +). +begš +(); + g™ + !ð(*li¡_). +’d +(); it++){ + +61 +SgT»eCÝy + + gtc3 +; + +62 +SgNode + * + gŠl2 + = +isSgNode +(* +™ +)-> +cÝy +( +tc3 +); + +63 + gŠl2 +-> +£t_·»Á +( +isSgNode +(* +™ +)-> +g‘_·»Á +()); + +65 (* + gli¡2 +). +push_back +( +isSgS‹m’t +( +Šl2 +)); + +67 +Ãw + +CG_ro£R•r +( +li¡2 +); + +70 + gNULL +; + +73 + gCG_ro£R•r +:: +þ—r +() { + +74 if( +Šl_ + !ð +NULL +) { + +75 +d–‘e + +Šl_ +; + +76 + gŠl_ + = +NULL +; + +80 +SgNode +* + gCG_ro£R•r +:: +G‘Code +() const { + +81 +Šl_ +; + +84 +SgS‹m’tPŒLi¡ +* + gCG_ro£R•r +:: +G‘Li¡ +() const { + +85 +li¡_ +; + +88 +SgEx´essiÚ +* + gCG_ro£R•r +:: +G‘Ex´essiÚ +() const { + +89 +Ý_ +; + +91 + gCG_ro£R•r +:: +Dump +() const { + +92 +SgNode +* +Šl + = +Šl_ +; + +93 +SgEx´essiÚ +* + gÝ + = +Ý_ + ; + +94 if( + gŠl + !ð +NULL +) + +95 +DumpFžeH–³r +( +Šl +, +¡dout +); + +96 if( + gÝ + !ð +NULL +) + +97 +DumpFžeH–³r +( +isSgNode +( +Ý +), +¡dout +); + +101 + gCG_ro£R•r +:: +DumpFžeH–³r +( +SgNode +* +node +, +FILE + * +å +) const{ + +102 + g¡d +:: +¡ršg + +x +; + +103 +size_t + + gnumb”OfSucûssÜs + = +node +-> +g‘_numb”OfT¿v”§lSucûssÜs +(); + +104 if( + gnumb”OfSucûssÜs + == 0){ + +105 +x + = +node +-> +uŬ£ToSŒšg + (); + +106 +årštf +( +å +, "%s", +x +. +c_¡r +()); + +109 +size_t + + gidx + = 0; idx < + gnumb”OfSucûssÜs +; idx++) + +111 +SgNode + * + gchžd + = +NULL +; + +112 + gchžd + = +node +-> +g‘_Œav”§lSucûssÜByIndex +( +idx +); + +113 +DumpFžeH–³r +( +chžd +, +å +); + +119 + gCG_ro£R•r +:: +DumpToFže +( +FILE + * +å +) const { + +121 +SgNode +* +Šl + = +Šl_ +; + +122 +SgEx´essiÚ +* + gÝ + = +Ý_ + ; + +124 if( + gŠl +!ð +NULL +){ + +125 +¡d +:: +¡ršg + +x + = +Šl +-> +uŬ£ToSŒšg +(); + +126 +årštf +( +å +, "%s", +x +. +c_¡r +()); + +129 if( + gÝ + !ð +NULL +){ + +130 +¡d +:: +¡ršg + +x + = +isSgNode +( +Ý +)-> +uŬ£ToSŒšg +(); + +131 +årštf +( +å +, "%s", +x +. +c_¡r +()); + + @CG_stringBuilder.cc + +17 + ~<code_g’/CG_¡ršgBužd”.h +> + +18 + ~<code_g’/CG_¡ršgR•r.h +> + +19 + ~<¡ršg +> + +21 +Çme¥aû + + gomega + { + +23 + g¡d +:: +¡ršg + +Saãgu¬dSŒšg +(cÚ¡ +¡d +::¡ršg & +s +, +Ý +); + +29 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©ePÏûHÞd” +( +šd’t +, + +30 +CG_ouutR•r + * +¡mt +, +Tu¶e +<CG_ouutR•r*> & +funcLi¡ +, + +31 +Tu¶e +< +¡d +:: +¡ršg +> &) const { + +32 +¡d +:: +¡ršg + +li¡SŒ + = ""; + +34 + gi + = 1; i <ð +funcLi¡ +. +size +(); i++) { + +35 ià( + gfuncLi¡ +[ +i +] =ð +NULL +) + +36 +li¡SŒ + += "N/A"; + +38 + gli¡SŒ + +ð +G‘SŒšg +( +funcLi¡ +[ +i +]); + +39 ià( + gi + < + gfuncLi¡ +. +size +()) + +40 + gli¡SŒ + += ","; + +43 + g¡d +:: +¡ršg + +¡mtName + = +G‘SŒšg +( +¡mt +); + +44 + g¡d +:: +¡ršg + +šd’tSŒ + = +G‘Ind’tS·ûs +( +šd’t +); + +46 +Ãw + +CG_¡ršgR•r +( +šd’tSŒ + + +¡mtName + + "(" + +li¡SŒ + + ");\n"); + +49 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eAssignm’t +( +šd’t +, + +50 +CG_ouutR•r +* +lhs +, CG_ouutR•r* +rhs +) const { + +51 ià( + glhs + =ð +NULL + || +rhs + == NULL) { + +52 +årštf +( +¡d”r +, "Code generation: missing†hs or„hs\n"); + +53 + gNULL +; + +56 + g¡d +:: +¡ršg + +lhsSŒ + = +G‘SŒšg +( +lhs +); + +57 + g¡d +:: +¡ršg + +rhsSŒ + = +G‘SŒšg +( +rhs +); + +59 + g¡d +:: +¡ršg + +šd’tSŒ + = +G‘Ind’tS·ûs +( +šd’t +); + +61 +Ãw + +CG_¡ršgR•r +( +šd’tSŒ + + +lhsSŒ + + "=" + +rhsSŒ + + ";\n"); + +64 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eInvoke +(cÚ¡ +¡d +:: +¡ršg + & +âame +, + +65 +Tu¶e +< +CG_ouutR•r +*> & +li¡ +) const { + +66 + g¡d +:: +¡ršg + +li¡SŒ + = ""; + +68 + gi + = 1; i <ð +li¡ +. +size +(); i++) { + +69 + gli¡SŒ + +ð +G‘SŒšg +( +li¡ +[ +i +]); + +70 ià( + gi + < + gli¡ +. +size +()) + +71 + gli¡SŒ + += ","; + +74 +Ãw + +CG_¡ršgR•r +( +âame + + "(" + +li¡SŒ + + ")"); + +77 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eComm’t +( +šd’t +, + +78 cÚ¡ +¡d +:: +¡ršg + & +comm’tText +) const { + +79 ià( +comm’tText + =ð +¡d +:: +¡ršg +("")) { + +80 +NULL +; + +83 + g¡d +:: +¡ršg + +šd’tSŒ + = +G‘Ind’tS·ûs +( +šd’t +); + +85 +Ãw + +CG_¡ršgR•r +( +šd’tSŒ + + "// " + +comm’tText + + "\n"); + +88 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eA‰ribu‹ +(CG_ouutR•¸* +cÚŒÞ +, + +89 cÚ¡ +¡d +:: +¡ršg + & +comm’tText +) const { + +90 ià( +comm’tText + =ð +¡d +:: +¡ršg +("")) { + +91 +cÚŒÞ +; + +94 + g¡d +:: +¡ršg + +cÚŒÞSŒšg + = +G‘SŒšg +( +cÚŒÞ +); + +96 +Ãw + +CG_¡ršgR•r +("// " + +comm’tText + + "\n" + +cÚŒÞSŒšg +); + +100 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eIf +( +šd’t +, CG_ouutR•r* +gu¬dLi¡ +, + +101 +CG_ouutR•r +* +Œue_¡mtLi¡ +, CG_ouutR•r* +çl£_¡mtLi¡ +) const { + +102 ià( + gŒue_¡mtLi¡ + =ð +NULL + && +çl£_¡mtLi¡ + == NULL) { + +103 +d–‘e + +gu¬dLi¡ +; + +104 + gNULL +; + +105 } ià( + ggu¬dLi¡ + =ð +NULL +) { + +106 +StmtLi¡Aµ’d +( +Œue_¡mtLi¡ +, +çl£_¡mtLi¡ +); + +109 + g¡d +:: +¡ršg + +gu¬dLi¡SŒ + = +G‘SŒšg +( +gu¬dLi¡ +); + +110 + g¡d +:: +¡ršg + +šd’tSŒ + = +G‘Ind’tS·ûs +( +šd’t +); + +111 + g¡d +:: +¡ršg + +s +; + +112 ià( + gŒue_¡mtLi¡ + !ð +NULL + && +çl£_¡mtLi¡ + == NULL) { + +113 +s + = +šd’tSŒ + + "ià(" + +gu¬dLi¡SŒ + + ") {\n" + +114 + +G‘SŒšg +( +Œue_¡mtLi¡ +è+ +šd’tSŒ + + "}\n"; + +115 } ià( + gŒue_¡mtLi¡ + =ð +NULL + && +çl£_¡mtLi¡ + != NULL) { + +116 +s + = +šd’tSŒ + + "ià!(" + +gu¬dLi¡SŒ + + ") {\n" + +117 + +G‘SŒšg +( +çl£_¡mtLi¡ +è+ +šd’tSŒ + + "}\n"; + +119 + gs + = +šd’tSŒ + + "ià(" + +gu¬dLi¡SŒ + + ") {\n" + +120 + +G‘SŒšg +( +Œue_¡mtLi¡ +è+ +šd’tSŒ + + "}\n" + indentStr + +121 + "–£ {\n" + +G‘SŒšg +( +çl£_¡mtLi¡ +è+ +šd’tSŒ + + "}\n"; + +124 +Ãw + +CG_¡ršgR•r +( +s +); + +127 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eInduùive +(CG_ouutR•r* +šdex +, + +128 +CG_ouutR•r +* +low” +, CG_ouutR•r* +uµ” +, CG_ouutR•r* +¡• +) const { + +129 ià( + gšdex + =ð +NULL +) { + +130 +årštf +( +¡d”r +, "Code generation: missing†oop index\n"); + +131 + gNULL +; + +134 ià( + glow” + =ð +NULL + || +uµ” + == NULL) { + +135 +årštf +( +¡d”r +, "Code generation: missing†oop bound\n"); + +138 + g¡d +:: +¡ršg + +šdexSŒ + = +G‘SŒšg +( +šdex +); + +139 + g¡d +:: +¡ršg + +low”SŒ +, + guµ”SŒ +; + +140 ià( + glow” + !ð +NULL +) + +141 +low”SŒ + = +G‘SŒšg +( +low” +); + +143 + glow”SŒ + = +¡d +:: +¡ršg +("-infinity"); + +144 ià( + guµ” + !ð +NULL +) + +145 +uµ”SŒ + = +G‘SŒšg +( +uµ” +); + +147 + guµ”SŒ + = +¡d +:: +¡ršg +("+infinity"); + +149 + g¡d +:: +¡ršg + +doSŒ + = "fÜ(" + +šdexSŒ + + " = " + +low”SŒ + + "; " + indexStr + +150 + " <ð" + +uµ”SŒ + + "; " + +šdexSŒ +; + +152 ià( + g¡• + !ð +NULL +) { + +153 +¡d +:: +¡ršg + +¡•SŒ + = +G‘SŒšg +( +¡• +); + +154 + gdoSŒ + +ð" +ð" + +¡•SŒ +; + +156 + gdoSŒ + += "++"; + +159 + gdoSŒ + += ")"; + +161 +Ãw + +CG_¡ršgR•r +( +doSŒ +); + +164 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eLoÝ +( +šd’t +, CG_ouutR•r* +cÚŒÞ +, + +165 +CG_ouutR•r +* +¡mtLi¡ +) const { + +166 ià( + g¡mtLi¡ + =ð +NULL +) { + +167 +d–‘e + +cÚŒÞ +; + +168 + gNULL +; + +169 } ià( + gcÚŒÞ + =ð +NULL +) { + +170 +årštf +( +¡d”r +, "Code generation:‚o inductive forhis†oop\n"); + +171 + g¡mtLi¡ +; + +174 + g¡d +:: +¡ršg + +ù¾SŒ + = +G‘SŒšg +( +cÚŒÞ +); + +175 + g¡d +:: +¡ršg + +¡mtSŒ + = +G‘SŒšg +( +¡mtLi¡ +); + +177 + g¡d +:: +¡ršg + +šd’tSŒ + = +G‘Ind’tS·ûs +( +šd’t +); + +179 + g¡d +:: +¡ršg + +s + = +šd’tSŒ + + +ù¾SŒ + + " {\n" + +¡mtSŒ + + indentStr + "}\n"; + +181 +Ãw + +CG_¡ršgR•r +( +s +); + +184 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eIÁ +( +_i +) const { + +185 +¡d +:: +¡ršg + +_s + = +to_¡ršg +( +_i +); + +186 +Ãw + +CG_¡ršgR•r +( +_s +); + +189 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eId’t +(cÚ¡ +¡d +:: +¡ršg + & +_s +) const { + +190 ià(& +_s + =ð +NULL + || _ =ð +¡d +:: +¡ršg +("")) { + +191 +NULL +; + +194 +Ãw + +CG_¡ršgR•r +( +_s +); + +197 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©ePlus +(CG_ouutR•r* +lÝ +, + +198 +CG_ouutR•r +* +rÝ +) const { + +199 ià( + grÝ + =ð +NULL +) { + +200 +lÝ +; + +201 } ià( + glÝ + =ð +NULL +) { + +202 +rÝ +; + +205 + g¡d +:: +¡ršg + +lÝSŒ + = +G‘SŒšg +( +lÝ +); + +206 + g¡d +:: +¡ršg + +rÝSŒ + = +G‘SŒšg +( +rÝ +); + +208 +Ãw + +CG_¡ršgR•r +( +lÝSŒ + + "+" + +rÝSŒ +); + +211 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eMšus +(CG_ouutR•r* +lÝ +, + +212 +CG_ouutR•r +* +rÝ +) const { + +213 ià( + grÝ + =ð +NULL +) { + +214 +lÝ +; + +215 } ià( + glÝ + =ð +NULL +) { + +216 +¡d +:: +¡ršg + +rÝSŒ + = +G‘SŒšg +( +rÝ +); + +217 +Ãw + +CG_¡ršgR•r +("-" + +Saãgu¬dSŒšg +( +rÝSŒ +, '-')); + +220 + g¡d +:: +¡ršg + +lÝSŒ + = +G‘SŒšg +( +lÝ +); + +221 + g¡d +:: +¡ršg + +rÝSŒ + = +G‘SŒšg +( +rÝ +); + +223 +Ãw + +CG_¡ršgR•r +( +lÝSŒ + + "-" + +Saãgu¬dSŒšg +( +rÝSŒ +, '-')); + +226 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eTimes +(CG_ouutR•r* +lÝ +, + +227 +CG_ouutR•r +* +rÝ +) const { + +228 ià( + grÝ + =ð +NULL + || +lÝ + == NULL) { + +229 +d–‘e + +rÝ +; + +230 +d–‘e + + glÝ +; + +231 + gNULL +; + +234 + g¡d +:: +¡ršg + +lÝSŒ + = +G‘SŒšg +( +lÝ +); + +235 + g¡d +:: +¡ršg + +rÝSŒ + = +G‘SŒšg +( +rÝ +); + +237 +Ãw + +CG_¡ršgR•r +( + +238 +Saãgu¬dSŒšg +( +lÝSŒ +, '*'è+ "*" + Saãgu¬dSŒšg( +rÝSŒ +, '*')); + +241 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eIÁeg”Divide +(CG_ouutR•r* +lÝ +, + +242 +CG_ouutR•r +* +rÝ +) const { + +243 ià( + grÝ + =ð +NULL +) { + +244 +årštf +( +¡d”r +, "Code generation: divide by NULL\n"); + +245 + gNULL +; + +246 } ià( + glÝ + =ð +NULL +) { + +247 +d–‘e + +rÝ +; + +248 + gNULL +; + +251 + g¡d +:: +¡ršg + +lÝSŒ + = +G‘SŒšg +( +lÝ +); + +252 + g¡d +:: +¡ršg + +rÝSŒ + = +G‘SŒšg +( +rÝ +); + +254 +Ãw + +CG_¡ršgR•r +("štDiv(" + +lÝSŒ + + "," + +rÝSŒ + + ")"); + +257 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eIÁeg”Mod +(CG_ouutR•r* +lÝ +, + +258 +CG_ouutR•r +* +rÝ +) const { + +259 ià( + grÝ + =ð +NULL + || +lÝ + == NULL) { + +260 +NULL +; + +263 + g¡d +:: +¡ršg + +lÝSŒ + = +G‘SŒšg +( +lÝ +); + +264 + g¡d +:: +¡ršg + +rÝSŒ + = +G‘SŒšg +( +rÝ +); + +266 +Ãw + +CG_¡ršgR•r +("štMod(" + +lÝSŒ + + "," + +rÝSŒ + + ")"); + +269 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eIÁeg”Cež +(CG_ouutR•r* +lÝ +, + +270 +CG_ouutR•r +* +rÝ +) const { + +271 ià( + grÝ + =ð +NULL + || +lÝ + == NULL) { + +272 +NULL +; + +275 + g¡d +:: +¡ršg + +lÝSŒ + = +G‘SŒšg +( +lÝ +); + +276 + g¡d +:: +¡ršg + +rÝSŒ + = +G‘SŒšg +( +rÝ +); + +278 +Ãw + +CG_¡ršgR•r +("štCež(" + +lÝSŒ + + "," + +rÝSŒ + + ")"); + +281 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eAnd +(CG_ouutR•r* +lÝ +, + +282 +CG_ouutR•r +* +rÝ +) const { + +283 ià( + grÝ + =ð +NULL +) + +284 +lÝ +; + +285 ià( + glÝ + =ð +NULL +) + +286 +rÝ +; + +288 + g¡d +:: +¡ršg + +lÝSŒ + = +G‘SŒšg +( +lÝ +); + +289 + g¡d +:: +¡ršg + +rÝSŒ + = +G‘SŒšg +( +rÝ +); + +291 +Ãw + +CG_¡ršgR•r +( +lÝSŒ + + " && " + +rÝSŒ +); + +294 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eGE +(CG_ouutR•r* +lÝ +, + +295 +CG_ouutR•r +* +rÝ +) const { + +296 ià( + grÝ + =ð +NULL + || +lÝ + == NULL) { + +297 +NULL +; + +300 + g¡d +:: +¡ršg + +lÝSŒ + = +G‘SŒšg +( +lÝ +); + +301 + g¡d +:: +¡ršg + +rÝSŒ + = +G‘SŒšg +( +rÝ +); + +303 +Ãw + +CG_¡ršgR•r +( +lÝSŒ + + " >ð" + +rÝSŒ +); + +306 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eLE +(CG_ouutR•r* +lÝ +, + +307 +CG_ouutR•r +* +rÝ +) const { + +308 ià( + grÝ + =ð +NULL + || +lÝ + == NULL) { + +309 +NULL +; + +312 + g¡d +:: +¡ršg + +lÝSŒ + = +G‘SŒšg +( +lÝ +); + +313 + g¡d +:: +¡ršg + +rÝSŒ + = +G‘SŒšg +( +rÝ +); + +315 +Ãw + +CG_¡ršgR•r +( +lÝSŒ + + " <ð" + +rÝSŒ +); + +318 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +C»©eEQ +(CG_ouutR•r* +lÝ +, + +319 +CG_ouutR•r +* +rÝ +) const { + +320 ià( + grÝ + =ð +NULL + || +lÝ + == NULL) { + +321 +NULL +; + +324 + g¡d +:: +¡ršg + +lÝSŒ + = +G‘SŒšg +( +lÝ +); + +325 + g¡d +:: +¡ršg + +rÝSŒ + = +G‘SŒšg +( +rÝ +); + +327 +Ãw + +CG_¡ršgR•r +( +lÝSŒ + + " =ð" + +rÝSŒ +); + +330 +CG_ouutR•r +* + gCG_¡ršgBužd” +:: +StmtLi¡Aµ’d +(CG_ouutR•r* +li¡1 +, + +331 +CG_ouutR•r +* +li¡2 +) const { + +332 ià( + gli¡2 + =ð +NULL +) { + +333 +li¡1 +; + +334 } ià( + gli¡1 + =ð +NULL +) { + +335 +li¡2 +; + +338 + g¡d +:: +¡ršg + +li¡1SŒ + = +G‘SŒšg +( +li¡1 +); + +339 + g¡d +:: +¡ršg + +li¡2SŒ + = +G‘SŒšg +( +li¡2 +); + +341 +Ãw + +CG_¡ršgR•r +( +li¡1SŒ + + +li¡2SŒ +); + +347 + g¡d +:: +¡ršg + +G‘Ind’tS·ûs +( +šd’t +) { + +348 +¡d +:: +¡ršg + +šd’tSŒ +; + +349 + gi + = 1; i < + gšd’t +; i++) { + +350 + gšd’tSŒ + += " "; + +352 + gšd’tSŒ +; + +359 + g¡d +:: +¡ršg + +G‘SŒšg +( +CG_ouutR•r +* +»´ +) { + +360 +¡d +:: +¡ršg + +»suÉ + = +¡©ic_ÿ¡ +< +CG_¡ršgR•r + *>( +»´ +)-> +G‘SŒšg +(); + +361 +d–‘e + + g»´ +; + +362 + g»suÉ +; + +365 + g¡d +:: +¡ršg + +Saãgu¬dSŒšg +(cÚ¡ +¡d +::¡ršg & +s +, +Ý +) { + +366 + gËn + = +s +. +Ëngth +(); + +367 + g·»n_Ëv– + = 0; + +368 + gnum_¶usmšus + = 0; + +369 + gnum_mul + = 0; + +370 + gnum_div + = 0; + +371 + gi + = 0; i < + gËn +; i++) + +372 + gs +[ +i +]) { + +374 +·»n_Ëv– +++; + +377 +·»n_Ëv– +--; + +381 ià( +·»n_Ëv– + == 0) + +382 +num_¶usmšus +++; + +385 ià( +·»n_Ëv– + == 0) + +386 +num_mul +++; + +389 ià( +·»n_Ëv– + == 0) + +390 +num_div +++; + +396 +boÞ + + gÃed_·»n + = +çl£ +; + +397 + gÝ +) { + +399 ià( +num_¶usmšus + > 0) + +400 +Ãed_·»n + = +Œue +; + +403 ià( +num_¶usmšus + > 0 || +num_div + > 0) + +404 +Ãed_·»n + = +Œue +; + +407 ià( +num_¶usmšus + > 0 || +num_div + > 0 || +num_mul + > 0) + +408 +Ãed_·»n + = +Œue +; + +414 ià( + gÃed_·»n +) + +415 "(" + + gs + + ")"; + +417 + gs +; + + @CG_stringRepr.cc + +16 + ~<code_g’/CG_¡ršgR•r.h +> + +17 + ~<¡dio.h +> + +19 +Çme¥aû + + gomega + { + +21 + gCG_¡ršgR•r +:: +CG_¡ršgR•r +() { + +24 +CG_¡ršgR•r +::CG_¡ršgR•r(cÚ¡ +¡d +:: +¡ršg +& +_s +è: +s +(_s) { + +27 +CG_¡ršgR•r +::~CG_stringRepr() { + +30 +CG_ouutR•r +* +CG_¡ršgR•r +:: +þÚe +() { + +31 +Ãw + +CG_¡ršgR•r +( +s +); + +38 + g¡d +:: +¡ršg + +CG_¡ršgR•r +:: +G‘SŒšg +() const { + +39 +s +; + +46 + gCG_¡ršgR•r +:: +Dump +() const { + +47 +´štf +("%s\n", +s +. +c_¡r +()); + +50 + gCG_¡ršgR•r +:: +DumpToFže +( +FILE + * +å +) const { + +51 +årštf +( +å +,"%s", +s +. +c_¡r +()); + + @CG_suifBuilder.cc + +15 + ~<¡ack +> + +16 + ~<code_g’/CG_suifBužd”.h +> + +17 + ~<suif1/ªnÙe.h +> + +18 + ~<veùÜ +> + +20 +Çme¥aû + + gomega + { + +25 * + gk_ocg_comm’t +; + +26 * + gk_s2c_´agma +; + +27 * + gk_cuda_dim3 +; + +28 * + gk_cuda_k”Ãl +; + +29 * + gk_cuda_modif›r +; + +30 * + gk_cuda_‹xtu»_memÜy +; + +38
+Tu¶e +< Tu¶e<> > +smtNÚS¶™Lev–s +; + +39
+Tu¶e +< Tu¶e< +¡d +:: +¡ršg +> > +loÝIdxNames +; + +40
+¡d +:: +veùÜ +< std:: +·œ +<, std:: +¡ršg +> > +syncs +; + +41
+checkLoÝLev– +; + +42
+¡mtFÜLoÝCheck +; + +43
+uµ”BoundFÜLev– +; + +44
+low”BoundFÜLev– +; + +45
+boÞ + +fžlInBounds +; + +48 cÚ¡ * + glibcode_g’_v”_¡ršg + = ""; + +49 cÚ¡ * + glibcode_g’_who_¡ršg + = ""; + +50 cÚ¡ * + glibcode_g’_suif_¡ršg + = ""; + +53 +š™_code_g’ +() { + +54 +boÞ + + gisIn™ + = +çl£ +; + +55 if(! + gisIn™ +) + +57 + gisIn™ + = +Œue +; + +58 +ANNOTE +( +k_ocg_comm’t +, "omega_comm’t", +TRUE +); + +59 +ANNOTE +( +k_s2c_´agma +, "s2ø´agma", +TRUE +); + +60 +ANNOTE +( +k_cuda_dim3 +, "cud¨dim3", +TRUE +); + +61 +ANNOTE +( +k_cuda_k”Ãl +, "cud¨k”Ãl", +TRUE +); + +62 +ANNOTE +( +k_cuda_modif›r +, "cud¨modif›r", +TRUE +); + +67 +ex™_code_g’ +( ) { + +75 + gCG_suifBužd” +:: +CG_suifBužd” +( +´oc_symb + * +symb +) + +77 +symb_ + = +symb +; + +78 +š™_code_g’ +(); + +81 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©ePÏûHÞd” + (, CG_ouutR•¸* +¡mt +, + +82 +Tu¶e +< +CG_ouutR•r +*> & +funcLi¡ +, Tu¶e< +¡d +:: +¡ršg +> & +loÝ_v¬s +) const { + +83 +Œ“_node_li¡ + * +Šl + = +¡©ic_ÿ¡ +< +CG_suifR•r + *>( +¡mt +)-> +Šl_ +; + +84 +d–‘e + + g¡mt +; + +86 + gi + = 1; i <ð +funcLi¡ +. +size +(); i++) { + +87 ià( + gfuncLi¡ +[ +i +] =ð +NULL +) + +90 +CG_suifR•r + * + g»´ + = +¡©ic_ÿ¡ +<CG_suifR•r*>( +funcLi¡ +[ +i +]); + +91 +Ý”ªd + + gÝ + = +»´ +-> +Ý_ +; + +92 +d–‘e + + g»´ +; + +94 +v¬_sym + * + gvs + = +¡©ic_ÿ¡ +<v¬_sym*>( +symb_ +-> +lookup_sym +( +loÝ_v¬s +[ +i +]. +c_¡r +(), +SYM_VAR +)); + +96 +sub¡™u‹ +( +Šl +, +vs +, +Ý +, +symb_ +); + +98 ià( + gÝ +. +is_š¡r +()) + +99 +d–‘e + + gÝ +. +š¡r +(); + +102 +Ãw + +CG_suifR•r +( +Šl +); + +106 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eAssignm’t +(, CG_ouutR•¸* +lhs +, + +107 +CG_ouutR•r + * +rhs +) const { + +108 iàÐ + glhs + =ð +NULL + || +rhs + == NULL ) { + +109 +årštf +( +¡d”r +, "Code generation: Missing†hs or„hs\n"); + +110 + gNULL +; + +113 +Ý”ªd + + g¤c + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +rhs +)-> +Ý_ +; + +114 ià( + g¤c +. +is_š¡r +(è&& src. +š¡r +()-> +Ýcode +(è=ð +io_¬¿y +) { + +115 +š_¬¿y + * +Ÿ + = +¡©ic_ÿ¡ +<š_¬¿y *>( +¤c +. +š¡r +()); + +116 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_lod +, +Ÿ +-> +–em_ty³ +(), +Ý”ªd +(), ia); + +117 + g¤c + = +Ý”ªd +( +šs +); + +120 +š¡ruùiÚ + * + gšs +; + +121 +Ý”ªd + + gd¡ + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +lhs +)-> +Ý_ +; + +122 ià( + gd¡ +. +is_š¡r +(è&& d¡. +š¡r +()-> +Ýcode +(è=ð +io_¬¿y +) { + +123 +š_¬¿y + * +Ÿ + = +¡©ic_ÿ¡ +<š_¬¿y *>( +d¡ +. +š¡r +()); + +124 + gšs + = +Ãw + +š_¼r +( +io_¡r +, +ty³_void +, +Ý”ªd +(), o³¿nd( +Ÿ +), +¤c +); + +127 + gšs + = +Ãw + +š_¼r +( +io_ýy +, +¤c +. +ty³ +(), +d¡ +, src); + +129 +d–‘e + + glhs +; + +130 +d–‘e + + grhs +; + +132 +Œ“_node_li¡ + * + gŠl + = +Ãw +ree_node_list; + +133 + gŠl +-> +³nd +( +Ãw + +Œ“_š¡r +( +šs +)); + +135 +Ãw + +CG_suifR•r +( +Šl +); + +139 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eInvoke +(cÚ¡ +¡d +:: +¡ršg + & +âame +, + +140 +Tu¶e +< +CG_ouutR•r +*> & +li¡ +) const { + +141 ià( + gâame + =ð +¡d +:: +¡ršg +("max"è|| +âame + == std::string("min")) { + +142 ià( +li¡ +. +size +() == 0) { + +143 +NULL +; + +145 ià( + gli¡ +. +size +() == 1) { + +146 +li¡ +[1]; + +149 + gÏ¡ + = +li¡ +. +size +(); + +150 +Ý”ªd + + gÝ2 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +li¡ +[ +Ï¡ +])-> +Ý_ +; + +151 +d–‘e + + gli¡ +[ +Ï¡ +]; + +152 + gli¡ +. +d–‘e_Ï¡ +(); + +153 +CG_suifR•r + * + g»´ + = +¡©ic_ÿ¡ +<CG_suifR•r*>( +C»©eInvoke +( +âame +, +li¡ +)); + +154 +Ý”ªd + + gÝ1 + = +»´ +-> +Ý_ +; + +156 +š¡ruùiÚ + * + gšs +; + +157 ià( + gâame + =ð +¡d +:: +¡ršg +("max")) + +158 +šs + = +Ãw + +š_¼r +( +io_max +, +Ý1 +. +ty³ +(), +Ý”ªd +(), op1, +Ý2 +); + +160 + gšs + = +Ãw + +š_¼r +( +io_mš +, +Ý1 +. +ty³ +(), +Ý”ªd +(), op1, +Ý2 +); + +162 + g»´ +-> + gÝ_ + = +Ý”ªd +( +šs +); + +164 + g»´ +; + +168 +årštf +( +¡d”r +, "Code generation: invoke function io_call‚ot implemented\n"); + +169 + gNULL +; + +174 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eA‰ribu‹ +(CG_ouutR•¸* +cÚŒÞ +, + +175 cÚ¡ +¡d +:: +¡ršg + & +comm’tText +)const { + +176 ià( +comm’tText + =ð +¡d +:: +¡ršg +("")) { + +177 +cÚŒÞ +; + +180 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_mrk +); + +182 +immed_li¡ + * + giml + = +Ãw + immed_list; + +183 + giml +-> +³nd +( +immed +( +cÚ¡_ÿ¡ +<*>( +comm’tText +. +c_¡r +()))); + +184 + gšs +-> +´•’d_ªnÙe +( +k_ocg_comm’t +, +iml +); + +186 +Œ“_node_li¡ + * + gŠl + ; + +187 + gŠl + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +cÚŒÞ +)-> +Šl_ +; + +188 + gŠl +-> +³nd +( +Ãw + +Œ“_š¡r +( +šs +)); + +191 +Ãw + +CG_suifR•r +( +Šl +); + +198 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eComm’t +(, cÚ¡ +¡d +:: +¡ršg + & +comm’tText +) const { + +199 iàÐ +comm’tText + =ð +¡d +:: +¡ršg +("") ) { + +200 +NULL +; + +203 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_mrk +); + +205 +immed_li¡ + * + giml + = +Ãw + immed_list; + +206 + giml +-> +³nd +( +immed +( +cÚ¡_ÿ¡ +<*>( +comm’tText +. +c_¡r +()))); + +207 + gšs +-> +´•’d_ªnÙe +( +k_ocg_comm’t +, +iml +); + +209 +Œ“_node_li¡ + * + gŠl + = +Ãw +ree_node_list; + +210 + gŠl +-> +³nd +( +Ãw + +Œ“_š¡r +( +šs +)); + +212 +Ãw + +CG_suifR•r +( +Šl +); + +216 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eIf +(, CG_ouutR•¸* +gu¬dLi¡ +, + +217 +CG_ouutR•r + * +Œue_¡mtLi¡ +, CG_ouutR•¸* +çl£_¡mtLi¡ +) const { + +218 + gif_couÁ” + = 1; + +219 + g¡d +:: +¡ršg + +s + = +¡d +::¡ršg("omegaif_")+ +to_¡ršg +( +if_couÁ” +++); + +220 +Ïb–_sym + * + gif_Ïb– + = +Ãw +†ab–_sym( +cÚ¡_ÿ¡ +<*>( +s +. +c_¡r +())); + +221 + gsymb_ +-> +add_sym +( +if_Ïb– +); + +223 iàÐ + gŒue_¡mtLi¡ + =ð +NULL + && +çl£_¡mtLi¡ + == NULL ) { + +224 +d–‘e + +gu¬dLi¡ +; + +225 + gNULL +; + +227 iàÐ + ggu¬dLi¡ + =ð +NULL + ) { + +228 +StmtLi¡Aµ’d +( +Œue_¡mtLi¡ +, +çl£_¡mtLi¡ +); + +231 +Œ“_node_li¡ + * + gh—d” + = +Ãw +ree_node_list; + +232 +Ý”ªd + + gÝ + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +gu¬dLi¡ +)-> +Ý_ +; + +234 + g¡d +:: +¡ack +< *> +S +; + +235 + gS +. +push +( +Ý +. +š¡r +()); + +236 ! + gS +. +em±y +()) { + +237 +š¡ruùiÚ + * + gšs + = +¡©ic_ÿ¡ +<š¡ruùiÚ *>( +S +. +tÝ +()); + +238 + gS +. +pÝ +(); + +239 ià( + gšs +-> +Ýcode +(è=ð +io_ªd +) { + +240 +š¡ruùiÚ + * +šs1 + = +šs +-> +¤c_Ý +(0). +š¡r +(); + +241 + gšs1 +-> +»move +(); + +242 + gS +. +push +( +šs1 +); + +243 +š¡ruùiÚ + * + gšs2 + = +šs +-> +¤c_Ý +(1). +š¡r +(); + +244 + gšs2 +-> +»move +(); + +245 + gS +. +push +( +šs2 +); + +246 +d–‘e + + gšs +; + +249 + gšs + = +Ãw + +š_bj +( +io_bçl£ +, +if_Ïb– +, +Ý”ªd +( +šs +)); + +250 + gh—d” +-> +³nd +( +Ãw + +Œ“_š¡r +( +šs +)); + +254 +Œ“_node_li¡ + * + gth’_·¹ +, * + g–£_·¹ +; + +255 ià( + gŒue_¡mtLi¡ + !ð +NULL +) + +256 +th’_·¹ + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +Œue_¡mtLi¡ +)-> +Šl_ +; + +258 + gth’_·¹ + = +NULL +; + +259 ià( + gçl£_¡mtLi¡ + !ð +NULL +) + +260 +–£_·¹ + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +çl£_¡mtLi¡ +)-> +Šl_ +; + +262 + g–£_·¹ + = +NULL +; + +263 +Œ“_if + * + gti + = +Ãw +»e_if( +if_Ïb– +, +h—d” +, +th’_·¹ +, +–£_·¹ +); + +265 +Œ“_node_li¡ + * + gŠl + = +Ãw +ree_node_list; + +266 + gŠl +-> +³nd +( +ti +); + +268 +d–‘e + + ggu¬dLi¡ +; + +269 +d–‘e + + gŒue_¡mtLi¡ +; + +270 +d–‘e + + gçl£_¡mtLi¡ +; + +272 +Ãw + +CG_suifR•r +( +Šl +); + +276 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eInduùive +(CG_ouutR•¸* +šdex +, + +277 +CG_ouutR•r + * +low” +, + +278 +CG_ouutR•r + * +uµ” +, + +279 +CG_ouutR•r + * +¡• +) const { + +280 iàÐ + gšdex + =ð +NULL + || +low” + =ðNULL || +uµ” + == NULL ) { + +281 +årštf +( +¡d”r +, "Code generation: something wrong in CreateInductive\n"); + +282 + gNULL +; + +285 ià( + g¡• + =ð +NULL +) + +286 +¡• + = +C»©eIÁ +(1); + +288 +v¬_sym + * + gšdex_sym + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +šdex +)-> +Ý_ +. +symbÞ +(); + +289 +Ý”ªd + + glow”_bound + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +low” +)-> +Ý_ +; + +290 +Ý”ªd + + guµ”_bound + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +uµ” +)-> +Ý_ +; + +291 +Ý”ªd + + g¡•_size + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +¡• +)-> +Ý_ +; + +293 +Ïb–_sym + * + gcÚtLab– + = +Ãw +†abel_sym(""); + +294 +Ïb–_sym + * + gbrkLab– + = +Ãw +†abel_sym(""); + +295 + gsymb_ +-> +add_sym +( +cÚtLab– +); + +296 + gsymb_ +-> +add_sym +( +brkLab– +); + +297 +Œ“_fÜ + * + gtf + = +Ãw +»e_fÜ( +šdex_sym +, +FOR_SLTE +, +cÚtLab– +, +brkLab– +, +NULL +, + +298 +low”_bound +, +uµ”_bound +, +¡•_size +, +NULL +); + +300 +Œ“_node_li¡ + * + gŠl + = +Ãw +ree_node_list; + +301 + gŠl +-> +³nd +( +tf +); + +303 +d–‘e + + gšdex +; + +304 +d–‘e + + glow” +; + +305 +d–‘e + + guµ” +; + +306 +d–‘e + + g¡• +; + +308 +Ãw + +CG_suifR•r +( +Šl +); + +312 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eLoÝ +(, CG_ouutR•¸* +cÚŒÞ +, + +313 +CG_ouutR•r + * +¡mtLi¡ +) const { + +314 iàÐ + g¡mtLi¡ + =ð +NULL + ) { + +315 +d–‘e + +cÚŒÞ +; + +316 + gNULL +; + +318 iàÐ + gcÚŒÞ + =ð +NULL + ) { + +319 +årštf +( +¡d”r +, "Code generation:‚o inductive forhis†oop\n"); + +320 + g¡mtLi¡ +; + +323 +Œ“_node_li¡ + * + gŠl + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +cÚŒÞ +)-> +Šl_ +; + +324 +Œ“_node_li¡_™” + +™” +( +Šl +); + +325 +Œ“_fÜ + * + gtf + = +¡©ic_ÿ¡ +<Œ“_fÜ*>( +™” +. +¡• +()); + +327 +Œ“_node_li¡ + * + gbody + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +¡mtLi¡ +)-> +Šl_ +; + +328 + gtf +-> +£t_body +( +body +); + +330 +d–‘e + + g¡mtLi¡ +; + +332 + gcÚŒÞ +; + +336 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eIÁ +( +_i +) const { + +337 +š_ldc + * +šs + = +Ãw + in_ldc( +ty³_s32 +, +Ý”ªd +(), +immed +( +_i +)); + +339 +Ãw + +CG_suifR•r +( +Ý”ªd +( +šs +)); + +343 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eId’t +(cÚ¡ +¡d +:: +¡ršg + & +_s +) const { + +344 iàÐ& +_s + =ð +NULL + || _ =ð +¡d +:: +¡ršg +("") ) { + +345 +NULL +; + +348 +v¬_sym + * + gvs + = +¡©ic_ÿ¡ +<v¬_sym*>( +symb_ +-> +lookup_sym +( +_s +. +c_¡r +(), +SYM_VAR +)); + +350 ià( + gvs + =ð +NULL +) { + +351 +vs + = +Ãw + +v¬_sym +( +ty³_s32 +, +cÚ¡_ÿ¡ +<*>( +_s +. +c_¡r +())); + +352 + gsymb_ +-> +add_sym +( +vs +); + +355 +Ãw + +CG_suifR•r +( +Ý”ªd +( +vs +)); + +359 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©ePlus +(CG_ouutR•¸* +lÝ +, + +360 +CG_ouutR•r + * +rÝ +) const { + +361 iàÐ + grÝ + =ð +NULL + ) { + +362 +lÝ +; + +364 iàÐ + glÝ + =ð +NULL + ) { + +365 +rÝ +; + +368 +Ý”ªd + + gÝ1 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +lÝ +)-> +Ý_ +; + +369 +Ý”ªd + + gÝ2 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +rÝ +)-> +Ý_ +; + +371 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_add +, +Ý1 +. +ty³ +(), +Ý”ªd +(), op1, +Ý2 +); + +373 +d–‘e + + glÝ +; + +374 +d–‘e + + grÝ +; + +376 +Ãw + +CG_suifR•r +( +Ý”ªd +( +šs +)); + +380 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eMšus +(CG_ouutR•¸* +lÝ +, + +381 +CG_ouutR•r + * +rÝ +) const { + +382 iàÐ + grÝ + =ð +NULL + ) { + +383 +lÝ +; + +385 iàÐ + glÝ + =ð +NULL + ) { + +386 +Ý”ªd + +Ý + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +rÝ +)-> +Ý_ +; + +387 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_Ãg +, +Ý +. +ty³ +(), +Ý”ªd +(), op); + +389 +d–‘e + + grÝ +; + +391 +Ãw + +CG_suifR•r +( +Ý”ªd +( +šs +)); + +394 +Ý”ªd + + gÝ1 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +lÝ +)-> +Ý_ +; + +395 +Ý”ªd + + gÝ2 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +rÝ +)-> +Ý_ +; + +397 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_sub +, +Ý1 +. +ty³ +(), +Ý”ªd +(), op1, +Ý2 +); + +399 +d–‘e + + glÝ +; + +400 +d–‘e + + grÝ +; + +402 +Ãw + +CG_suifR•r +( +Ý”ªd +( +šs +)); + +407 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eTimes +(CG_ouutR•¸* +lÝ +, + +408 +CG_ouutR•r + * +rÝ +) const { + +409 iàÐ + grÝ + =ð +NULL + || +lÝ + == NULL) { + +410 ià( +rÝ + !ð +NULL +) { + +411 +rÝ +-> +þ—r +(); + +412 +d–‘e + + grÝ +; + +414 ià( + glÝ + !ð +NULL +) { + +415 +lÝ +-> +þ—r +(); + +416 +d–‘e + + glÝ +; + +418 + gNULL +; + +421 +Ý”ªd + + gÝ1 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +lÝ +)-> +Ý_ +; + +422 +Ý”ªd + + gÝ2 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +rÝ +)-> +Ý_ +; + +424 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_mul +, +Ý1 +. +ty³ +(), +Ý”ªd +(), op1, +Ý2 +); + +426 +d–‘e + + glÝ +; + +427 +d–‘e + + grÝ +; + +429 +Ãw + +CG_suifR•r +( +Ý”ªd +( +šs +)); + +433 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eIÁeg”Divide +(CG_ouutR•¸* +lÝ +, + +434 +CG_ouutR•r + * +rÝ +) const { + +435 iàÐ + grÝ + =ð +NULL + ) { + +436 +årštf +( +¡d”r +, "Code generation: divide by NULL\n"); + +437 + gNULL +; + +439 iàÐ + glÝ + =ð +NULL + ) { + +440 +d–‘e + +rÝ +; + +441 + gNULL +; + +445 +Ý”ªd + + gÝ1 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +lÝ +)-> +Ý_ +; + +446 +Ý”ªd + + gÝ2 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +rÝ +)-> +Ý_ +; + +449 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_div +, +Ý1 +. +ty³ +(), +Ý”ªd +(), op1, +Ý2 +); + +451 +d–‘e + + glÝ +; + +452 +d–‘e + + grÝ +; + +454 +Ãw + +CG_suifR•r +( +Ý”ªd +( +šs +)); + +458 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eIÁeg”Mod +(CG_ouutR•¸* +lÝ +, + +459 +CG_ouutR•r + * +rÝ +) const { + +460 iàÐ + grÝ + =ð +NULL + || +lÝ + == NULL ) { + +461 +NULL +; + +464 +Ý”ªd + + gÝ1 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +lÝ +)-> +Ý_ +; + +465 +Ý”ªd + + gÝ2 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +rÝ +)-> +Ý_ +; + +468 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_»m +, +ty³_s32 +, +Ý”ªd +(), +Ý1 +, +Ý2 +); + +470 +d–‘e + + glÝ +; + +471 +d–‘e + + grÝ +; + +473 +Ãw + +CG_suifR•r +( +Ý”ªd +( +šs +)); + +477 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eAnd +(CG_ouutR•¸* +lÝ +, + +478 +CG_ouutR•r + * +rÝ +) const { + +479 ià( + grÝ + =ð +NULL +) + +480 +lÝ +; + +481 ià( + glÝ + =ð +NULL +) + +482 +rÝ +; + +484 +Ý”ªd + + gÝ1 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +lÝ +)-> +Ý_ +; + +485 +Ý”ªd + + gÝ2 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +rÝ +)-> +Ý_ +; + +487 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_ªd +, +Ý1 +. +ty³ +(), +Ý”ªd +(), op1, +Ý2 +); + +489 +d–‘e + + glÝ +; + +490 +d–‘e + + grÝ +; + +492 +Ãw + +CG_suifR•r +( +Ý”ªd +( +šs +)); + +496 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eGE +(CG_ouutR•¸* +lÝ +, + +497 +CG_ouutR•r + * +rÝ +) const { + +498 +C»©eLE +( +rÝ +, +lÝ +); + +502 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eLE +(CG_ouutR•¸* +lÝ +, + +503 +CG_ouutR•r + * +rÝ +) const { + +504 iàÐ + grÝ + =ð +NULL + || +lÝ + == NULL ) { + +505 +NULL +; + +508 +Ý”ªd + + gÝ1 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +lÝ +)-> +Ý_ +; + +509 +Ý”ªd + + gÝ2 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +rÝ +)-> +Ý_ +; + +511 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_¦e +, +ty³_s32 +, +Ý”ªd +(), +Ý1 +, +Ý2 +); + +513 +d–‘e + + glÝ +; + +514 +d–‘e + + grÝ +; + +516 +Ãw + +CG_suifR•r +( +Ý”ªd +( +šs +)); + +520 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eEQ +(CG_ouutR•¸* +lÝ +, + +521 +CG_ouutR•r + * +rÝ +) const { + +522 iàÐ + grÝ + =ð +NULL + || +lÝ + == NULL ) { + +523 +NULL +; + +526 +Ý”ªd + + gÝ1 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +lÝ +)-> +Ý_ +; + +527 +Ý”ªd + + gÝ2 + = +¡©ic_ÿ¡ +< +CG_suifR•r +*>( +rÝ +)-> +Ý_ +; + +529 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_£q +, +ty³_s32 +, +Ý”ªd +(), +Ý1 +, +Ý2 +); + +531 +d–‘e + + glÝ +; + +532 +d–‘e + + grÝ +; + +534 +Ãw + +CG_suifR•r +( +Ý”ªd +( +šs +)); + +539 +CG_ouutR•r +* + gCG_suifBužd” +:: +StmtLi¡Aµ’d +(CG_ouutR•¸* +li¡1 +, + +540 +CG_ouutR•r + * +li¡2 +) const { + +541 iàÐ + gli¡2 + =ð +NULL + ) { + +542 +li¡1 +; + +544 iàÐ + gli¡1 + =ð +NULL + ) { + +545 +li¡2 +; + +548 +Œ“_node_li¡ + * + gŠl1 + = +¡©ic_ÿ¡ +< +CG_suifR•r + *>( +li¡1 +)-> +Šl_ +; + +549 +Œ“_node_li¡ + * + gŠl2 + = +¡©ic_ÿ¡ +< +CG_suifR•r + *>( +li¡2 +)-> +Šl_ +; + +550 ià( + gŠl2 + =ð +NULL +) + +551 +Šl1 +-> +³nd +( +Ãw + +Œ“_š¡r +( +¡©ic_ÿ¡ +< +CG_suifR•r + *>( +li¡2 +)-> +Ý_ +. +š¡r +())); + +553 + gŠl1 +-> +³nd +( +Šl2 +); + +555 +d–‘e + + gli¡2 +; + +557 + gli¡1 +; + +565 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eP¿gma +(, + +566 cÚ¡ +¡d +:: +¡ršg + & +´agmaText +) const { + +567 iàÐ +´agmaText + =ð +¡d +:: +¡ršg +("") ) { + +568 +NULL +; + +570 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_mrk +); + +571 +immed_li¡ + * + giml + = +Ãw + immed_list; + +572 + giml +-> +³nd +( +immed +( +cÚ¡_ÿ¡ +<*>( +´agmaText +. +c_¡r +()))); + +573 + gšs +-> +³nd_ªnÙe +( +k_s2c_´agma +, +iml +); + +574 +Œ“_node_li¡ + * + gŠl + = +Ãw +ree_node_list; + +575 + gŠl +-> +³nd +( +Ãw + +Œ“_š¡r +( +šs +)); + +576 +Ãw + +CG_suifR•r +( +Šl +); + +579 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eDim3 +( +immed + +v¬Name +, immed +¬g1 +, immed +¬g2 +) const { + +580 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_mrk +); + +581 +immed_li¡ + * + giml + = +Ãw + immed_list; + +582 + giml +-> +³nd +( +immed +( +v¬Name +)); + +583 + giml +-> +³nd +( +¬g1 +); + +584 + giml +-> +³nd +( +¬g2 +); + +585 + gšs +-> +³nd_ªnÙe +( +k_cuda_dim3 +, +iml +); + +586 +Œ“_node_li¡ + * + gŠl + = +Ãw +ree_node_list; + +587 + gŠl +-> +³nd +( +Ãw + +Œ“_š¡r +( +šs +)); + +588 +Ãw + +CG_suifR•r +( +Šl +); + +591 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eDim3 +( +immed + +v¬Name +, immed +¬g1 +, immed +¬g2 +, immed +¬g3 +) const { + +592 +š¡ruùiÚ + * + gšs + = +Ãw + +š_¼r +( +io_mrk +); + +593 +immed_li¡ + * + giml + = +Ãw + immed_list; + +594 + giml +-> +³nd +( +immed +( +v¬Name +)); + +595 + giml +-> +³nd +( +¬g1 +); + +596 + giml +-> +³nd +( +¬g2 +); + +597 + giml +-> +³nd +( +¬g3 +); + +598 + gšs +-> +³nd_ªnÙe +( +k_cuda_dim3 +, +iml +); + +599 +Œ“_node_li¡ + * + gŠl + = +Ãw +ree_node_list; + +600 + gŠl +-> +³nd +( +Ãw + +Œ“_š¡r +( +šs +)); + +601 +Ãw + +CG_suifR•r +( +Šl +); + +604 +CG_ouutR•r +* + gCG_suifBužd” +:: +C»©eK”Ãl +( +immed_li¡ +* +iml +) const { + +605 +š¡ruùiÚ + * +šs + = +Ãw + +š_¼r +( +io_mrk +); + +606 + gšs +-> +³nd_ªnÙe +( +k_cuda_k”Ãl +, +iml +); + +607 +Œ“_node_li¡ + * + gŠl + = +Ãw +ree_node_list; + +608 + gŠl +-> +³nd +( +Ãw + +Œ“_š¡r +( +šs +)); + +609 +Ãw + +CG_suifR•r +( +Šl +); + +612 +ty³_node +* + gCG_suifBužd” +:: +ModifyTy³ +Ñy³_node* +ba£ +, cÚ¡ * +modif›r +) const { + +613 +modif›r_ty³ +* + g»suÉ + = +Ãw + modif›r_ty³( +TYPE_NULL +, +ba£ +); + +614 +immed_li¡ + * + giml + = +Ãw + immed_list; + +615 + giml +-> +³nd +( +immed +((*) +modif›r +)); + +616 + g»suÉ +-> +³nd_ªnÙe +( +k_cuda_modif›r +, +iml +); + +617 + g»suÉ +; + +626 +boÞ + +sub¡™u‹ +( +š¡ruùiÚ + * +š +, +v¬_sym + * +sym +, +Ý”ªd + +ex´ +, +ba£_symb + * +¡ +) { + +627 ià( + gš + =ð +NULL + || +sym + == NULL) + +628 +çl£ +; + +630 +boÞ + + gr + = +çl£ +; + +631 + gi + = 0; i < + gš +-> +num_¤cs +(); i++) { + +632 +Ý”ªd + +Ý +( +š +-> +¤c_Ý +( +i +)); + +634 ià( + gÝ +. +is_symbÞ +(è&& op. +symbÞ +(è=ð +sym +) { + +635 +š +-> +£t_¤c_Ý +( +i +, +ex´ +. +þÚe +( +¡ +)); + +636 + gr + = +Œue +; + +638 ià( + gÝ +. +is_š¡r +()) { + +639 + gr + = +sub¡™u‹ +( +Ý +. +š¡r +(), +sym +, +ex´ +, +¡ +) ||„; + +643 + gr +; + +646 +boÞ + +sub¡™u‹ +( +Œ“_node + * +Š +, +v¬_sym + * +sym +, +Ý”ªd + +ex´ +, +ba£_symb + * +¡ +) { + +647 ià( + gŠ + =ð +NULL +) + +648 +çl£ +; + +650 +boÞ + + gr + = +çl£ +; + +651 ià( + gŠ +-> +kšd +(è=ð +TREE_INSTR +) + +652 +r + = +sub¡™u‹ +( +¡©ic_ÿ¡ +< +Œ“_š¡r +*>( +Š +)-> +š¡r +(), +sym +, +ex´ +, +¡ +è|| + gr +; + +654 + gi + = 0; i < + gŠ +-> +num_chžd_li¡s +(); i++) { + +655 + gr + = +sub¡™u‹ +( +Š +-> +chžd_li¡_num +( +i +), +sym +, +ex´ +, +¡ +) ||„; + +659 + gr +; + +662 +boÞ + +sub¡™u‹ +( +Œ“_node_li¡ + * +Šl +, +v¬_sym + * +sym +, +Ý”ªd + +ex´ +, + +663 +ba£_symb + * +¡ +) { + +664 ià( + gŠl + =ð +NULL +) + +665 +çl£ +; + +667 +boÞ + + gr + = +çl£ +; + +668 +Œ“_node_li¡_™” + +™” +( +Šl +); + +669 ! + g™” +. +is_em±y +()) { + +670 +Œ“_node + * + gŠ + = +™” +. +¡• +(); + +672 + gr + = +sub¡™u‹ +( +Š +, +sym +, +ex´ +, +¡ +) ||„; + +675 + gr +; + + @CG_suifRepr.cc + +14 + ~<code_g’/CG_suifR•r.h +> + +15 + ~<¡dio.h +> + +17 +Çme¥aû + + gomega + { + +19 + gCG_suifR•r +:: +CG_suifR•r +(): +Šl_ +( +NULL +), +Ý_ +() { + +22 + gCG_suifR•r +:: +CG_suifR•r +( +Œ“_node_li¡ + * +Šl +): +Šl_ +ÑÆ), +Ý_ +() { + +25 + gCG_suifR•r +:: +CG_suifR•r +( +Ý”ªd + +Ý +): +Šl_ +( +NULL +), +Ý_ +(op) { + +28 + gCG_suifR•r +::~ +CG_suifR•r +() { + +33 +CG_ouutR•r +* +CG_suifR•r +:: +þÚe +() { + +34 ià(! +Ý_ +. +is_nuÎ +() ) { + +35 +Ý”ªd + +Ý + = +Ý_ +. +þÚe +(); + +36 +Ãw + +CG_suifR•r +( +Ý +); + +38 ià( + gŠl_ + !ð +NULL +) { + +39 +Œ“_node_li¡ + * +Šl + = +Šl_ +-> +þÚe +(); + +40 +Ãw + +CG_suifR•r +( +Šl +); + +43 +Ãw + +CG_suifR•r +(); + +46 + gCG_suifR•r +:: +þ—r +() { + +47 ià(! +Ý_ +. +is_nuÎ +()) { + +48 ià( +Ý_ +. +is_š¡r +()) + +49 +d–‘e + +Ý_ +. +š¡r +(); + +50 + gÝ_ +. +£t_nuÎ +(); + +52 ià( + gŠl_ + !ð +NULL +) { + +53 +d–‘e + +Šl_ +; + +54 + gŠl_ + = +NULL +; + +58 +Œ“_node_li¡ +* + gCG_suifR•r +:: +G‘Code +() const { + +59 +Šl_ +; + +62 +Ý”ªd + + gCG_suifR•r +:: +G‘Ex´essiÚ +() const { + +63 +Ý_ +; + +66 + gCG_suifR•r +:: +Dump +() const { + +67 ià( +Šl_ + !ð +NULL +) + +68 +Šl_ +-> +´št +(); + +69 ià(! + gÝ_ +. +is_nuÎ +()) + +70 + gÝ_ +. +´št +(); + +73 + gCG_suifR•r +:: +DumpToFže +( +FILE + * +å +) const { + +74 ià( +Šl_ + !ð +NULL +) + +75 +Šl_ +-> +´št +( +å +); + +76 ià(! + gÝ_ +. +is_nuÎ +()) + +77 + gÝ_ +. +´št +( +å +); + + @code_gen.cc + +16 + ~<omega.h +> + +17 + ~<omega/R–_m.h +> + +18 + ~<basic/CÞËùiÚ.h +> + +19 + ~<basic/Bag.h +> + +20 + ~<basic/M.h +> + +21 + ~<basic/utž.h +> + +22 + ~<basic/omega_”rÜ.h +> + +23 + ~<m©h.h +> + +24 + ~<veùÜ +> + +26 + ~<code_g’/CG.h +> + +27 + ~<code_g’/code_g’.h +> + +28 + ~<code_g’/CG_ouutBužd”.h +> + +29 + ~<code_g’/CG_ouutR•r.h +> + +30 + ~<code_g’/CG_¡ršgBužd”.h +> + +31 + ~<code_g’/CG_¡ršgR•r.h +> + +32 + ~<code_g’/ouut_»´.h +> + +34 +Çme¥aû + + gomega + { + +37 + gÏ¡_Ëv– +; + +38 +S‘Tu¶e + + gÃw_IS +; + +39 +S‘Tu¶eTu¶e + + g´ojeùed_nIS +; + +40 + gTu¶e +< + gCG_ouutR•r + *> + g¡©em’tInfo +; + +41 +R–Tu¶e + + gŒªsfÜm©iÚs +; + +44 + gTu¶e +< Tu¶e<> > + gsmtNÚS¶™Lev–s +; + +45 + gTu¶e +< Tu¶e< + g¡d +:: +¡ršg +> > +loÝIdxNames +; + +46 + g¡d +:: +veùÜ +< +¡d +:: +·œ +<, std:: +¡ršg +> > +syncs +; + +51 + gcheckLoÝLev– +; + +52 + g¡mtFÜLoÝCheck +; + +53 + guµ”BoundFÜLev– +; + +54 + glow”BoundFÜLev– +; + +55 +boÞ + + gfžlInBounds +; + +58 þas + cJunkSticIn™ +{ + gpublic +: +JunkSticIn™ +(){ +checkLoÝLev– +=0; + gfžlInBounds += +çl£ +;} }; + +59 +JunkSticIn™ + + gjunkIn™In¡ªû__ +; + +64 +CG_»suÉ + * +g’_»cursive +( +Ëv– +, +IÁTu¶e + & +isAùive +); + +67 + gcode_g’_debug +=0; + +70 +S‘Tu¶e + + $fž‹r_funùiÚ_symbÞs +( +S‘Tu¶e + & +£ts +, +boÞ + +k“p_fs +){ + +71 +S‘Tu¶e + + `Ãw_£ts +( +£ts +. + `size +()); + +72 +i + = 1; i <ð +£ts +. + `size +(); i++) { + +73 +R–©iÚ + +R + = +£ts +[ +i +]; + +74 +R–©iÚ + & +S + = +Ãw_£ts +[ +i +]; + +75 + `as£¹ +( +R +. + `is_£t +()); + +77 +S + = + `R–©iÚ +( +R +. + `n_£t +()); + +78 +S +. + `cÝy_Çmes +( +R +); + +79 +F_Exi¡s + * +ã + = +S +. + `add_exi¡s +(); + +80 +F_Or + * +fo + = +ã +-> + `add_Ü +(); + +81 +DNF_I‹¿tÜ + + `D +( +R +. + `qu”y_DNF +()); +D +; D++) { + +82 +F_And + * +ç + = +fo +-> + `add_ªd +(); + +83 +V¬ŸbË_ID_Tu¶e + & +Þdloÿls + = (* +D +)-> + `loÿls +(); + +84 +SeùiÚ +< +V¬ŸbË_ID +> +Ãwloÿls + = +ã +-> + `deþ¬e_tu¶e +( +Þdloÿls +. + `size +()); + +91 +EQ_I‹¿tÜ + + `e +(* +D +); +e +;ƒ++) + +92 if(( + `max_fs_¬™y +(* +e +è> 0è=ð +k“p_fs +){ + +93 +EQ_HªdË + +n + = +ç +-> + `add_EQ +(); + +94 +CÚ¡r_V¬s_I‹r + + `cvi +(* +e +, +çl£ +); +cvi +;cvi++) + +95 if((* +cvi +). +v¬ +-> + `kšd +(è=ð +Wždÿrd_V¬ +) + +96 +n +. + `upd©e_cÛf +( +Ãwloÿls +[ +Þdloÿls +. + `šdex +((* +cvi +). +v¬ +)], + +97 (* +cvi +). +cÛf +); + +99 if((* +cvi +). +v¬ +-> + `kšd +(è=ð +Glob®_V¬ +) + +100 +n +. + `upd©e_cÛf +( +S +. + `g‘_loÿl +((* +cvi +). +v¬ +-> + `g‘_glob®_v¬ +(), + +101 (* +cvi +). +v¬ +-> + `funùiÚ_of +()), + +102 (* +cvi +). +cÛf +); + +104 +n +. + `upd©e_cÛf +((* +cvi +). +v¬ +,(*cvi). +cÛf +); + +105 +n +. + `upd©e_cÚ¡ +((* +e +). + `g‘_cÚ¡ +()); + +106 +n +. + `fš®ize +(); + +109 +GEQ_I‹¿tÜ + + `g +(* +D +); +g +; g++) + +110 if(( + `max_fs_¬™y +(* +g +è> 0è=ð +k“p_fs +) { + +111 +GEQ_HªdË + +n + = +ç +-> + `add_GEQ +(); + +112 +CÚ¡r_V¬s_I‹r + + `cvi +(* +g +, +çl£ +); +cvi +;cvi++) + +113 if((* +cvi +). +v¬ +-> + `kšd +(è=ð +Wždÿrd_V¬ +) + +114 +n +. + `upd©e_cÛf +( +Ãwloÿls +[ +Þdloÿls +. + `šdex +((* +cvi +). +v¬ +)], + +115 (* +cvi +). +cÛf +); + +117 if((* +cvi +). +v¬ +-> + `kšd +(è=ð +Glob®_V¬ +) + +118 +n +. + `upd©e_cÛf +( +S +. + `g‘_loÿl +((* +cvi +). +v¬ +-> + `g‘_glob®_v¬ +(), + +119 (* +cvi +). +v¬ +-> + `funùiÚ_of +()), + +120 (* +cvi +). +cÛf +); + +122 +n +. + `upd©e_cÛf +((* +cvi +). +v¬ +,(*cvi). +cÛf +); + +123 +n +. + `upd©e_cÚ¡ +((* +g +). + `g‘_cÚ¡ +()); + +124 +n +. + `fš®ize +(); + +127 +S +. + `fš®ize +(); + +130 +Ãw_£ts +; + +131 + } +} + +134 +R–Tu¶e + + $¡r_funùiÚ_symbÞs +( +S‘Tu¶e + & +£ts +) { + +135 + `fž‹r_funùiÚ_symbÞs +( +£ts +, +çl£ +); + +136 + } +} + +138 +R–Tu¶e + + $exŒaù_funùiÚ_symbÞs +( +S‘Tu¶e + & +£ts +) { + +139 + `fž‹r_funùiÚ_symbÞs +( +£ts +, +Œue +); + +140 + } +} + +143 + g¡d +:: +¡ršg + + $MMG’”©eCode +( +R–Tu¶e + & +T +, +S‘Tu¶e + & +Þd_IS +, +R–©iÚ + & +known +, +effÜt +) { + +144 +Tu¶e +< +CG_ouutR•r + *> +ÇmeInfo +; + +145 +¡mt + = 1; stmˆ<ð +T +. + `size +(); stmt++) + +146 +ÇmeInfo +. + `³nd +( +Ãw + + `CG_¡ršgR•r +("s" + + `to_¡ršg +( +¡mt +))); + +148 +CG_¡ršgBužd” + +ocg +; + +149 +CG_¡ršgR•r + * +sR•r + = +¡©ic_ÿ¡ +<CG_¡ršgR•¸*>( + `MMG’”©eCode +(& +ocg +, +T +, +Þd_IS +, +ÇmeInfo +, +known +, +effÜt +)); + +151 +i + = 1; i <ð +ÇmeInfo +. + `size +(); i++) + +152 +d–‘e + +ÇmeInfo +[ +i +]; + +153 ià( +sR•r + !ð +NULL +) + +154 + `G‘SŒšg +( +sR•r +); + +156 +¡d +:: + `¡ršg +(); + +157 + } +} + +163 +CG_ouutR•r +* +MMG’”©eCode +( +CG_ouutBužd” +* +ocg +, +R–Tu¶e + & +T +, +S‘Tu¶e + & +Þd_IS +, cÚ¡ +Tu¶e +<CG_ouutR•¸*> & +¡mt_cÚ‹Á +, +R–©iÚ + & +known +, +effÜt +) { + +164 + g¡mts + = +T +. +size +(); + +165 ià( + g¡mts + == 0) + +166 +ocg +-> +C»©eComm’t +(1, "No statements found!"); + +167 ià(! + gknown +. +is_nuÎ +()) + +168 + gknown +. +sim¶ify +(); + +171 + gmaxStmt + = 1; + +172 + gÏ¡_Ëv– + = 0; + +173 + g¡mt + = 1; stmˆ<ð +¡mts +; stmt++) { + +174 + gÞd_dim + = +T +[ +¡mt +]. +n_out +(); + +175 ià( + gÞd_dim + > + gÏ¡_Ëv– +) + +176 + gÏ¡_Ëv– + = +Þd_dim +; + +178 + gi + = 1; i <ð +Þd_IS +[ +¡mt +]. +n_£t +(); i++) + +179 + gT +[ +¡mt +]. +Çme_šput_v¬ +( +i +, +Þd_IS +[¡mt]. +£t_v¬ +(i)-> +Çme +()); + +180 + gi + = 1; i <ð +Þd_dim +; i++) + +181 + gT +[ +¡mt +]. +Çme_ouut_v¬ +( +i +, +¡d +:: +¡ršg +("t")+ +to_¡ršg +(i)); + +182 + gT +[ +¡mt +]. +£tup_Çmes +(); + +184 +R–©iÚ + + gR + = +Rªge +( +Re¡riù_Domaš +( +cÝy +( +T +[ +¡mt +]), cÝy( +Þd_IS +[stmt]))); + +185 + gR +. +sim¶ify +(); + +186 + gR +. +is_uµ”_bound_§tisfŸbË +()) { + +187 + gÃw_IS +. +»®loÿ‹ +( +maxStmt +); + +188 + gŒªsfÜm©iÚs +. +»®loÿ‹ +( +maxStmt +); + +189 + g¡©em’tInfo +. +»®loÿ‹ +( +maxStmt +); + +190 +DNF + * + gdnf + = +R +. +qu”y_DNF +(); + +191 +DNF_I‹¿tÜ + +c +( +dnf +); + +192 +R–©iÚ + + gR2 + = R–©iÚ( +R +, * +c +); + +193 + gR2 +. +sim¶ify +(); + +194 ià( + gR2 +. +is_šexaù +()) + +195 +throw + +codeg’_”rÜ +("unknown constraint in†oop bounds"); + +196 ià( + gknown +. +is_nuÎ +()) { + +197 + gÃw_IS +[ +maxStmt +] = +R2 +; + +198 + gŒªsfÜm©iÚs +[ +maxStmt +] = +T +[ +¡mt +]; + +199 + g¡©em’tInfo +[ +maxStmt +] = +¡mt_cÚ‹Á +[ +¡mt +]; + +200 + gmaxStmt +++; + +203 +R–©iÚ + + gR2_ex‹nded + = +cÝy +( +R2 +); + +204 +R–©iÚ + + gknown_ex‹nded + = +cÝy +( +known +); + +205 ià( + gR2 +. +n_£t +(è> + gknown +.n_set()) + +206 + gknown_ex‹nded + = +Ex‹nd_S‘ +( +known_ex‹nded +, +R2 +. +n_£t +()- +known +.n_set()); + +207 ià( + gR2 +. +n_£t +(è< + gknown +.n_set()) + +208 + gR2_ex‹nded + = +Ex‹nd_S‘ +( +R2_ex‹nded +, +known +. +n_£t +()- +R2 +.n_set()); + +209 ià( +IÁ”£ùiÚ +( +R2_ex‹nded +, +known_ex‹nded +). +is_uµ”_bound_§tisfŸbË +()) { + +210 + gÃw_IS +[ +maxStmt +] = +R2 +; + +211 + gŒªsfÜm©iÚs +[ +maxStmt +] = +T +[ +¡mt +]; + +212 + g¡©em’tInfo +[ +maxStmt +] = +¡mt_cÚ‹Á +[ +¡mt +]; + +213 + gmaxStmt +++; + +216 + gc +. +Ãxt +(); + +217 ià(! + gc +. +live +()) + +219 if( + gcode_g’_debug +) { + +220 +årštf +( +DebugFže +, "splitting iteration space for disjoint form\n"); + +221 +årštf +( +DebugFže +, "Original iteration space: \n"); + +222 + gR +. +´št_w™h_subs +( +DebugFže +); + +223 +årštf +( +DebugFže +, "First conjunct: \n"); + +224 + gR2 +. +´št_w™h_subs +( +DebugFže +); + +226 +R–©iÚ + +»mašd” +( +R +, * +c +); + +227 + gc +. +Ãxt +(); + +228 + gc +. +live +()) { + +229 + g»mašd” + = +UniÚ +( +»mašd” +, +R–©iÚ +( +R +, * +c +)); + +230 + gc +. +Ãxt +(); + +232 + gR + = +Difã»nû +( +»mašd” +, +cÝy +( +R2 +)); + +233 + gR +. +sim¶ify +(); + +234 if( + gcode_g’_debug +) { + +235 +årštf +( +DebugFže +, "Remaining iteration space: \n"); + +236 + gR +. +´št_w™h_subs +( +DebugFže +); + +242 + g¡mts + = +maxStmt +-1; + +243 if( + g¡mts + == 0) + +244 +ocg +-> +C»©eComm’t +(1, "No…oints in‡ny ofhe iteration spaces!"); + +247 + g¡mt + = 1; stmˆ<ð +¡mts +; stmt++) { + +248 + gÞd_dim + = +Ãw_IS +[ +¡mt +]. +n_£t +(); + +249 ià( + gÞd_dim + < + gÏ¡_Ëv– +) { + +250 + gÃw_IS +[ +¡mt +] = +Ex‹nd_S‘ +( +Ãw_IS +[¡mt], +Ï¡_Ëv– +- +Þd_dim +); + +251 +F_And + * + gf_roÙ + = +Ãw_IS +[ +¡mt +]. +ªd_w™h_ªd +(); + +252 + gi + = +Þd_dim ++1; i <ð +Ï¡_Ëv– +; i++) { + +253 +EQ_HªdË + + gh + = +f_roÙ +-> +add_EQ +(); + +254 + gh +. +upd©e_cÛf +( +Ãw_IS +[ +¡mt +]. +£t_v¬ +( +i +), 1); + +255 + gh +. +upd©e_cÚ¡ +( +posInfš™y +); + +261 if( + gknown +. +is_nuÎ +()) { + +262 + gknown + = +R–©iÚ +:: +True +( +Ï¡_Ëv– +); + +264 + gknown + = +Ex‹nd_S‘ +( +known +, +Ï¡_Ëv– +-known. +n_£t +()); + +265 + gi + = 1; i <ð +Ï¡_Ëv– +; i++) + +266 + gknown +. +Çme_£t_v¬ +( +i +, +¡d +:: +¡ršg +("t")+ +to_¡ršg +(i)); + +267 + gknown +. +£tup_Çmes +(); + +270 + g´ojeùed_nIS +. +þ—r +(); + +271 + g´ojeùed_nIS +. +»®loÿ‹ +( +Ï¡_Ëv– +); + +272 + gi + = 1; i <ð +Ï¡_Ëv– +; i++ ) { + +273 + g´ojeùed_nIS +[ +i +]. +»®loÿ‹ +( +¡mts +); + +275 + g¡mt + = 1; stmˆ<ð +¡mts +; stmt++) { + +276 ià( + gÏ¡_Ëv– + > 0) + +277 + g´ojeùed_nIS +[ +Ï¡_Ëv– +][ +¡mt +] = +Ãw_IS +[stmt]; + +278 + gi + = +Ï¡_Ëv– +-1; i >= 1; i--) { + +279 + g´ojeùed_nIS +[ +i +][ +¡mt +] = +Projeù +( +cÝy +( +´ojeùed_nIS +[i+1][¡mt]), i+1, +S‘_V¬ +); + +280 + g´ojeùed_nIS +[ +i +][ +¡mt +]. +sim¶ify +(); + +285 +IÁTu¶e + +®lStmts +( +¡mts +); + +286 + gi + = 1; i <ð +¡mts +; i++) + +287 + g®lStmts +[ +i +] = 1; + +288 +CG_»suÉ + * + gcg + = +g’_»cursive +(1, +®lStmts +); + +291 + gcg + = +cg +-> +»compu‹ +( +known +, known); + +292 + gcg + = +cg +-> +fÜû_fš™e_bounds +(); + +295 + gi + = 1; i <ð +mš +( +effÜt +, +cg +-> +d•th +()); i++) + +296 + gcg + = +cg +-> +liáOv”h—d +( +i +); + +299 + gcg +-> +hoi¡Gu¬d +(); + +303 +CG_ouutR•r +* + gsR•r + = +cg +-> +´štR•r +( +ocg +, 1, +¡d +:: +veùÜ +<CG_ouutR•¸*>( +Ï¡_Ëv– +)); + +304 +d–‘e + + gcg +; + +305 + gcg + = +NULL +; + +306 + g´ojeùed_nIS +. +þ—r +(); + +307 + gŒªsfÜm©iÚs +. +þ—r +(); + +308 + gÃw_IS +. +þ—r +(); + +310 + gsR•r +; + +314 +CG_ouutR•r +* +MMG’”©eCode +( +CG_ouutBužd” +* +ocg +, +R–Tu¶e + & +T +, +S‘Tu¶e + & +Þd_IS +, + +315 cÚ¡ +Tu¶e +< +CG_ouutR•r + *> & +¡mt_cÚ‹Á +, +R–©iÚ + & +known +, + +316 +Tu¶e +< +IÁTu¶e + >& +smtNÚS¶™Lev–s_ +, + +317 +¡d +:: +veùÜ +< std:: +·œ +<, std:: +¡ršg +> > +syncs_ +, + +318 cÚ¡ +Tu¶e +< Tu¶e< +¡d +:: +¡ršg +> >& +loÝIdxNames_ +, + +319 +effÜt +) { + +320 + g¡mts + = +T +. +size +(); + +321 ià( + g¡mts + == 0) + +322 +ocg +-> +C»©eComm’t +(1, "No statements found!"); + +323 ià(! + gknown +. +is_nuÎ +()) + +324 + gknown +. +sim¶ify +(); + +328 + gsmtNÚS¶™Lev–s + = +smtNÚS¶™Lev–s_ +; + +329 + gsyncs + = +syncs_ +; + +330 + gloÝIdxNames + = +loÝIdxNames_ +; + +336 + gmaxStmt + = 1; + +337 + gÏ¡_Ëv– + = 0; + +338 + g¡mt + = 1; stmˆ<ð +¡mts +; stmt++) { + +339 + gÞd_dim + = +T +[ +¡mt +]. +n_out +(); + +340 ià( + gÞd_dim + > + gÏ¡_Ëv– +) + +341 + gÏ¡_Ëv– + = +Þd_dim +; + +343 + gi + = 1; i <ð +Þd_IS +[ +¡mt +]. +n_£t +(); i++) + +344 + gT +[ +¡mt +]. +Çme_šput_v¬ +( +i +, +Þd_IS +[¡mt]. +£t_v¬ +(i)-> +Çme +()); + +345 + gi + = 1; i <ð +Þd_dim +; i++) + +346 + gT +[ +¡mt +]. +Çme_ouut_v¬ +( +i +, +¡d +:: +¡ršg +("t")+ +to_¡ršg +(i)); + +347 + gT +[ +¡mt +]. +£tup_Çmes +(); + +349 +R–©iÚ + + gR + = +Rªge +( +Re¡riù_Domaš +( +cÝy +( +T +[ +¡mt +]), cÝy( +Þd_IS +[stmt]))); + +350 + gR +. +sim¶ify +(); + +351 + gR +. +is_uµ”_bound_§tisfŸbË +()) { + +352 + gÃw_IS +. +»®loÿ‹ +( +maxStmt +); + +353 + gŒªsfÜm©iÚs +. +»®loÿ‹ +( +maxStmt +); + +354 + g¡©em’tInfo +. +»®loÿ‹ +( +maxStmt +); + +357 + gsmtNÚS¶™Lev–s +. +»®loÿ‹ +( +maxStmt +); + +361 +DNF + * + gdnf + = +R +. +qu”y_DNF +(); + +362 +DNF_I‹¿tÜ + +c +( +dnf +); + +363 +R–©iÚ + + gR2 + = R–©iÚ( +R +, * +c +); + +364 + gR2 +. +sim¶ify +(); + +365 ià( + gR2 +. +is_šexaù +()) + +366 +throw + +codeg’_”rÜ +("unknown constraint in†oop bounds"); + +367 ià( + gknown +. +is_nuÎ +()) { + +368 + gÃw_IS +[ +maxStmt +] = +R2 +; + +369 + gŒªsfÜm©iÚs +[ +maxStmt +] = +T +[ +¡mt +]; + +370 + g¡©em’tInfo +[ +maxStmt +] = +¡mt_cÚ‹Á +[ +¡mt +]; + +371 + gmaxStmt +++; + +374 +R–©iÚ + + gR2_ex‹nded + = +cÝy +( +R2 +); + +375 +R–©iÚ + + gknown_ex‹nded + = +cÝy +( +known +); + +376 ià( + gR2 +. +n_£t +(è> + gknown +.n_set()) + +377 + gknown_ex‹nded + = +Ex‹nd_S‘ +( +known_ex‹nded +, +R2 +. +n_£t +()- +known +.n_set()); + +378 ià( + gR2 +. +n_£t +(è< + gknown +.n_set()) + +379 + gR2_ex‹nded + = +Ex‹nd_S‘ +( +R2_ex‹nded +, +known +. +n_£t +()- +R2 +.n_set()); + +380 ià( +IÁ”£ùiÚ +( +R2_ex‹nded +, +known_ex‹nded +). +is_uµ”_bound_§tisfŸbË +()) { + +381 + gÃw_IS +[ +maxStmt +] = +R2 +; + +382 + gŒªsfÜm©iÚs +[ +maxStmt +] = +T +[ +¡mt +]; + +383 + g¡©em’tInfo +[ +maxStmt +] = +¡mt_cÚ‹Á +[ +¡mt +]; + +384 + gmaxStmt +++; + +387 + gc +. +Ãxt +(); + +388 ià(! + gc +. +live +()) + +390 if( + gcode_g’_debug +) { + +391 +årštf +( +DebugFže +, "splitting iteration space for disjoint form\n"); + +392 +årštf +( +DebugFže +, "Original iteration space: \n"); + +393 + gR +. +´št_w™h_subs +( +DebugFže +); + +394 +årštf +( +DebugFže +, "First conjunct: \n"); + +395 + gR2 +. +´št_w™h_subs +( +DebugFže +); + +397 +R–©iÚ + +»mašd” +( +R +, * +c +); + +398 + gc +. +Ãxt +(); + +399 + gc +. +live +()) { + +400 + g»mašd” + = +UniÚ +( +»mašd” +, +R–©iÚ +( +R +, * +c +)); + +401 + gc +. +Ãxt +(); + +403 + gR + = +Difã»nû +( +»mašd” +, +cÝy +( +R2 +)); + +404 + gR +. +sim¶ify +(); + +405 if( + gcode_g’_debug +) { + +406 +årštf +( +DebugFže +, "Remaining iteration space: \n"); + +407 + gR +. +´št_w™h_subs +( +DebugFže +); + +413 + g¡mts + = +maxStmt +-1; + +414 if( + g¡mts + == 0) + +415 +ocg +-> +C»©eComm’t +(1, "No…oints in‡ny ofhe iteration spaces!"); + +418 + g¡mt + = 1; stmˆ<ð +¡mts +; stmt++) { + +419 + gÞd_dim + = +Ãw_IS +[ +¡mt +]. +n_£t +(); + +420 ià( + gÞd_dim + < + gÏ¡_Ëv– +) { + +421 + gÃw_IS +[ +¡mt +] = +Ex‹nd_S‘ +( +Ãw_IS +[¡mt], +Ï¡_Ëv– +- +Þd_dim +); + +422 +F_And + * + gf_roÙ + = +Ãw_IS +[ +¡mt +]. +ªd_w™h_ªd +(); + +423 + gi + = +Þd_dim ++1; i <ð +Ï¡_Ëv– +; i++) { + +424 +EQ_HªdË + + gh + = +f_roÙ +-> +add_EQ +(); + +425 + gh +. +upd©e_cÛf +( +Ãw_IS +[ +¡mt +]. +£t_v¬ +( +i +), 1); + +426 + gh +. +upd©e_cÚ¡ +( +posInfš™y +); + +432 if( + gknown +. +is_nuÎ +()) { + +433 + gknown + = +R–©iÚ +:: +True +( +Ï¡_Ëv– +); + +435 + gknown + = +Ex‹nd_S‘ +( +known +, +Ï¡_Ëv– +-known. +n_£t +()); + +436 + gi + = 1; i <ð +Ï¡_Ëv– +; i++) + +437 + gknown +. +Çme_£t_v¬ +( +i +, +¡d +:: +¡ršg +("t")+ +to_¡ršg +(i)); + +438 + gknown +. +£tup_Çmes +(); + +441 + g´ojeùed_nIS +. +þ—r +(); + +442 + g´ojeùed_nIS +. +»®loÿ‹ +( +Ï¡_Ëv– +); + +443 + gi + = 1; i <ð +Ï¡_Ëv– +; i++ ) { + +444 + g´ojeùed_nIS +[ +i +]. +»®loÿ‹ +( +¡mts +); + +446 + g¡mt + = 1; stmˆ<ð +¡mts +; stmt++) { + +447 ià( + gÏ¡_Ëv– + > 0) + +448 + g´ojeùed_nIS +[ +Ï¡_Ëv– +][ +¡mt +] = +Ãw_IS +[stmt]; + +449 + gi + = +Ï¡_Ëv– +-1; i >= 1; i--) { + +450 + g´ojeùed_nIS +[ +i +][ +¡mt +] = +Projeù +( +cÝy +( +´ojeùed_nIS +[i+1][¡mt]), i+1, +S‘_V¬ +); + +451 + g´ojeùed_nIS +[ +i +][ +¡mt +]. +sim¶ify +(); + +456 +IÁTu¶e + +®lStmts +( +¡mts +); + +457 + gi + = 1; i <ð +¡mts +; i++) + +458 + g®lStmts +[ +i +] = 1; + +459 +CG_»suÉ + * + gcg + = +g’_»cursive +(1, +®lStmts +); + +462 + gcg + = +cg +-> +»compu‹ +( +known +, known); + +463 + gcg + = +cg +-> +fÜû_fš™e_bounds +(); + +466 + gi + = 1; i <ð +mš +( +effÜt +, +cg +-> +d•th +()); i++) + +467 + gcg + = +cg +-> +liáOv”h—d +( +i +); + +470 + gcg +-> +hoi¡Gu¬d +(); + +474 +CG_ouutR•r +* + gsR•r + = +cg +-> +´štR•r +( +ocg +, 1, +¡d +:: +veùÜ +<CG_ouutR•¸*>( +Ï¡_Ëv– + )); + +475 +d–‘e + + gcg +; + +476 + gcg + = +NULL +; + +477 + g´ojeùed_nIS +. +þ—r +(); + +478 + gŒªsfÜm©iÚs +. +þ—r +(); + +479 + gÃw_IS +. +þ—r +(); + +481 + gsR•r +; + +484 +CG_»suÉ + * + $g’_»cursive +( +Ëv– +, +IÁTu¶e + & +isAùive +) { + +485 +¡mts + = +isAùive +. + `size +(); + +487 +S‘ +<> +aùive +; + +488 +s +; + +489 +s + = 1; s <ð +¡mts +; s++) + +490 if( +isAùive +[ +s +]è +aùive +. + `š£¹ +(s); + +492 + `as£¹ + ( +aùive +. + `size +() >= 1); + +493 if( +Ëv– + > +Ï¡_Ëv– +è +Ãw + + `CG_Ëaf +( +isAùive +); + +495 ià( +aùive +. + `size +() == 1) + +496 +Ãw + + `CG_loÝ +( +isAùive +, +Ëv– +, + `g’_»cursive +(level+1,isActive)); + +498 +boÞ + +cÚ¡ªtLev– + = +Œue +; + +500 +‹¡_»l_size +; + +501 +cÛf_t + +¡¬t +, +fšish +; + +502 +fšish + = -( +posInfš™y +-1); + +503 +¡¬t + = +posInfš™y +; + +504 +Tu¶e +< +cÛf_t +> + `wh’ +( +¡mts +); + +505 +s +=1; s<= +¡mts +; s++èià( +isAùive +[s]) { + +506 +cÛf_t + +lb +, +ub +; + +507 +‹¡_»l_size + = +´ojeùed_nIS +[ +Ëv– +][ +s +]. + `n_£t +(); + +508 +´ojeùed_nIS +[ +Ëv– +][ +s +]. + `sšgË_cÚjunù +() + +509 -> + `qu”y_v¬ŸbË_bounds +( + +510 +´ojeùed_nIS +[ +Ëv– +][ +s +]. + `£t_v¬ +(level), + +511 +lb +, +ub +); + +512 if( +code_g’_debug +) { + +513 + `årštf +( +DebugFže +, "IS%d: " +cÛf_fmt + " <ðt%d <ð" cÛf_fmˆ"\n", +s +, + +514 +lb +, +Ëv– +, +ub +); + +515 +´ojeùed_nIS +[ +Ëv– +][ +s +]. + `´efix_´št +( +DebugFže +); + +517 ià( +lb + !ð +ub +) { + +518 +cÚ¡ªtLev– + = +çl£ +; + +522 + `£t_max +( +fšish +, +lb +); + +523 + `£t_mš +( +¡¬t +, +lb +); + +524 +wh’ +[ +s +] = +lb +; + +529 ià( +cÚ¡ªtLev– + && +fšish +- +¡¬t + <ð +¡mts +) { + +530 +IÁTu¶e + + `ÃwAùive +( +isAùive +. + `size +()); + +531 +i +=1; i<= +¡mts +; i++) + +532 +ÃwAùive +[ +i +] = +isAùive +[i] && +wh’ +[i] =ð +¡¬t +; + +533 +CG_»suÉ + * +r + = +Ãw + + `CG_loÝ +( +isAùive +, +Ëv– +, + +534 + `g’_»cursive +( +Ëv– ++1, +ÃwAùive +)); + +535 +cÛf_t + +time + = +¡¬t ++1;im<ð +fšish +;ime++) { + +536 +couÁ + = 0; + +537 +i +=1; i<= +¡mts +; i++) { + +538 +ÃwAùive +[ +i +] = +isAùive +[i] && +wh’ +[i] =ð +time +; + +539 ià( +ÃwAùive +[ +i +]è +couÁ +++; + +541 ià( +couÁ +) { + +542 +R–©iÚ + + `‹¡_»l +( +‹¡_»l_size +); + +543 +GEQ_HªdË + +g + = +‹¡_»l +. + `ªd_w™h_GEQ +(); + +544 +g +. + `upd©e_cÛf +( +‹¡_»l +. + `£t_v¬ +( +Ëv– +),-1); + +545 +g +. + `upd©e_cÚ¡ +( +time +-1); + +547 +r + = +Ãw + + `CG_¥l™ +( +isAùive +, +Ëv– +, +‹¡_»l +,r, + +548 +Ãw + + `CG_loÝ +( +isAùive +, +Ëv– +, + +549 + `g’_»cursive +( +Ëv– ++1, +ÃwAùive +))); + +552 +r +; + +560 +R–©iÚ + +huÎ + = + `HuÎ +( +´ojeùed_nIS +[ +Ëv– +], +isAùive +,1); + +562 +R–©iÚ + +huÎ + = + `HuÎ +( +´ojeùed_nIS +[ +Ëv– +], +isAùive +,0); + +565 if( +code_g’_debug +) { + +566 + `årštf +( +DebugFže +, "HuÎ (Ëv– %dèis:\n", +Ëv– +); + +567 +huÎ +. + `´efix_´št +( +DebugFže +); + +571 +IÁTu¶e + + `fœ¡Chunk +( +isAùive +); + +572 +IÁTu¶e + + `£cÚdChunk +( +isAùive +); + +579 +boÞ + +checkFÜS¶™s + = +Œue +; + +580 +s + = 1; s <ð +isAùive +. + `size +(); s++){ + +581 ià( +isAùive +[ +s +]) { + +582 if( +s + < +smtNÚS¶™Lev–s +. + `size +(è&& smtNÚS¶™Lev–s[s]. + `šdex +( +Ëv– +-2) != 0){ + +583 +checkFÜS¶™s + = +çl£ +; + +590 +s + = 1; +checkFÜS¶™s + && s <ð +isAùive +. + `size +(); s++) + +591 ià( +isAùive +[ +s +]) { + +592 +R–©iÚ + +gi¡ + = + `Gi¡ +( + `cÝy +( +´ojeùed_nIS +[ +Ëv– +][ +s +]),cÝy( +huÎ +),1); + +593 ià( +gi¡ +. + `is_obvious_utÞogy +()) ; + +594 +gi¡ +. + `sim¶ify +(); + +595 +CÚjunù + * +s_cÚj + = +gi¡ +. + `sšgË_cÚjunù +(); + +596 +GEQ_I‹¿tÜ + + `G +( +s_cÚj +); +G +; G++) { + +597 +R–©iÚ + + `‹¡_»l +( +gi¡ +. + `n_£t +()); + +598 +‹¡_»l +. + `ªd_w™h_GEQ +(* +G +); + +599 +V¬ŸbË_ID + +v + = + `£t_v¬ +( +Ëv– +); + +600 +cÛf_t + +sign + = (* +G +). + `g‘_cÛf +( +v +); + +601 if( +sign + > 0è +‹¡_»l + = + `Com¶em’t +(test_rel); + +602 if( +code_g’_debug +) { + +603 + `årštf +( +DebugFže +, "CÚsid”šg s¶™ from stmˆ%d:\n", +s +); + +604 +‹¡_»l +. + `´efix_´št +( +DebugFže +); + +607 +fœ¡Chunk +[ +s +] = +sign + <= 0; + +608 +£cÚdChunk +[ +s +] = +sign + > 0; + +609 +numb”Fœ¡ + = +sign + <= 0; + +610 +numb”SecÚd + = +sign + > 0; + +612 +s2 + = 1; s2 <ð +isAùive +. + `size +(); s2++) + +613 ià( +isAùive +[ +s2 +] && s2 !ð +s +) { + +614 if( +code_g’_debug +) + +615 + `årštf +( +DebugFže +,"CÚsid” stmˆ%d\n", +s2 +); + +616 +boÞ + +t + = + `IÁ”£ùiÚ +( + `cÝy +( +´ojeùed_nIS +[ +Ëv– +][ +s2 +]), + +617 + `cÝy +( +‹¡_»l +)). + `is_uµ”_bound_§tisfŸbË +(); + +618 +boÞ + +f + = + `Difã»nû +( + `cÝy +( +´ojeùed_nIS +[ +Ëv– +][ +s2 +]), + +619 + `cÝy +( +‹¡_»l +)). + `is_uµ”_bound_§tisfŸbË +(); + +620 + `as£¹ +( +t + || +f +); + +621 if( +code_g’_debug + && +t +&& +f +) + +622 + `årštf +( +DebugFže +, "SÏshe ¡mˆ%d\n", +s2 +); + +623 ià( +t +&& +f +è +ÃxtGEQ +; + +624 if( +code_g’_debug +) { + +625 ià( +t +) + +626 + `årštf +( +DebugFže +, "ŒufÜ stmˆ%d\n", +s2 +); + +628 + `årštf +( +DebugFže +, "çl£ fÜ stmˆ%d\n", +s2 +); + +630 ià( +t +è +numb”Fœ¡ +++; + +631 +numb”SecÚd +++; + +632 +fœ¡Chunk +[ +s2 +] = +t +; + +633 +£cÚdChunk +[ +s2 +] = ! +t +; + +636 + `as£¹ +( +numb”Fœ¡ ++ +numb”SecÚd +>1 && "Can't handle wildcard in iteration space"); + +637 if( +code_g’_debug +) + +638 + `årštf +( +DebugFže +, "%drue, %d false\n", + +639 +numb”Fœ¡ +, + +640 +numb”SecÚd +); + +641 ià( +numb”Fœ¡ + && +numb”SecÚd +) { + +643 +Ãw + + `CG_¥l™ +( +isAùive +, +Ëv– +, +‹¡_»l +, + +644 + `g’_»cursive +( +Ëv– +, +fœ¡Chunk +), + +645 + `g’_»cursive +( +Ëv– +, +£cÚdChunk +)); + +647 +ÃxtGEQ +: ; + +653 +Ãw + + `CG_loÝ +( +isAùive +, +Ëv– +, + `g’_»cursive +(level+1,isActive)); + +654 + } +} + + @output_repr.cc + +16 + ~<omega.h +> + +17 + ~<code_g’/CG_¡ršgBužd”.h +> + +18 + ~<code_g’/ouut_»´.h +> + +19 + ~<basic/omega_”rÜ.h +> + +20 + ~<m©h.h +> + +21 + ~<¡ack +> + +22 + ~<ty³šfo +> + +24 +Çme¥aû + + gomega + { + +26
+Tu¶e +<Tu¶e< +R–©iÚ +> > +´ojeùed_nIS +; + +27 + gv¬_sub¡™utiÚ_th»shÞd + = 100; + +29
+uµ”BoundFÜLev– +; + +30
+low”BoundFÜLev– +; + +31
+boÞ + +fžlInBounds +; + +37 +Çme¥aû + + gomega + { + +39 + g¡d +:: +·œ +< +EQ_HªdË +, > +fšd_sim¶e¡_assignm’t +(cÚ¡ +R–©iÚ + & +R_ +, +V¬ŸbË_ID + +v +, cÚ¡ +¡d +:: +veùÜ +< +CG_ouutR•r + *> & +assigÃd_Ú_the_æy +); + +42 + gÇme¥aû + { + +47 +g‘_¡ride +(cÚ¡ +CÚ¡¿št_HªdË + & +h +, +V¬ŸbË_ID + & +wc +, +cÛf_t + & +¡• +){ + +48 + gwc + = 0; + +49 +CÚ¡r_V¬s_I‹r + +i +( +h +, +Œue +); + gi +; i++) { + +50 +as£¹ +( +wc + == 0); + +51 + gwc + = (* +i +). +v¬ +; + +52 + g¡• + = ((* +i +). +cÛf +); + +58 +CG_ouutR•r +* +ouutId’t +( +CG_ouutBužd” +* +ocg +, cÚ¡ +R–©iÚ + & +R_ +, +V¬ŸbË_ID + +v +, cÚ¡ +¡d +:: +veùÜ +<CG_ouutR•¸*> & +assigÃd_Ú_the_æy +) { + +59 +R–©iÚ + & +R + = +cÚ¡_ÿ¡ +<R–©iÚ &>( +R_ +); + +61 + gv +-> +kšd +()) { + +62 + gS‘_V¬ +: { + +63 +pos + = +v +-> +g‘_pos™iÚ +(); + +64 ià( + gassigÃd_Ú_the_æy +[ +pos +-1] !ð +NULL +) + +65 +assigÃd_Ú_the_æy +[ +pos +-1]-> +þÚe +(); + +67 + gocg +-> +C»©eId’t +( +v +-> +Çme +()); + +70 + gGlob®_V¬ +: { + +71 ià( +v +-> +g‘_glob®_v¬ +()-> +¬™y +() == 0) + +72 +ocg +-> +C»©eId’t +( +v +-> +Çme +()); + +76 + g¬™y + = +v +-> +g‘_glob®_v¬ +()-> +¬™y +(); + +78 + gTu¶e +< + gCG_ouutR•r + *> + g¬gLi¡ +; + +82 + gi + = 1; i <ð +¬™y +; i++) + +83 + g¬gLi¡ +. +³nd +( +ocg +-> +C»©eId’t +( +R +. +£t_v¬ +( +i +)-> +Çme +())); + +84 +CG_ouutR•r + * + gÿÎ + = +ocg +-> +C»©eInvoke +( +v +-> +g‘_glob®_v¬ +()-> +ba£_Çme +(), +¬gLi¡ +); + +85 + gÿÎ +; + +90 +throw + +¡d +:: +šv®id_¬gum’t +("wrong variableype"); + +101 + g¡d +:: +·œ +< +CG_ouutR•r + *, + gboÞ +> +ouutAssignm’t +( +CG_ouutBužd” + * +ocg +, cÚ¡ +R–©iÚ + & +R_ +, +V¬ŸbË_ID + +v +, R–©iÚ & +’fÜûd +, CG_ouutR•¸*& +if_»´ +, cÚ¡ +¡d +:: +veùÜ +<CG_ouutR•¸*> & +assigÃd_Ú_the_æy +) { + +102 +R–©iÚ + & +R + = +cÚ¡_ÿ¡ +<R–©iÚ &>( +R_ +); + +104 +CÚjunù + * + gc + = +R +. +qu”y_DNF +()-> +sšgË_cÚjunù +(); + +107 +EQ_I‹¿tÜ + +ei +( +c +); + gei +;ƒi++) + +108 ià(!(* + gei +). +has_wždÿrds +(è&& +abs +((* +ei +). +g‘_cÛf +( +v +)) > 1) { + +109 +R–©iÚ + +r +( +R +. +n_£t +()); + +110 +F_And + * + gf_su³r_roÙ + = +r +. +add_ªd +(); + +111 +F_Exi¡s + * + gã + = +f_su³r_roÙ +-> +add_exi¡s +(); + +112 +V¬ŸbË_ID + + ge + = +ã +-> +deþ¬e +(); + +113 +F_And + * + gf_roÙ + = +ã +-> +add_ªd +(); + +114 +EQ_HªdË + + gh + = +f_roÙ +-> +add_EQ +(); + +115 +CÚ¡r_V¬s_I‹r + +cvi +(* +ei +); + gcvi +; cvi++) + +116 (* + gcvi +). + gv¬ +-> +kšd +()) { + +117 + gIÅut_V¬ +: { + +118 ià((* +cvi +). +v¬ + =ð +v +) + +119 +h +. +upd©e_cÛf +( +e +, (* +cvi +). +cÛf +); + +121 + gh +. +upd©e_cÛf +( +r +. +£t_v¬ +((* +cvi +). +v¬ +-> +g‘_pos™iÚ +()), (*cvi). +cÛf +); + +124 + gGlob®_V¬ +: { + +125 +Glob®_V¬_ID + +g + = (* +cvi +). +v¬ +-> +g‘_glob®_v¬ +(); + +126 +V¬ŸbË_ID + + gv2 +; + +127 ià( + gg +-> +¬™y +() == 0) + +128 +v2 + = +r +. +g‘_loÿl +( +g +); + +130 + gv2 + = +r +. +g‘_loÿl +( +g +, (* +cvi +). +v¬ +-> +funùiÚ_of +()); + +131 + gh +. +upd©e_cÛf +( +v2 +, (* +cvi +). +cÛf +); + +135 +as£¹ +(0); + +137 + gh +. +upd©e_cÚ¡ +((* +ei +). +g‘_cÚ¡ +()); + +139 + gr +. +cÝy_Çmes +( +R +); + +140 + gr +. +£tup_Çmes +(); + +143 ià(! +Gi¡ +( +r +, +cÝy +( +’fÜûd +), 1). +is_obvious_utÞogy +()) { + +144 +cÛf_t + + gcÛf + = (* +ei +). +g‘_cÛf +( +v +); + +145 +cÛf_t + + gsign + = -(( +cÛf +>0)?1:-1); + +146 + gcÛf + = +abs +( +cÛf +); + +148 +CG_ouutR•r + * + g‹rm + = +NULL +; + +149 +CÚ¡r_V¬s_I‹r + +cvi +(* +ei +); + gcvi +; cvi++) + +150 ià((* + gcvi +). + gv¬ + !ð +v +) { + +151 +CG_ouutR•r + * +v¬R•r + = +ouutId’t +( +ocg +, +R +, (* +cvi +). +v¬ +, +assigÃd_Ú_the_æy +); + +152 +cÛf_t + + gt + = +sign +*(* +cvi +). +cÛf +; + +153 ià( + gt + == 1) + +154 +‹rm + = +ocg +-> +C»©ePlus +Ñ”m, +v¬R•r +); + +155 ià( + gt + == -1) + +156 +‹rm + = +ocg +-> +C»©eMšus +Ñ”m, +v¬R•r +); + +157 ià( + gt + > 0) + +158 + g‹rm + = +ocg +-> +C»©ePlus +( +‹rm +, ocg-> +C»©eTimes +(ocg-> +C»©eIÁ +( +t +), +v¬R•r +)); + +159 ià( + gt + < 0) + +160 + g‹rm + = +ocg +-> +C»©eMšus +( +‹rm +, ocg-> +C»©eTimes +(ocg-> +C»©eIÁ +(- +t +), +v¬R•r +)); + +162 +cÛf_t + + gt + = +sign +*(* +ei +). +g‘_cÚ¡ +(); + +163 ià( + gt + > 0) + +164 + g‹rm + = +ocg +-> +C»©ePlus +( +‹rm +, ocg-> +C»©eIÁ +( +t +)); + +165 ià( + gt + < 0) + +166 + g‹rm + = +ocg +-> +C»©eMšus +( +‹rm +, ocg-> +C»©eIÁ +(- +t +)); + +168 + g‹rm + = +ocg +-> +C»©eIÁeg”Mod +( +‹rm +, ocg-> +C»©eIÁ +( +cÛf +)); + +169 + g‹rm + = +ocg +-> +C»©eEQ +( +‹rm +, ocg-> +C»©eIÁ +(0)); + +171 + gif_»´ + = +ocg +-> +C»©eAnd +( +if_»´ +, +‹rm +); + +174 + g’fÜûd +. +ªd_w™h_EQ +(* +ei +); + +175 + g’fÜûd +. +sim¶ify +(); + +179 + g¡d +:: +·œ +< +EQ_HªdË +, > + ga + = +fšd_sim¶e¡_assignm’t +( +R +, +v +, +assigÃd_Ú_the_æy +); + +182 ià( + ga +. + g£cÚd + < + gINT_MAX +) { + +183 +EQ_HªdË + + geq + = +a +. +fœ¡ +; + +184 +CG_ouutR•r + * + grÝ_»´ + = +NULL +; + +186 +cÛf_t + + gdivid” + = +eq +. +g‘_cÛf +( +v +); + +187 + gsign + = 1; + +188 ià( + gdivid” + < 0) { + +189 + gdivid” + = - +divid” +; + +190 + gsign + = -1; + +193 +CÚ¡r_V¬s_I‹r + +cvi +( +eq +); + gcvi +; cvi++) + +194 ià((* + gcvi +). + gv¬ + !ð +v +) { + +195 +CG_ouutR•r + * +v¬_»´ + = +ouutId’t +( +ocg +, +R +, (* +cvi +). +v¬ +, +assigÃd_Ú_the_æy +); + +196 +cÛf_t + + gcÛf + = (* +cvi +). +cÛf +; + +197 ià(- +sign + * + gcÛf + == -1) + +198 +rÝ_»´ + = +ocg +-> +C»©eMšus +ÔÝ_»´, +v¬_»´ +); + +199 ià(- +sign + * + gcÛf + < -1) + +200 + grÝ_»´ + = +ocg +-> +C»©eMšus +( +rÝ_»´ +, ocg-> +C»©eTimes +(ocg-> +C»©eIÁ +( +sign + * +cÛf +), +v¬_»´ +)); + +201 ià(- +sign + * + gcÛf + == 1) + +202 +rÝ_»´ + = +ocg +-> +C»©ePlus +ÔÝ_»´, +v¬_»´ +); + +204 + grÝ_»´ + = +ocg +-> +C»©ePlus +( +rÝ_»´ +, ocg-> +C»©eTimes +(ocg-> +C»©eIÁ +(- +sign + * +cÛf +), +v¬_»´ +)); + +207 +cÛf_t + + gc_‹rm + = -( +eq +. +g‘_cÚ¡ +(è* +sign +); + +209 ià( + gc_‹rm + > 0) + +210 + grÝ_»´ + = +ocg +-> +C»©ePlus +( +rÝ_»´ +, ocg-> +C»©eIÁ +( +c_‹rm +)); + +211 ià( + gc_‹rm + < 0) + +212 + grÝ_»´ + = +ocg +-> +C»©eMšus +( +rÝ_»´ +, ocg-> +C»©eIÁ +(- +c_‹rm +)); + +213 ià( + grÝ_»´ + =ð +NULL +) + +214 +rÝ_»´ + = +ocg +-> +C»©eIÁ +(0); + +216 ià( + gdivid” + != 1) + +217 +rÝ_»´ + = +ocg +-> +C»©eIÁeg”Divide +ÔÝ_»´, ocg-> +C»©eIÁ +( +divid” +)); + +219 + g’fÜûd +. +ªd_w™h_EQ +( +eq +); + +220 + g’fÜûd +. +sim¶ify +(); + +222 ià( + ga +. + g£cÚd + > + gv¬_sub¡™utiÚ_th»shÞd +) + +223 + g¡d +:: +make_·œ +( +rÝ_»´ +, +Œue +); + +225 + g¡d +:: +make_·œ +( +rÝ_»´ +, +çl£ +); + +228 + g¡d +:: +make_·œ +( +¡©ic_ÿ¡ +< +CG_ouutR•r + *>( +NULL +), +çl£ +); + +237 + gTu¶e +< + gCG_ouutR•r +*> +ouutSub¡™utiÚ +( +CG_ouutBužd” +* +ocg +, cÚ¡ +R–©iÚ + & +R_ +, cÚ¡ +¡d +:: +veùÜ +< +CG_ouutR•r + *> & +assigÃd_Ú_the_æy +) { + +238 +R–©iÚ + & +R + = +cÚ¡_ÿ¡ +<R–©iÚ &>( +R_ +); + +240 cÚ¡ + gn + = +R +. +n_out +(); + +241 + gTu¶e +< + gCG_ouutR•r +*> + goR•rLi¡ +; + +244 + gi + = 1; i <ð +n +; i++) { + +245 +R–©iÚ + +mpšg +( +n +, 1); + +246 +F_And + * + gf_roÙ + = +mpšg +. +add_ªd +(); + +247 +EQ_HªdË + + gh + = +f_roÙ +-> +add_EQ +(); + +248 + gh +. +upd©e_cÛf +( +mpšg +. +ouut_v¬ +(1), 1); + +249 + gh +. +upd©e_cÛf +( +mpšg +. +šput_v¬ +( +i +), -1); + +251 +R–©iÚ + + gS + = +Compos™iÚ +( +mpšg +, +cÝy +( +R +)); + +253 + g¡d +:: +·œ +< +EQ_HªdË +, > + ga + = +fšd_sim¶e¡_assignm’t +( +S +, S. +ouut_v¬ +(1), +assigÃd_Ú_the_æy +); + +255 ià( + ga +. + g£cÚd + < + gINT_MAX +) { + +256 + ga +. + g£cÚd + > 0) { + +257 +EQ_HªdË + + geq + = +a +. +fœ¡ +; + +258 + g¡d +:: +£t +<> +ÿndid©es +; + +259 +CÚ¡r_V¬s_I‹r + +cvi +( +eq +); + gcvi +; cvi++) + +260 ià((* + gcvi +). + gv¬ +-> +kšd +(è=ð +IÅut_V¬ +) + +261 +ÿndid©es +. +š£¹ +((* +cvi +). +v¬ +-> +g‘_pos™iÚ +()); + +263 +boÞ + + gchªged + = +çl£ +; + +264 + g¡d +:: +£t +<>:: +™”©Ü + +j + = +ÿndid©es +. +begš +(); + gj + !ðÿndid©es. +’d +(); j++) { + +265 +R–©iÚ + + gS2 + = +Projeù +( +cÝy +( +S +), * +j +, +IÅut_V¬ +); + +266 + g¡d +:: +·œ +< +EQ_HªdË +, > + ga2 + = +fšd_sim¶e¡_assignm’t +( +S2 +, S2. +ouut_v¬ +(1), +assigÃd_Ú_the_æy +); + +267 ià( + ga2 +. + g£cÚd + <ð +a +. +£cÚd +) { + +268 +S + = +S2 +; + +269 + ga + = +a2 +; + +270 + gchªged + = +Œue +; + +274 ià(! + gchªged +) + +279 ià( + ga +. + g£cÚd + < + gINT_MAX +) { + +280 +CG_ouutR•r + * + g»´ + = +NULL +; + +281 +EQ_HªdË + + geq + = +a +. +fœ¡ +; + +282 +V¬ŸbË_ID + + gv + = +S +. +ouut_v¬ +(1); + +284 + gj + = 1; j <ð +S +. +n_šp +(); j++) + +285 + gS +. +Çme_šput_v¬ +( +j +, +R +. +šput_v¬ +(j)-> +Çme +()); + +286 + gS +. +£tup_Çmes +(); + +288 + gd + = +eq +. +g‘_cÛf +( +v +); + +289 +as£¹ +( +d + != 0); + +290 + gsign + = ( +d +>0)?-1:1; + +291 + gd + = - +sign + * +d +; + +292 +CÚ¡r_V¬s_I‹r + +cvi +( +eq +); + gcvi +; cvi++) + +293 ià((* + gcvi +). + gv¬ + !ð +v +) { + +294 +cÛf + = +sign + * (* +cvi +).coef; + +295 +CG_ouutR•r + * + gÝ + = +ouutId’t +( +ocg +, +S +, (* +cvi +). +v¬ +, +assigÃd_Ú_the_æy +); + +296 ià( + gcÛf + > 1) + +297 + gÝ + = +ocg +-> +C»©eTimes +(ocg-> +C»©eIÁ +( +cÛf +), +Ý +); + +298 ià( + gcÛf + < -1) + +299 + gÝ + = +ocg +-> +C»©eTimes +(ocg-> +C»©eIÁ +(- +cÛf +), +Ý +); + +300 ià( + gcÛf + > 0) + +301 + g»´ + = +ocg +-> +C»©ePlus +( +»´ +, +Ý +); + +302 ià( + gcÛf + < 0) + +303 + g»´ + = +ocg +-> +C»©eMšus +( +»´ +, +Ý +); + +306 + gc + = +sign + * +eq +. +g‘_cÚ¡ +(); + +307 ià( + gc + > 0) + +308 + g»´ + = +ocg +-> +C»©ePlus +( +»´ +, ocg-> +C»©eIÁ +( +c +)); + +309 ià( + gc + < 0) + +310 + g»´ + = +ocg +-> +C»©eMšus +( +»´ +, ocg-> +C»©eIÁ +(- +c +)); + +311 ià( + g»´ + =ð +NULL +) + +312 +»´ + = +ocg +-> +C»©eIÁ +(0); + +314 ià( + gd + != 1) + +315 +»´ + = +ocg +-> +C»©eIÁeg”Divide +Ô•r, ocg-> +C»©eIÁ +( +d +)); + +317 + goR•rLi¡ +. +³nd +( +»´ +); + +320 + goR•rLi¡ +. +³nd +( +NULL +); + +323 + goR•rLi¡ +; + +326 + gÇme¥aû + { + +328 +R–©iÚ + +ü—‹_¡ride_Ú_bound +( +n +, cÚ¡ +¡d +:: +m +< +V¬ŸbË_ID +, +cÛf_t +> & +lb +, cÛf_ˆ +¡ride +) { + +329 +R–©iÚ + +»suÉ +( +n +); + +330 +F_And + * + gf_roÙ + = +»suÉ +. +add_ªd +(); + +331 +EQ_HªdË + + gh + = +f_roÙ +-> +add_¡ride +( +¡ride +); + +333 + g¡d +:: +m +< +V¬ŸbË_ID +, + gcÛf_t +>:: +cÚ¡_™”©Ü + +i + = +lb +. +begš +(); + gi + !ðlb. +’d +(); i++) { + +334 ià( + gi +-> + gfœ¡ + =ð +NULL +) + +335 +h +. +upd©e_cÚ¡ +( +i +-> +£cÚd +); + +337 + gi +-> + gfœ¡ +-> +kšd +()) { + +338 + gIÅut_V¬ +: { + +339 +pos + = +i +-> +fœ¡ +-> +g‘_pos™iÚ +(); + +340 + gh +. +upd©e_cÛf +( +»suÉ +. +£t_v¬ +( +pos +), +i +-> +£cÚd +); + +343 + gGlob®_V¬ +: { + +344 +Glob®_V¬_ID + +g + = +i +-> +fœ¡ +-> +g‘_glob®_v¬ +(); + +345 +V¬ŸbË_ID + + gv +; + +346 ià( + gg +-> +¬™y +() == 0) + +347 +v + = +»suÉ +. +g‘_loÿl +( +g +); + +349 + gv + = +»suÉ +. +g‘_loÿl +( +g +, +i +-> +fœ¡ +-> +funùiÚ_of +()); + +350 + gh +. +upd©e_cÛf +( +v +, +i +-> +£cÚd +); + +354 +as£¹ +(0); + +359 + g»suÉ +; + +368 +R–©iÚ + +g»©e¡_commÚ_¡• +(cÚ¡ +Tu¶e +<R–©iÚ> & +I +, cÚ¡ Tu¶e<> & +aùive +, +Ëv– +, cÚ¡ R–©iÚ & +known +) { + +369 +as£¹ +( +I +. +size +(è=ð +aùive +.size()); + +370 + gn + = 0; + +372 + g¡d +:: +veùÜ +< +R–©iÚ +> +I1 +, + gI2 +; + +373 + gi + = 1; i <ð +I +. +size +(); i++) + +374 ià( + gaùive +[ +i +]) { + +375 ià( + gn + == 0) + +376 +n + = +I +[ +i +]. +n_£t +(); + +378 +R–©iÚ + + gr1 +; + +379 ià( + gknown +. +is_nuÎ +()) + +380 + gr1 + = +cÝy +( +I +[ +i +]); + +382 + gr1 + = +IÁ”£ùiÚ +( +cÝy +( +I +[ +i +]), cÝy( +known +)); + +383 + gr1 +. +sim¶ify +(); + +385 + gI1 +. +push_back +( +r1 +); + +386 +R–©iÚ + + gr2 + = +Gi¡ +( +cÝy +( +I +[ +i +]), cÝy( +known +)); + +387 +as£¹ +( +r2 +. +is_uµ”_bound_§tisfŸbË +()); + +388 ià( + gr2 +. +is_obvious_utÞogy +()) + +389 + gR–©iÚ +:: +True +( +n +); + +390 + gI2 +. +push_back +( +r2 +); + +393 + g¡d +:: +veùÜ +< +boÞ +> +is_exaù +( +I2 +. +size +(), +Œue +); + +394 + g¡d +:: +veùÜ +< +cÛf_t +> +¡• +( +I2 +. +size +(), 0); + +395 + g¡d +:: +veùÜ +< +cÛf_t +> +messy_¡• +( +I2 +. +size +(), 0); + +396 +V¬ŸbË_ID + + gt_cÞ + = +£t_v¬ +( +Ëv– +); + +397 + g¡d +:: +m +< +V¬ŸbË_ID +, + gcÛf_t +> + glb +; + +400 +size_t + + gi + = 0; i < + gI2 +. +size +(); i++) { + +401 +CÚjunù + * + gc + = +I2 +[ +i +]. +qu”y_DNF +()-> +sšgË_cÚjunù +(); + +403 +boÞ + + gis_deg’”©ed + = +çl£ +; + +404 +EQ_I‹¿tÜ + + ge + = +c +-> +EQs +();ƒ;ƒ++) { + +405 +cÛf_t + + gcÛf + = +abs +((* +e +). +g‘_cÛf +( +t_cÞ +)); + +406 ià( + gcÛf + !ð0 && !(* +e +). +has_wždÿrds +()) { + +407 +is_deg’”©ed + = +Œue +; + +411 ià( + gis_deg’”©ed +) + +414 +EQ_I‹¿tÜ + + ge + = +c +-> +EQs +();ƒ;ƒ++) { + +415 ià((* + ge +). +has_wždÿrds +()) { + +416 +cÛf_t + + gcÛf + = +abs +((* +e +). +g‘_cÛf +( +t_cÞ +)); + +417 ià( + gcÛf + == 0) + +419 ià( + gcÛf + != 1) { + +420 +is_exaù +[ +i +] = +çl£ +; + +424 +cÛf_t + + gthis_¡• + = +abs +( +CÚ¡r_V¬s_I‹r +(* +e +, +Œue +). +cu¼_cÛf +()); + +425 +as£¹ +( +this_¡• + != 1); + +427 ià( + glb +. +size +() != 0) { + +428 +R–©iÚ + +‹¡ + = +ü—‹_¡ride_Ú_bound +( +n +, +lb +, +this_¡• +); + +429 ià( +Gi¡ +( +‹¡ +, +cÝy +( +I1 +[ +i +])). +is_obvious_utÞogy +()) { + +430 ià( + g¡• +[ +i +] == 0) + +431 +¡• +[ +i +] = +this_¡• +; + +433 + g¡• +[ +i +] = +lcm +( +¡• +[i], +this_¡• +); + +436 + gis_exaù +[ +i +] = +çl£ +; + +440 +CÚjunù + * + gc + = +I2 +[ +i +]. +qu”y_DNF +()-> +sšgË_cÚjunù +(); + +441 +GEQ_I‹¿tÜ + + gge + = +c +-> +GEQs +(); ge; ge++) { + +442 ià((* + gge +). +has_wždÿrds +(è|| (*ge). +g‘_cÛf +( +t_cÞ +) != 1) + +445 + g¡d +:: +m +< +V¬ŸbË_ID +, + gcÛf_t +> + gcur_lb +; + +446 +CÚ¡r_V¬s_I‹r + +cv +(* +ge +); + gcv +; cv++) + +447 + gcur_lb +[ +cv +. +cu¼_v¬ +()] = cv. +cu¼_cÛf +(); + +448 + gcur_lb +[ +NULL +] = (* +ge +). +g‘_cÚ¡ +(); + +450 +R–©iÚ + + g‹¡ + = +ü—‹_¡ride_Ú_bound +( +n +, +cur_lb +, +this_¡• +); + +451 ià( +Gi¡ +( +‹¡ +, +cÝy +( +I1 +[ +i +])). +is_obvious_utÞogy +()) { + +452 ià( + g¡• +[ +i +] == 0) + +453 +¡• +[ +i +] = +this_¡• +; + +455 + g¡• +[ +i +] = +lcm +( +¡• +[i], +this_¡• +); + +457 + glb + = +cur_lb +; + +463 ià( + glb +. +size +() == 0) { + +464 +¡d +:: +m +< +V¬ŸbË_ID +, +cÛf_t +> +cur_lb +; + +465 + gwžd_couÁ + = 0; + +466 +CÚ¡r_V¬s_I‹r + +cv +(* +e +); + gcv +; cv++) + +467 ià( + gcv +. +cu¼_v¬ +()-> +kšd +(è=ð +Wždÿrd_V¬ +) + +468 +wžd_couÁ +++; + +470 + gcur_lb +[ +cv +. +cu¼_v¬ +()] = cv. +cu¼_cÛf +(); + +471 + gcur_lb +[ +NULL +] = (* +e +). +g‘_cÚ¡ +(); + +473 ià( + gwžd_couÁ + == 1) { + +474 +lb + = +cur_lb +; + +475 ià( + g¡• +[ +i +] == 0) + +476 +¡• +[ +i +] = +this_¡• +; + +478 + g¡• +[ +i +] = +lcm +( +¡• +[i], +this_¡• +); + +482 ià( + glb +. +size +() == 0) + +483 +is_exaù +[ +i +] = +çl£ +; + +490 +cÛf_t + + gglob®_¡• + = 0; + +491 +size_t + + gi + = 0; i < + gis_exaù +. +size +(); i++) + +492 ià( + gis_exaù +[ +i +]) + +493 + gglob®_¡• + = +gcd +( +glob®_¡• +, +¡• +[ +i +]); + +494 ià( + gglob®_¡• + == 1) + +495 +R–©iÚ +:: +True +( +n +); + +498 +size_t + + gi + = 0; i < + gI2 +. +size +(); i++) + +499 ià(! + gis_exaù +[ +i +]) { + +500 +CÚjunù + * + gc + = +I2 +[ +i +]. +qu”y_DNF +()-> +sšgË_cÚjunù +(); + +501 +EQ_I‹¿tÜ + + ge + = +c +-> +EQs +();ƒ;ƒ++) { + +502 +cÛf_t + + gcÛf + = +abs +((* +e +). +g‘_cÛf +( +t_cÞ +)); + +503 ià( + gcÛf + =ð0 || +cÛf + == 1) + +507 +cÛf_t + + gthis_¡• + = +abs +( +CÚ¡r_V¬s_I‹r +(* +e +, +Œue +). +cu¼_cÛf +()); + +508 + gthis_¡• + /ð +gcd +( +this_¡• +, +cÛf +); + +509 + gthis_¡• + = +gcd +( +glob®_¡• +, +this_¡• +); + +510 ià( + gthis_¡• + == 1) + +513 ià( + glb +. +size +() != 0) { + +514 +R–©iÚ + +‹¡ + = +ü—‹_¡ride_Ú_bound +( +n +, +lb +, +this_¡• +); + +515 ià( +Gi¡ +( +‹¡ +, +cÝy +( +I1 +[ +i +])). +is_obvious_utÞogy +()) { + +516 ià( + g¡• +[ +i +] == 0) + +517 +¡• +[ +i +] = +this_¡• +; + +519 + g¡• +[ +i +] = +lcm +( +¡• +[i], +this_¡• +); + +524 +CÚjunù + * + gc + = +I2 +[ +i +]. +qu”y_DNF +()-> +sšgË_cÚjunù +(); + +525 +GEQ_I‹¿tÜ + + gge + = +c +-> +GEQs +(); ge; ge++) { + +526 ià((* + gge +). +has_wždÿrds +(è|| (*ge). +g‘_cÛf +( +t_cÞ +) != 1) + +529 + g¡d +:: +m +< +V¬ŸbË_ID +, + gcÛf_t +> + gcur_lb +; + +531 +CÚ¡r_V¬s_I‹r + +cv +(* +ge +); + gcv +; cv++) + +532 + gcur_lb +[ +cv +. +cu¼_v¬ +()] = cv. +cu¼_cÛf +(); + +534 + gcur_lb +[ +NULL +] = (* +ge +). +g‘_cÚ¡ +(); + +536 +R–©iÚ + + g‹¡ + = +ü—‹_¡ride_Ú_bound +( +n +, +cur_lb +, +this_¡• +); + +537 ià( +Gi¡ +( +‹¡ +, +cÝy +( +I1 +[ +i +])). +is_obvious_utÞogy +()) { + +538 ià( + g¡• +[ +i +] == 0) + +539 +¡• +[ +i +] = +this_¡• +; + +541 + g¡• +[ +i +] = +lcm +( +¡• +[i], +this_¡• +); + +543 + glb + = +cur_lb +; + +552 +size_t + + gi + = 0; i < + gis_exaù +. +size +(); i++) + +553 ià(! + gis_exaù +[ +i +]) + +554 + gglob®_¡• + = +gcd +( +glob®_¡• +, +¡• +[ +i +]); + +555 ià( + gglob®_¡• + =ð1 || +glob®_¡• + == 0) + +556 +R–©iÚ +:: +True +( +n +); + +558 +R–©iÚ + + g»suÉ + = +ü—‹_¡ride_Ú_bound +( +n +, +lb +, +glob®_¡• +); + +561 +size_t + + gi + = 0; i < + gI1 +. +size +(); i++) + +562 ià( + g¡• +[ +i +] == 0) { + +563 ià(! +Gi¡ +( +cÝy +( +»suÉ +), cÝy( +I1 +[ +i +])). +is_obvious_utÞogy +()) + +564 +R–©iÚ +:: +True +( +n +); + +567 + g»suÉ +; + +574 +CG_ouutR•r +* +ouutS‹m’t +( +CG_ouutBužd” + * +ocg +, CG_ouutR•¸* +¡mt +, +šd’t +, cÚ¡ +R–©iÚ + & +mpšg_ +, cÚ¡ R–©iÚ & +known_ +, cÚ¡ +¡d +:: +veùÜ +<CG_ouutR•¸*> & +assigÃd_Ú_the_æy +) { + +575 +R–©iÚ + +mpšg + = +cÝy +( +mpšg_ +); + +576 +R–©iÚ + + gknown + = +cÝy +( +known_ +); + +577 + gTu¶e +< + g¡d +:: +¡ršg +> +loÝ_v¬s +; + +579 + gi + = 1; i <ð +mpšg +. +n_šp +(); i++) + +580 + gloÝ_v¬s +. +³nd +( +mpšg +. +šput_v¬ +( +i +)-> +Çme +()); + +583 ià( + gknown +. +n_£t +(è> + gmpšg +. +n_out +()) { + +584 +R–©iÚ + +r +( +known +. +n_£t +(), +mpšg +. +n_out +()); + +585 +F_And + * + gf_roÙ + = +r +. +add_ªd +(); + +586 + gi + = 1; i <ð +mpšg +. +n_out +(); i++) { + +587 +EQ_HªdË + + gh + = +f_roÙ +-> +add_EQ +(); + +588 + gh +. +upd©e_cÛf +( +r +. +šput_v¬ +( +i +), 1); + +589 + gh +. +upd©e_cÛf +( +r +. +ouut_v¬ +( +i +), -1); + +591 + gknown + = +Rªge +( +Re¡riù_Domaš +( +r +, +known +)); + +592 + gknown +. +sim¶ify +(); + +596 +R–©iÚ + +k +( +known +. +n_£t +()); + +597 +F_And + * + gf_roÙ + = +k +. +add_ªd +(); + +598 +CÚjunù + * + gc + = +known +. +qu”y_DNF +()-> +sšgË_cÚjunù +(); + +599 +EQ_I‹¿tÜ + + ge + = +c +-> +EQs +();ƒ;ƒ++) { + +600 ià(!(* + ge +). +has_wždÿrds +()) + +601 + gf_roÙ +-> +add_EQ +(* +e +); + +603 + gk +. +sim¶ify +(); + +606 +R–©iÚ + + gInv_mpšg + = +Re¡riù_Domaš +( +Inv”£ +( +mpšg +), +k +); + +607 + gTu¶e +< + gCG_ouutR•r +*> + gsLi¡ + = +ouutSub¡™utiÚ +( +ocg +, +Inv_mpšg +, +assigÃd_Ú_the_æy +); + +609 + gocg +-> +C»©ePÏûHÞd” +( +šd’t +, +¡mt +, +sLi¡ +, +loÝ_v¬s +); + +614 +boÞ + +fšdFloÜIÃqu®™y +( +R–©iÚ + & +r +, +V¬ŸbË_ID + +v +, +GEQ_HªdË + & +h +, V¬ŸbË_ID +exþuded +) { + +615 +CÚjunù + * + gc + = +r +. +sšgË_cÚjunù +(); + +617 + g¡d +:: +£t +< +V¬ŸbË_ID +> +v¬_checked +; + +618 + g¡d +:: +¡ack +< +V¬ŸbË_ID +> +v¬_checkšg +; + +619 + gv¬_checkšg +. +push +( +v +); + +621 ! + gv¬_checkšg +. +em±y +()) { + +622 +V¬ŸbË_ID + + gv2 + = +v¬_checkšg +. +tÝ +(); + +623 + gv¬_checkšg +. +pÝ +(); + +625 +boÞ + + gis_æoÜ + = +çl£ +; + +626 +GEQ_I‹¿tÜ + +gi +( +c +); + ggi +; gi++) { + +627 ià( + gexþuded + !ð +NULL + && (* +gi +). +g‘_cÛf +( +exþuded +) != 0) + +630 +cÛf_t + + ga + = (* +gi +). +g‘_cÛf +( +v2 +); + +631 ià( + ga + < 0) { + +632 +GEQ_I‹¿tÜ + +gi2 +( +c +); + ggi2 +; gi2++) { + +633 +cÛf_t + + gb + = (* +gi2 +). +g‘_cÛf +( +v2 +); + +634 ià( + gb + =ð- +a + && (* +gi +). +g‘_cÚ¡ +()+(* +gi2 +).get_const() < -a) { + +635 +boÞ + +m©ch + = +Œue +; + +636 +CÚ¡r_V¬s_I‹r + +cvi +(* +gi +); + gcvi +; cvi++) + +637 ià((* + ggi2 +). +g‘_cÛf +((* +cvi +). +v¬ +è!ð-(*cvi). +cÛf +) { + +638 +m©ch + = +çl£ +; + +641 ià(! + gm©ch +) + +643 +CÚ¡r_V¬s_I‹r + +cvi +(* +gi2 +); + gcvi +; cvi++) + +644 ià((* + ggi +). +g‘_cÛf +((* +cvi +). +v¬ +è!ð-(*cvi). +cÛf +) { + +645 +m©ch + = +çl£ +; + +648 ià( + gm©ch +) { + +649 + gv¬_checked +. +š£¹ +( +v2 +); + +650 + gis_æoÜ + = +Œue +; + +651 ià( + gv + =ð +v2 +) + +652 +h + = * +gi +; + +654 +CÚ¡r_V¬s_I‹r + +cvi +(* +gi +); + gcvi +; cvi++) + +655 ià(((* + gcvi +). + gv¬ +-> +kšd +(è=ð +Exi¡s_V¬ + || (* +cvi +). +v¬ +->kšd(è=ð +Wždÿrd_V¬ +) && + +656 +v¬_checked +. +fšd +((* +cvi +). +v¬ +è=ðv¬_checked. +’d +()) + +657 +v¬_checkšg +. +push +((* +cvi +). +v¬ +); + +663 ià( + gis_æoÜ +) + +667 ià(! + gis_æoÜ +) + +668 + gçl£ +; + +670 + gŒue +; + +680 +CG_ouutR•r +* +ouut_as_gu¬d +( +CG_ouutBužd” +* +ocg +, cÚ¡ +R–©iÚ + & +gu¬ds_š +, +CÚ¡¿št_HªdË + +e +, +boÞ + +is_equ®™y +, cÚ¡ +¡d +:: +veùÜ +<CG_ouutR•¸*> & +assigÃd_Ú_the_æy +) { + +681 +R–©iÚ + & +gu¬ds + = +cÚ¡_ÿ¡ +<R–©iÚ &>( +gu¬ds_š +); + +682 ià( + ge +. +has_wždÿrds +()) + +683 +throw + + g¡d +:: +šv®id_¬gum’t +("constraint must‚ot have wildcard"); + +685 +V¬ŸbË_ID + + gv + = (* +CÚ¡r_V¬s_I‹r +( +e +)). +v¬ +; + +687 +cÛf_t + + g§ved_cÛf + = (( +e +). +g‘_cÛf +( +v +)); + +688 + gsign + = +§ved_cÛf + < 0 ? -1 : 1; + +690 ( + ge +). +upd©e_cÛf_duršg_sim¶ify +( +v +, - +§ved_cÛf ++ +sign +); + +691 +CG_ouutR•r +* + grÝ + = +ouutEasyBoundAsR•r +( +ocg +, +gu¬ds +, +e +, +v +, +çl£ +, 0, +assigÃd_Ú_the_æy +); + +692 ( + ge +). +upd©e_cÛf_duršg_sim¶ify +( +v +, +§ved_cÛf +- +sign +); + +694 +CG_ouutR•r +* + glÝ + = +ouutId’t +( +ocg +, +gu¬ds +, +v +, +assigÃd_Ú_the_æy +); + +695 ià( +abs +( +§ved_cÛf +) != 1) + +696 +lÝ + = +ocg +-> +C»©eTimes +(ocg-> +C»©eIÁ +( +abs +( +§ved_cÛf +)),†op); + +699 ià( + gis_equ®™y +) { + +700 + gocg +-> +C»©eEQ +( +lÝ +, +rÝ +); + +703 ià( + g§ved_cÛf + < 0) + +704 + gocg +-> +C»©eLE +( +lÝ +, +rÝ +); + +706 + gocg +-> +C»©eGE +( +lÝ +, +rÝ +); + +715 +CG_ouutR•r + * +ouut_EQ_¡rides +( +CG_ouutBužd” +* +ocg +, cÚ¡ +R–©iÚ + & +gu¬ds_š +, cÚ¡ +¡d +:: +veùÜ +<CG_ouutR•¸*> & +assigÃd_Ú_the_æy +) { + +716 +R–©iÚ + +gu¬ds + = +cÚ¡_ÿ¡ +<R–©iÚ &>( +gu¬ds_š +); + +717 +CÚjunù + * + gc + = +gu¬ds +. +sšgË_cÚjunù +(); + +719 +CG_ouutR•r + * + geqR•r + = +NULL +; + +721 +EQ_I‹¿tÜ + +ei +( +c +-> +EQs +()); + gei +;ƒi++) { + +722 +V¬ŸbË_ID + + gwc + = +NULL +; + +723 +CÚ¡r_V¬s_I‹r + +cvi +((* +ei +), +Œue +); + gcvi +; cvi++) { + +724 ià( + gwc + !ð +NULL +) + +725 +throw + +codeg’_”rÜ +("Can't generateƒquality condition with multiple wildcards"); + +727 + gwc + = (* +cvi +). +v¬ +; + +729 ià( + gwc + =ð +NULL +) + +732 +cÛf_t + + g¡• + = (* +ei +). +g‘_cÛf +( +wc +); + +734 (* + gei +). +upd©e_cÛf_duršg_sim¶ify +( +wc +, 1- +¡• +); + +735 +CG_ouutR•r +* + glÝ + = +ouutEasyBoundAsR•r +( +ocg +, +gu¬ds +, (* +ei +), +wc +, +çl£ +, 0, +assigÃd_Ú_the_æy +); + +736 (* + gei +). +upd©e_cÛf_duršg_sim¶ify +( +wc +, +¡• +-1); + +738 +CG_ouutR•r +* + grÝ + = +ocg +-> +C»©eIÁ +( +abs +( +¡• +)); + +739 +CG_ouutR•r +* + gštMod + = +ocg +-> +C»©eIÁeg”Mod +( +lÝ +, +rÝ +); + +740 +CG_ouutR•r +* + geqNode + = +ocg +-> +C»©eEQ +( +štMod +, ocg-> +C»©eIÁ +(0)); + +742 + geqR•r + = +ocg +-> +C»©eAnd +( +eqR•r +, +eqNode +); + +745 + geqR•r +; + +759 +CG_ouutR•r + * +ouut_GEQ_¡rides +( +CG_ouutBužd” +* +ocg +, cÚ¡ +R–©iÚ + & +gu¬ds_š +, cÚ¡ +¡d +:: +veùÜ +<CG_ouutR•¸*> & +assigÃd_Ú_the_æy +) { + +760 +R–©iÚ + +gu¬ds + = +cÚ¡_ÿ¡ +<R–©iÚ &>( +gu¬ds_š +); + +761 +CÚjunù + * + gc + = +gu¬ds +. +sšgË_cÚjunù +(); + +763 +CG_ouutR•r +* + ggeqR•r + = +NULL +; + +765 + g¡d +:: +£t +< +V¬ŸbË_ID +> +nÚ_Üphª_wždÿrd +; + +766 +GEQ_I‹¿tÜ + +gi +( +c +); + ggi +; gi++) { + +767 + gnum_wžd + = 0; + +768 +V¬ŸbË_ID + + gfœ¡_Úe +; + +769 +CÚ¡r_V¬s_I‹r + +cvi +(* +gi +, +Œue +); + gcvi +; cvi++) { + +770 + gnum_wžd +++; + +771 ià( + gnum_wžd + == 1) + +772 +fœ¡_Úe + = (* +cvi +). +v¬ +; + +774 + gnÚ_Üphª_wždÿrd +. +š£¹ +((* +cvi +). +v¬ +); + +776 ià( + gnum_wžd + > 1) + +777 + gnÚ_Üphª_wždÿrd +. +š£¹ +( +fœ¡_Úe +); + +780 + gi + = 1; i <ð(*( +c +-> +v¬ŸbËs +())). +size +(); i++) { + +781 +V¬ŸbË_ID + + gwc + = (*( +c +-> +v¬ŸbËs +()))[ +i +]; + +782 ià( + gwc +-> +kšd +(è=ð +Wždÿrd_V¬ + && +nÚ_Üphª_wždÿrd +. +fšd +( +wc +è=ðnÚ_Üphª_wždÿrd. +’d +()) { + +783 +Tu¶e +< +GEQ_HªdË +> +low” +, +uµ” +; + +784 +GEQ_I‹¿tÜ + +gi +( +c +); + ggi +; gi++) { + +785 if((* + ggi +). +g‘_cÛf +( +wc +) > 0) + +786 + glow” +. +³nd +(* +gi +); + +787 if((* + ggi +). +g‘_cÛf +( +wc +) < 0) + +788 + guµ” +. +³nd +(* +gi +); + +793 + gTu¶e_I‹¿tÜ +< + gGEQ_HªdË +> +low +( +low” +); + glow +;†ow++) { + +794 + gTu¶e_I‹¿tÜ +< + gGEQ_HªdË +> +up +( +uµ” +); + gup +; up++) { + +795 +cÛf_t + + glow_cÛf + = (* +low +). +g‘_cÛf +( +wc +); + +796 +cÛf_t + + gup_cÛf + = (* +up +). +g‘_cÛf +( +wc +); + +798 (* + glow +). +upd©e_cÛf_duršg_sim¶ify +( +wc +, 1- +low_cÛf +); + +799 +CG_ouutR•r +* + glowEx´ + = +ouutEasyBoundAsR•r +( +ocg +, +gu¬ds +, * +low +, +wc +, +çl£ +, 0, +assigÃd_Ú_the_æy +); + +800 (* + glow +). +upd©e_cÛf_duršg_sim¶ify +( +wc +, +low_cÛf +-1); + +802 (* + gup +). +upd©e_cÛf_duršg_sim¶ify +( +wc +, -1- +up_cÛf +); + +803 +CG_ouutR•r +* + gupEx´ + = +ouutEasyBoundAsR•r +( +ocg +, +gu¬ds +, * +up +, +wc +, +çl£ +, 0, +assigÃd_Ú_the_æy +); + +804 (* + gup +). +upd©e_cÛf_duršg_sim¶ify +( +wc +, +up_cÛf ++1); + +806 +CG_ouutR•r +* + gštDiv + = +ocg +-> +C»©eIÁeg”Divide +( +upEx´ +, ocg-> +C»©eIÁ +(- +up_cÛf +)); + +807 +CG_ouutR•r +* + grÝ + = +ocg +-> +C»©eTimes +(ocg-> +C»©eIÁ +( +low_cÛf +), +štDiv +); + +808 +CG_ouutR•r +* + ggeqNode + = +ocg +-> +C»©eLE +( +lowEx´ +, +rÝ +); + +810 + ggeqR•r + = +ocg +-> +C»©eAnd +( +geqR•r +, +geqNode +); + +816 ià( + gnÚ_Üphª_wždÿrd +. +size +() > 0) { + +826 +throw + +codeg’_”rÜ +("Can't generate multiple wildcard GEQ guards„ight‚ow"); + +829 + ggeqR•r +; + +836 +CG_ouutR•r + * +ouutGu¬d +( +CG_ouutBužd” +* +ocg +, cÚ¡ +R–©iÚ + & +gu¬ds_š +, cÚ¡ +¡d +:: +veùÜ +<CG_ouutR•¸*> & +assigÃd_Ú_the_æy +) { + +837 +R–©iÚ + & +gu¬ds + = +cÚ¡_ÿ¡ +<R–©iÚ &>( +gu¬ds_š +); + +838 ià( + ggu¬ds +. +is_nuÎ +(è|| gu¬ds. +is_obvious_utÞogy +()) + +839 + gNULL +; + +841 +CG_ouutR•r +* + gnodeR•r + = +NULL +; + +843 +CG_ouutR•r + * + geqSŒideR•r + = +ouut_EQ_¡rides +( +ocg +, +gu¬ds +, +assigÃd_Ú_the_æy +); + +844 + gnodeR•r + = +ocg +-> +C»©eAnd +( +nodeR•r +, +eqSŒideR•r +); + +846 +CG_ouutR•r + * + ggeqSŒideR•r + = +ouut_GEQ_¡rides +( +ocg +, +gu¬ds +, +assigÃd_Ú_the_æy +); + +847 + gnodeR•r + = +ocg +-> +C»©eAnd +( +nodeR•r +, +geqSŒideR•r +); + +849 +CÚjunù + * + gc + = +gu¬ds +. +sšgË_cÚjunù +(); + +850 +EQ_I‹¿tÜ + +ei +( +c +-> +EQs +()); + gei +;ƒi++) + +851 ià(!(* + gei +). +has_wždÿrds +()) { + +852 +CG_ouutR•r + * + geqR•r + = +ouut_as_gu¬d +( +ocg +, +gu¬ds +, (* +ei +), +Œue +, +assigÃd_Ú_the_æy +); + +853 + gnodeR•r + = +ocg +-> +C»©eAnd +( +nodeR•r +, +eqR•r +); + +855 +GEQ_I‹¿tÜ + +gi +( +c +-> +GEQs +()); + ggi +; gi++) + +856 ià(!(* + ggi +). +has_wždÿrds +()) { + +857 +CG_ouutR•r + * + ggeqR•r + = +ouut_as_gu¬d +( +ocg +, +gu¬ds +, (* +gi +), +çl£ +, +assigÃd_Ú_the_æy +); + +858 + gnodeR•r + = +ocg +-> +C»©eAnd +( +nodeR•r +, +geqR•r +); + +861 + gnodeR•r +; + +869 +CG_ouutR•r + * +ouutLBasR•r +( +CG_ouutBužd” +* +ocg +, cÚ¡ +GEQ_HªdË + & +g +, + +870 +R–©iÚ + & +bounds +, +V¬ŸbË_ID + +v +, + +871 +cÛf_t + +¡ride +, cÚ¡ +EQ_HªdË + & +¡rideEQ +, + +872 +R–©iÚ + +known +, cÚ¡ +¡d +:: +veùÜ +< +CG_ouutR•r + *> & +assigÃd_Ú_the_æy +) { + +873 #ià! +defšed + +NDEBUG + + +874 +cÛf_t + +v_cÛf +; + +875 +as£¹ +(( +v_cÛf + = +g +. +g‘_cÛf +( +v +)) > 0); + +878 + g¡d +:: +¡ršg + +s +; + +879 +CG_ouutR•r + * + glbR•r +; + +880 ià( + g¡ride + == 1) { + +881 +lbR•r + = +ouutEasyBoundAsR•r +( +ocg +, +bounds +, +g +, +v +, +çl£ +, 1, +assigÃd_Ú_the_æy +); + +884 ià(! +boundH™sSŒide +( +g +, +v +, +¡rideEQ +, +¡ride +, +known +)) { + +885 + gbounds +. +£tup_Çmes +(); + +887 +CG_¡ršgBužd” + + goscg +; + +888 + g¡d +:: +¡ršg + +c + = +G‘SŒšg +( +ouutEasyBoundAsR•r +(& +oscg +, +bounds +, +¡rideEQ +, +v +, +Œue +, 0, +assigÃd_Ú_the_æy +)); + +889 +CG_ouutR•r + * + gcR•r + = +NULL +; + +890 ià( + gc + !ð +¡d +:: +¡ršg +("0")) + +891 +cR•r + = +ouutEasyBoundAsR•r +( +ocg +, +bounds +, +¡rideEQ +, +v +, +Œue +, 0, +assigÃd_Ú_the_æy +); + +892 + g¡d +:: +¡ršg + +Lov”M + = +G‘SŒšg +( +ouutEasyBoundAsR•r +(& +oscg +, +bounds +, +g +, +v +, +çl£ +, 1, +assigÃd_Ú_the_æy +)); + +893 +CG_ouutR•r + * + gLov”MR•r + = +NULL +; + +894 ià( + gLov”M + !ð +¡d +:: +¡ršg +("0")) + +895 +Lov”MR•r + = +ouutEasyBoundAsR•r +( +ocg +, +bounds +, +g +, +v +, +çl£ +, 1, +assigÃd_Ú_the_æy +); + +897 ià( + gcode_g’_debug + > 2) { + +898 +årštf +( +DebugFže +,"::: Lov”M i %s\n", +Lov”M +. +c_¡r +()); + +899 +årštf +( +DebugFže +,"::: c i %s\n", +c +. +c_¡r +()); + +902 + gcom¶ex™y1 + = 0, + gcom¶ex™y2 + = 0; + +903 +size_t + + gi + = 0; i < + gc +. +Ëngth +(); i++) + +904 ià( + gc +[ +i +] =ð'+' || +c +[i] == '-' || c[i] == '*' || c[i] == '/') + +905 +com¶ex™y1 +++; + +906 ià( + gc +[ +i +] == ',') + +907 +com¶ex™y1 + += 2; + +908 +size_t + + gi + = 0; i < + gLov”M +. +Ëngth +(); i++) + +909 ià( + gLov”M +[ +i +] =ð'+' || +Lov”M +[i] == '-' || LoverM[i] == '*' || LoverM[i] == '/') + +910 +com¶ex™y2 +++; + +911 ià( + gLov”M +[ +i +] == ',') + +912 +com¶ex™y2 + += 2; + +914 ià( + gcom¶ex™y1 + < + gcom¶ex™y2 +) { + +915 +CG_ouutR•r + * + gidUp + = +Lov”MR•r +; + +916 +CG_ouutR•r + * + gc1R•r + = +ocg +-> +C»©eCÝy +( +cR•r +); + +917 + gidUp + = +ocg +-> +C»©eMšus +( +idUp +, +c1R•r +); + +918 + gidUp + = +ocg +-> +C»©ePlus +( +idUp +, ocg-> +C»©eIÁ +( +¡ride +-1)); + +919 +CG_ouutR•r + * + gidLow + = +ocg +-> +C»©eIÁ +( +¡ride +); + +920 + glbR•r + = +ocg +-> +C»©eTimes +(ocg-> +C»©eIÁ +( +¡ride +), + +921 +ocg +-> +C»©eIÁeg”Divide +( +idUp +, +idLow +)); + +922 + glbR•r + = +ocg +-> +C»©ePlus +( +lbR•r +, +cR•r +); + +925 +CG_ouutR•r + * + gLov”M1R•r + = +ocg +-> +C»©eCÝy +( +Lov”MR•r +); + +926 +CG_ouutR•r + * + gimUp + = +ocg +-> +C»©eMšus +( +cR•r +, +Lov”M1R•r +); + +927 +CG_ouutR•r + * + gimLow + = +ocg +-> +C»©eIÁ +( +¡ride +); + +928 +CG_ouutR•r + * + gštMod + = +ocg +-> +C»©eIÁeg”Mod +( +imUp +, +imLow +); + +929 + glbR•r + = +ocg +-> +C»©ePlus +( +Lov”MR•r +, +štMod +); + +934 + gbounds +. +£tup_Çmes +(); + +935 + glbR•r + = +ouutEasyBoundAsR•r +( +ocg +, +bounds +, +g +, +v +, +çl£ +, 0, +assigÃd_Ú_the_æy +); + +939 + glbR•r +; + +946 +CG_ouutR•r + * +ouutUBasR•r +( +CG_ouutBužd” +* +ocg +, cÚ¡ +GEQ_HªdË + & +g +, + +947 +R–©iÚ + & +bounds +, + +948 +V¬ŸbË_ID + +v +, + +949 +cÛf_t + , + +950 cÚ¡ +EQ_HªdË + & , + +951 cÚ¡ +¡d +:: +veùÜ +< +CG_ouutR•r + *> & +assigÃd_Ú_the_æy +) { + +952 +as£¹ +( +g +. +g‘_cÛf +( +v +) < 0); + +953 +CG_ouutR•r +* + gupR•r + = +ouutEasyBoundAsR•r +( +ocg +, +bounds +, +g +, +v +, +çl£ +, 0, +assigÃd_Ú_the_æy +); + +954 + gupR•r +; + +966 +CG_ouutR•r +* +ouutEasyBoundAsR•r +( +CG_ouutBužd” +* +ocg +, +R–©iÚ + & +bounds +, + +967 cÚ¡ +CÚ¡¿št_HªdË + & +g +, +V¬ŸbË_ID + +v +, + +968 +boÞ + +ignÜeWC +, + +969 +ûžšg +, + +970 cÚ¡ +¡d +:: +veùÜ +< +CG_ouutR•r + *> & +assigÃd_Ú_the_æy +) { + +974 +CG_ouutR•r +* +—syBoundR•r + = +NULL +; + +976 +cÛf_t + + gv_cÛf + = +g +. +g‘_cÛf +( +v +); + +977 + gv_sign + = +v_cÛf + > 0 ? 1 : -1; + +978 + gv_cÛf + *ð +v_sign +; + +979 +as£¹ +( +v_cÛf + > 0); + +982 + gsign_adj + = - +v_sign +; + +987 +CÚ¡r_V¬s_I‹r + +c2 +( +g +, +çl£ +); + gc2 +; c2++) { + +988 ià((* + gc2 +). + gv¬ + !ð +v + && (! +ignÜeWC + || (* +c2 +). +v¬ +-> +kšd +()!= +Wždÿrd_V¬ +)) { + +990 +cÛf_t + +cf + = (* +c2 +). +cÛf +* +sign_adj +; + +991 +as£¹ +( +cf + != 0); + +993 +CG_ouutR•r + * + gv¬Name +; + +994 ià((* + gc2 +). + gv¬ +-> +kšd +(è=ð +Wždÿrd_V¬ +) { + +995 +GEQ_HªdË + +h +; + +996 ià(! +fšdFloÜIÃqu®™y +( +bounds +, (* +c2 +). +v¬ +, +h +, +v +)) { + +997 ià( + g—syBoundR•r + !ð +NULL +) { + +998 +—syBoundR•r +-> +þ—r +(); + +999 +d–‘e + + g—syBoundR•r +; + +1001 + gNULL +; + +1003 + gv¬Name + = +ouutEasyBoundAsR•r +( +ocg +, +bounds +, +h +, (* +c2 +). +v¬ +, +çl£ +, 0, +assigÃd_Ú_the_æy +); + +1006 + gv¬Name + = +ouutId’t +( +ocg +, +bounds +, (* +c2 +). +v¬ +, +assigÃd_Ú_the_æy +); + +1008 +CG_ouutR•r + * + gcfR•r + = +NULL +; + +1010 ià( + gcf + > 1) { + +1011 + gcfR•r + = +ocg +-> +C»©eIÁ +( +cf +); + +1012 +CG_ouutR•r +* + grbR•r + = +ocg +-> +C»©eTimes +( +cfR•r +, +v¬Name +); + +1013 + g—syBoundR•r + = +ocg +-> +C»©ePlus +( +—syBoundR•r +, +rbR•r +); + +1015 ià( + gcf + < -1) { + +1016 + gcfR•r + = +ocg +-> +C»©eIÁ +(- +cf +); + +1017 +CG_ouutR•r +* + grbR•r + = +ocg +-> +C»©eTimes +( +cfR•r +, +v¬Name +); + +1018 + g—syBoundR•r + = +ocg +-> +C»©eMšus +( +—syBoundR•r +, +rbR•r +); + +1020 ià( + gcf + == 1) { + +1021 +—syBoundR•r + = +ocg +-> +C»©ePlus +ÓasyBoundR•r, +v¬Name +); + +1023 ià( + gcf + == -1) { + +1024 +—syBoundR•r + = +ocg +-> +C»©eMšus +ÓasyBoundR•r, +v¬Name +); + +1029 ià( + gg +. +g‘_cÚ¡ +()) { + +1030 +cÛf_t + + gcf + = +g +. +g‘_cÚ¡ +()* +sign_adj +; + +1031 +as£¹ +( +cf + != 0); + +1032 ià( + gcf + > 0) { + +1033 + g—syBoundR•r + = +ocg +-> +C»©ePlus +( +—syBoundR•r +, ocg-> +C»©eIÁ +( +cf +)); + +1036 + g—syBoundR•r + = +ocg +-> +C»©eMšus +( +—syBoundR•r +, ocg-> +C»©eIÁ +(- +cf +)); + +1040 if( + g—syBoundR•r + =ð +NULL +) { + +1041 +—syBoundR•r + = +ocg +-> +C»©eIÁ +(0); + +1045 ià( + gv_cÛf + > 1) { + +1046 +as£¹ +( +ûžšg + >= 0); + +1047 ià( + gûžšg +) { + +1048 + g—syBoundR•r +ð +ocg +-> +C»©ePlus +( +—syBoundR•r +, ocg-> +C»©eIÁ +( +v_cÛf +-1)); + +1050 + g—syBoundR•r + = +ocg +-> +C»©eIÁeg”Divide +( +—syBoundR•r +, ocg-> +C»©eIÁ +( +v_cÛf +)); + +1053 + g—syBoundR•r +; + +1062 + g¡d +:: +·œ +< +CG_ouutR•r + *, + gboÞ +> +ouutBounds +( +CG_ouutBužd” +* +ocg +, cÚ¡ +R–©iÚ + & +bounds +, +V¬ŸbË_ID + +v +, +šd’t +, R–©iÚ & +’fÜûd +, cÚ¡ +¡d +:: +veùÜ +<CG_ouutR•¸*> & +assigÃd_Ú_the_æy +) { + +1063 +R–©iÚ + +b + = +cÝy +( +bounds +); + +1064 +CÚjunù + * + gc + = +b +. +qu”y_DNF +()-> +sšgË_cÚjunù +(); + +1068 +R–©iÚ + + gr1 + = R–©iÚ:: +True +( +b +. +n_£t +()), + gr2 + = Relation::True(b.n_set()); + +1069 +EQ_I‹¿tÜ + +ei +( +c +); + gei +;ƒi++) { + +1070 ià((* + gei +). +g‘_cÛf +( +v +è!ð0 && (* +ei +). +has_wždÿrds +()) { + +1071 +cÛf_t + +sign +; + +1072 ià((* + gei +). +g‘_cÛf +( +v +) > 0) + +1073 + gsign + = 1; + +1075 + gsign + = -1; + +1077 +cÛf_t + + g¡ride + = 0; + +1078 +CÚ¡r_V¬s_I‹r + +cvi +(* +ei +, +Œue +); + gcvi +; cvi++) + +1079 ià((* + gcvi +). + gv¬ +-> +kšd +(è=ð +Wždÿrd_V¬ +) { + +1080 +¡ride + = +abs +((* +cvi +). +cÛf +); + +1085 +boÞ + + gfound_m©ch + = +çl£ +; + +1086 ià( +abs +((* +ei +). +g‘_cÛf +( +v +)) != 1) { + +1087 +cÛf_t + +d + = +¡ride + / +gcd +( +abs +((* +ei +). +g‘_cÛf +( +v +)), stride); + +1088 +R–©iÚ + + gr3 + = R–©iÚ:: +True +( +b +. +n_£t +()); + +1089 + gr3 +. +ªd_w™h_EQ +(* +ei +); + +1091 +GEQ_I‹¿tÜ + +gi +( +c +); + ggi +; gi++) { + +1092 ià((* + ggi +). +g‘_cÛf +( +v +è=ð1 && !(* +gi +). +has_wždÿrds +()) { + +1093 +R–©iÚ + +r4 +( +b +. +n_£t +()); + +1094 +F_And + * + gf_roÙ + = +r4 +. +add_ªd +(); + +1095 +SŒide_HªdË + + gh + = +f_roÙ +-> +add_¡ride +( +d +); + +1097 +CÚ¡r_V¬s_I‹r + +cvi +(* +gi +); + gcvi +; cvi++) + +1098 (* + gcvi +). + gv¬ +-> +kšd +()) { + +1099 + gIÅut_V¬ +: { + +1100 +pos + = (* +cvi +). +v¬ +-> +g‘_pos™iÚ +(); + +1101 + gh +. +upd©e_cÛf +( +r4 +. +£t_v¬ +( +pos +), (* +cvi +). +cÛf +); + +1104 + gGlob®_V¬ +: { + +1105 +Glob®_V¬_ID + +g + = (* +cvi +). +v¬ +-> +g‘_glob®_v¬ +(); + +1106 +V¬ŸbË_ID + + gv +; + +1107 ià( + gg +-> +¬™y +() == 0) + +1108 +v + = +r4 +. +g‘_loÿl +( +g +); + +1110 + gv + = +r4 +. +g‘_loÿl +( +g +, (* +cvi +). +v¬ +-> +funùiÚ_of +()); + +1111 + gh +. +upd©e_cÛf +( +v +, (* +cvi +). +cÛf +); + +1115 +årštf +( +DebugFže +, "can't deal withhe variableype in†ower bound\n"); + +1116 + g¡d +:: +make_·œ +( +¡©ic_ÿ¡ +< +CG_ouutR•r + *>( +NULL +), +çl£ +); + +1118 + gh +. +upd©e_cÚ¡ +((* +gi +). +g‘_cÚ¡ +()); + +1120 +R–©iÚ + + gr5 + = +Gi¡ +( +cÝy +( +r3 +), +IÁ”£ùiÚ +(cÝy( +r4 +), cÝy( +’fÜûd +))); + +1123 ià( + gr5 +. +is_obvious_utÞogy +()) { + +1124 + gr1 + = +IÁ”£ùiÚ +( +r1 +, +r4 +); + +1125 + gfound_m©ch + = +Œue +; + +1132 +GEQ_I‹¿tÜ + +gi +( +c +); + ggi +; gi++) { + +1133 ià((* + ggi +). +g‘_cÛf +( +v +è=ð +abs +((* +ei +).g‘_cÛf(v)è&& !(* +gi +). +has_wždÿrds +()) { + +1134 +R–©iÚ + +r +( +b +. +n_£t +()); + +1135 +SŒide_HªdË + + gh + = +r +. +add_ªd +()-> +add_¡ride +( +¡ride +); + +1137 +CÚ¡r_V¬s_I‹r + +cvi +(* +gi +); + gcvi +; cvi++) + +1138 (* + gcvi +). + gv¬ +-> +kšd +()) { + +1139 + gIÅut_V¬ +: { + +1140 +pos + = (* +cvi +). +v¬ +-> +g‘_pos™iÚ +(); + +1141 ià((* + gcvi +). + gv¬ + !ð +v +) { + +1142 +t1 + = +št_mod +((* +cvi +). +cÛf +, +¡ride +); + +1143 ià( + gt1 + != 0) { + +1144 +cÛf_t + +t2 + = +’fÜûd +. +qu”y_v¬ŸbË_mod +ÓnfÜûd. +£t_v¬ +( +pos +), +¡ride +); + +1145 ià( + gt2 + !ð +posInfš™y +) + +1146 +h +. +upd©e_cÚ¡ +( +t1 +* +t2 +); + +1148 + gh +. +upd©e_cÛf +( +r +. +£t_v¬ +( +pos +), +t1 +); + +1152 + gh +. +upd©e_cÛf +( +r +. +£t_v¬ +( +pos +), (* +cvi +). +cÛf +); + +1155 + gGlob®_V¬ +: { + +1156 +Glob®_V¬_ID + +g + = (* +cvi +). +v¬ +-> +g‘_glob®_v¬ +(); + +1157 +V¬ŸbË_ID + + gv +; + +1158 ià( + gg +-> +¬™y +() == 0) + +1159 +v + = +’fÜûd +. +g‘_loÿl +( +g +); + +1161 + gv + = +’fÜûd +. +g‘_loÿl +( +g +, (* +cvi +). +v¬ +-> +funùiÚ_of +()); + +1162 +cÛf_t + + gt + = +’fÜûd +. +qu”y_v¬ŸbË_mod +( +v +, +¡ride +); + +1163 ià( + gt + !ð +posInfš™y +) + +1164 +h +. +upd©e_cÚ¡ +( +t +*(* +cvi +). +cÛf +); + +1166 +V¬ŸbË_ID + + gv2 +; + +1167 ià( + gg +-> +¬™y +() == 0) + +1168 +v2 + = +r +. +g‘_loÿl +( +g +); + +1170 + gv2 + = +r +. +g‘_loÿl +( +g +, (* +cvi +). +v¬ +-> +funùiÚ_of +()); + +1171 + gh +. +upd©e_cÛf +( +v2 +, (* +cvi +). +cÛf +); + +1176 +årštf +( +DebugFže +, "can't deal withhe variableype in†ower bound\n"); + +1177 + g¡d +:: +make_·œ +( +¡©ic_ÿ¡ +< +CG_ouutR•r + *>( +NULL +), +çl£ +); + +1179 + gh +. +upd©e_cÚ¡ +((* +gi +). +g‘_cÚ¡ +()); + +1181 +boÞ + + gt + = +Œue +; + +1183 +CÚjunù + * + gc2 + = +r +. +qu”y_DNF +()-> +sšgË_cÚjunù +(); + +1184 +EQ_HªdË + + gh2 +; + +1185 +EQ_I‹¿tÜ + +ei2 +( +c2 +); + gei2 +;ƒi2++) { + +1186 + gh2 + = * +ei2 +; + +1190 + gsign +; + +1191 ià( + gh2 +. +g‘_cÛf +( +v +è=ð(* +ei +).get_coef(v)) + +1192 +sign + = 1; + +1194 + gsign + = -1; + +1196 + gt + = +št_mod +( +h2 +. +g‘_cÚ¡ +(è- +sign + * (* +ei +).g‘_cÚ¡(), +¡ride +) == 0; + +1198 ià( + gt + !ð +çl£ +) + +1199 +CÚ¡r_V¬s_I‹r + +cvi +( +h2 +); + gcvi +; cvi++) + +1200 ià((* + gcvi +). + gv¬ +-> +kšd +(è!ð +Wždÿrd_V¬ + && + +1201 +št_mod +((* +cvi +). +cÛf + - +sign + * (* +ei +). +g‘_cÛf +((*cvi). +v¬ +), +¡ride +) != 0) { + +1202 +t + = +çl£ +; + +1206 ià( + gt + !ð +çl£ +) + +1207 +CÚ¡r_V¬s_I‹r + +cvi +(* +ei +); + gcvi +; cvi++) + +1208 ià((* + gcvi +). + gv¬ +-> +kšd +(è!ð +Wždÿrd_V¬ + && + +1209 +št_mod +((* +cvi +). +cÛf + - +sign + * +h2 +. +g‘_cÛf +((*cvi). +v¬ +), +¡ride +) != 0) { + +1210 +t + = +çl£ +; + +1216 ià( + gt +) { + +1218 +F_And + * + gf_roÙ + = +r1 +. +ªd_w™h_ªd +(); + +1219 +SŒide_HªdË + + gh + = +f_roÙ +-> +add_¡ride +( +¡ride +); + +1220 +CÚ¡r_V¬s_I‹r + +cvi +(* +gi +); + gcvi +; cvi++) + +1221 (* + gcvi +). + gv¬ +-> +kšd +()) { + +1222 + gIÅut_V¬ +: { + +1223 +h +. +upd©e_cÛf +( +r1 +. +£t_v¬ +((* +cvi +). +v¬ +-> +g‘_pos™iÚ +()), (*cvi). +cÛf +); + +1226 + gGlob®_V¬ +: { + +1227 +Glob®_V¬_ID + +g + = (* +cvi +). +v¬ +-> +g‘_glob®_v¬ +(); + +1228 +V¬ŸbË_ID + + gv +; + +1229 ià( + gg +-> +¬™y +() == 0) + +1230 +v + = +r1 +. +g‘_loÿl +( +g +); + +1232 + gv + = +r1 +. +g‘_loÿl +( +g +, (* +cvi +). +v¬ +-> +funùiÚ_of +()); + +1233 + gh +. +upd©e_cÛf +( +v +, (* +cvi +). +cÛf +); + +1237 +årštf +( +DebugFže +, "can't deal withhe variableype in†ower bound\n"); + +1238 + g¡d +:: +make_·œ +( +¡©ic_ÿ¡ +< +CG_ouutR•r + *>( +NULL +), +çl£ +); + +1240 + gh +. +upd©e_cÚ¡ +((* +gi +). +g‘_cÚ¡ +()); + +1242 + gfound_m©ch + = +Œue +; + +1249 ià(! + gfound_m©ch +) + +1250 + gr1 +. +ªd_w™h_EQ +(* +ei +); + +1252 ià((* + gei +). +g‘_cÛf +( +v +) == 0) { + +1253 +R–©iÚ + +r3 + = R–©iÚ:: +True +( +b +. +n_£t +()); + +1254 + gr3 +. +ªd_w™h_EQ +(* +ei +); + +1255 +R–©iÚ + + gr4 + = +Gi¡ +( +r3 +, +cÝy +( +’fÜûd +)); + +1256 ià(! + gr4 +. +is_obvious_utÞogy +()) + +1257 + gr2 +. +ªd_w™h_EQ +(* +ei +); + +1260 + gr2 +. +ªd_w™h_EQ +(* +ei +); + +1265 + g¡d +:: +m +< +V¬ŸbË_ID +, + gV¬ŸbË_ID +> + gexi¡s_mpšg +; + +1266 +F_Exi¡s + * + gã + = +r2 +. +ªd_w™h_ªd +()-> +add_exi¡s +(); + +1267 +F_And + * + gf_roÙ + = +ã +-> +add_ªd +(); + +1268 +GEQ_I‹¿tÜ + +gi +( +c +); + ggi +; gi++) { + +1269 +GEQ_HªdË + + gh + = +f_roÙ +-> +add_GEQ +(); + +1270 +CÚ¡r_V¬s_I‹r + +cvi +(* +gi +); + gcvi +; cvi++) { + +1271 +V¬ŸbË_ID + + gv + = +cvi +. +cu¼_v¬ +(); + +1272 + gv +-> +kšd +()) { + +1273 + gIÅut_V¬ +: { + +1274 +pos + = +v +-> +g‘_pos™iÚ +(); + +1275 + gh +. +upd©e_cÛf +( +r2 +. +£t_v¬ +( +pos +), +cvi +. +cu¼_cÛf +()); + +1278 + gExi¡s_V¬ +: + +1279 +Wždÿrd_V¬ +: { + +1280 +¡d +:: +m +< +V¬ŸbË_ID +, + gV¬ŸbË_ID +>:: +™”©Ü + +p + = +exi¡s_mpšg +. +fšd +( +v +); + +1281 +V¬ŸbË_ID + + ge +; + +1282 ià( + gp + =ð +exi¡s_mpšg +. +’d +()) { + +1283 +e + = +ã +-> +deþ¬e +(); + +1284 + gexi¡s_mpšg +[ +v +] = +e +; + +1287 + ge + = (* +p +). +£cÚd +; + +1288 + gh +. +upd©e_cÛf +( +e +, +cvi +. +cu¼_cÛf +()); + +1291 + gGlob®_V¬ +: { + +1292 +Glob®_V¬_ID + +g + = +v +-> +g‘_glob®_v¬ +(); + +1293 +V¬ŸbË_ID + + gv2 +; + +1294 ià( + gg +-> +¬™y +() == 0) + +1295 +v2 + = +r2 +. +g‘_loÿl +( +g +); + +1297 + gv2 + = +r2 +. +g‘_loÿl +( +g +, +v +-> +funùiÚ_of +()); + +1298 + gh +. +upd©e_cÛf +( +v2 +, +cvi +. +cu¼_cÛf +()); + +1302 +as£¹ +(0); + +1305 + gh +. +upd©e_cÚ¡ +((* +gi +). +g‘_cÚ¡ +()); + +1311 + gr1 +. +sim¶ify +(); + +1312 + gr2 +. +sim¶ify +(); + +1313 +R–©iÚ + + gb2 + = +IÁ”£ùiÚ +( +r1 +, +r2 +); + +1314 + gb2 +. +sim¶ify +(); + +1315 + gi + = 1; i <ð +b +. +n_£t +(); i++) + +1316 + gb2 +. +Çme_£t_v¬ +( +i +, +b +. +£t_v¬ +(i)-> +Çme +()); + +1317 + gb2 +. +£tup_Çmes +(); + +1318 + gb + = +b2 +; + +1319 + gc + = +b +. +qu”y_DNF +()-> +sšgË_cÚjunù +(); + +1324 +EQ_HªdË + + g¡rideEQ +; + +1325 +boÞ + + gfoundSŒide + = +çl£ +; + +1326 +boÞ + + gfoundSim¶eSŒide + = +çl£ +; + +1327 +cÛf_t + + g¡• + = 1; + +1328 + gnum_¡ride + = 0; + +1330 +EQ_I‹¿tÜ + +ei +( +c +); + gei +;ƒi++) { + +1331 ià((* + gei +). +g‘_cÛf +( +v +è!ð0 && (* +ei +). +has_wždÿrds +()) { + +1332 +num_¡ride +++; + +1334 ià( +abs +((* +ei +). +g‘_cÛf +( +v +)) != 1) + +1337 +boÞ + + gt + = +Œue +; + +1338 +cÛf_t + + gd + = 1; + +1339 +CÚ¡r_V¬s_I‹r + +cvi +(* +ei +); + gcvi +; cvi++) + +1340 ià((* + gcvi +). + gv¬ +-> +kšd +(è=ð +Wždÿrd_V¬ +) { + +1341 +as£¹ +( +d +==1); + +1342 + gd + = +abs +((* +cvi +). +cÛf +); + +1344 ià((* + gcvi +). + gv¬ +-> +kšd +(è=ð +IÅut_V¬ +) { + +1345 ià((* +cvi +). +v¬ + !ð +v +) + +1346 +t + = +çl£ +; + +1349 + gt + = +çl£ +; + +1351 ià( + gd + > + g¡• +) { + +1352 + g¡• + = +d +; + +1353 + gfoundSim¶eSŒide + = +t +; + +1354 + g¡rideEQ + = * +ei +; + +1355 + gfoundSŒide + = +Œue +; + +1362 ià(!( + gnum_¡ride + =ð0 || ( +num_¡ride + =ð1 && +foundSŒide +))) + +1363 +¡d +:: +make_·œ +( +¡©ic_ÿ¡ +< +CG_ouutR•r + *>( +NULL +), +çl£ +); + +1366 + glow”_bounds + = 0, + guµ”_bounds + = 0; + +1367 + gTu¶e +< + gCG_ouutR•r + *> + glbLi¡ +; + +1368 + gTu¶e +< + gCG_ouutR•r + *> + gubLi¡ +; + +1369 +cÛf_t + + gcÚ¡_lb + = +ÃgInfš™y +, + gcÚ¡_ub + = +posInfš™y +; + +1370 +GEQ_I‹¿tÜ + +g +( +c +); + gg +; g++) { + +1371 +cÛf_t + + gcÛf + = (* +g +). +g‘_cÛf +( +v +); + +1372 ià( + gcÛf + == 0) + +1374 ià( + gcÛf + > 0) { + +1375 + glow”_bounds +++; + +1376 ià((* + gg +). +is_cÚ¡ +( +v +è&& ! + gfoundSŒide +) { + +1378 +cÛf_t + + gL +, + gm +; + +1379 + gL + = -((* +g +). +g‘_cÚ¡ +()); + +1381 + gm + = (* +g +). +g‘_cÛf +( +v +); + +1382 +cÛf_t + + gsb + = (è( +ûž +(((è +L +è/ +m +)); + +1383 +£t_max +( +cÚ¡_lb +, +sb +); + +1385 ià((* + gg +). +is_cÚ¡ +( +v +è&& + gfoundSim¶eSŒide +) { + +1388 +cÛf_t + + gL +, + gm +, + gs +, + gc +; + +1389 + gL + = -((* +g +). +g‘_cÚ¡ +()); + +1390 + gm + = (* +g +). +g‘_cÛf +( +v +); + +1391 + gs + = +¡• +; + +1392 + gc + = +¡rideEQ +. +g‘_cÚ¡ +(); + +1393 +cÛf_t + + gsb + = ( +s + * (è( +ûž +Ð(è( +L + - ( +c + * +m +)) /(s*m))))+ c; + +1394 +£t_max +( +cÚ¡_lb +, +sb +); + +1397 + glbLi¡ +. +³nd +( +ouutLBasR•r +( +ocg +, * +g +, +b +, +v +, +¡• +, +¡rideEQ +, +’fÜûd +, +assigÃd_Ú_the_æy +)); + +1400 + guµ”_bounds +++; + +1401 ià((* + gg +). +is_cÚ¡ +( +v +)) { + +1403 +£t_mš +( +cÚ¡_ub +,-(* +g +). +g‘_cÚ¡ +()/(*g). +g‘_cÛf +( +v +)); + +1406 + gubLi¡ +. +³nd +( +ouutUBasR•r +( +ocg +, * +g +, +b +, +v +, +¡• +, +¡rideEQ +, +assigÃd_Ú_the_æy +)); + +1410 +CG_ouutR•r + * + glbR•r + = +NULL +; + +1411 +CG_ouutR•r + * + gubR•r + = +NULL +; + +1412 ià( + gcÚ¡_lb + !ð +ÃgInfš™y +) + +1413 +lbLi¡ +. +³nd +( +ocg +-> +C»©eIÁ +( +cÚ¡_lb +)); + +1414 ià( + glbLi¡ +. +size +() > 1) + +1415 + glbR•r + = +ocg +-> +C»©eInvoke +("max", +lbLi¡ +); + +1416 ià( + glbLi¡ +. +size +() == 1) + +1417 +lbR•r + = +lbLi¡ +[1]; + +1420 if( + gfžlInBounds + && + glbLi¡ +. +size +(è=ð1 && +cÚ¡_lb + !ð +ÃgInfš™y +) + +1421 +low”BoundFÜLev– + = +cÚ¡_lb +; + +1424 ià( + gcÚ¡_ub + !ð +posInfš™y +) + +1425 +ubLi¡ +. +³nd +( +ocg +-> +C»©eIÁ +( +cÚ¡_ub +)); + +1426 ià( + gubLi¡ +. +size +() > 1) + +1427 + gubR•r + = +ocg +-> +C»©eInvoke +("mš", +ubLi¡ +); + +1428 ià( + gubLi¡ +. +size +() == 1) + +1429 +ubR•r + = +ubLi¡ +[1]; + +1432 if( + gfžlInBounds + && + gcÚ¡_ub + !ð +posInfš™y +) + +1433 +uµ”BoundFÜLev– + = +cÚ¡_ub +; + +1436 ià( + guµ”_bounds + =ð0 || +low”_bounds + == 0) { + +1437 +¡d +:: +make_·œ +( +¡©ic_ÿ¡ +< +CG_ouutR•r + *>( +NULL +), +çl£ +); + +1441 +F_Exi¡s + * + gã + = +’fÜûd +. +ªd_w™h_ªd +()-> +add_exi¡s +(); + +1442 +F_And + * + gf_roÙ + = +ã +-> +add_ªd +(); + +1443 + g¡d +:: +m +< +V¬ŸbË_ID +, + gV¬ŸbË_ID +> + gexi¡s_mpšg +; + +1444 + g¡d +:: +¡ack +< +¡d +:: +·œ +< +GEQ_HªdË +, + gV¬ŸbË_ID +> > + gæoÜ_geq_¡ack +; + +1445 + g¡d +:: +£t +< +V¬ŸbË_ID +> +æoÜ_v¬_£t +; + +1447 ià( + gfoundSŒide +) { + +1448 +EQ_HªdË + + gh + = +f_roÙ +-> +add_EQ +(); + +1449 +CÚ¡r_V¬s_I‹r + +cvi +( +¡rideEQ +); + gcvi +; cvi++) + +1450 (* + gcvi +). + gv¬ +-> +kšd +()) { + +1451 + gIÅut_V¬ +: { + +1452 +pos + = (* +cvi +). +v¬ +-> +g‘_pos™iÚ +(); + +1453 + gh +. +upd©e_cÛf +( +’fÜûd +. +£t_v¬ +( +pos +), (* +cvi +). +cÛf +); + +1456 + gExi¡s_V¬ +: + +1457 +Wždÿrd_V¬ +: { + +1458 +¡d +:: +m +< +V¬ŸbË_ID +, + gV¬ŸbË_ID +>:: +™”©Ü + +p + = +exi¡s_mpšg +. +fšd +((* +cvi +). +v¬ +); + +1459 +V¬ŸbË_ID + + ge +; + +1460 ià( + gp + =ð +exi¡s_mpšg +. +’d +()) { + +1461 +e + = +ã +-> +deþ¬e +(); + +1462 + gexi¡s_mpšg +[(* +cvi +). +v¬ +] = +e +; + +1465 + ge + = (* +p +). +£cÚd +; + +1466 + gh +. +upd©e_cÛf +( +e +, (* +cvi +). +cÛf +); + +1469 + gGlob®_V¬ +: { + +1470 +Glob®_V¬_ID + +g + = (* +cvi +). +v¬ +-> +g‘_glob®_v¬ +(); + +1471 +V¬ŸbË_ID + + ge +; + +1472 ià( + gg +-> +¬™y +() == 0) + +1473 +e + = +’fÜûd +. +g‘_loÿl +( +g +); + +1475 + ge + = +’fÜûd +. +g‘_loÿl +( +g +, (* +cvi +). +v¬ +-> +funùiÚ_of +()); + +1476 + gh +. +upd©e_cÛf +( +e +, (* +cvi +). +cÛf +); + +1480 +as£¹ +(0); + +1482 + gh +. +upd©e_cÚ¡ +( +¡rideEQ +. +g‘_cÚ¡ +()); + +1485 +GEQ_I‹¿tÜ + +gi +( +c +); + ggi +; gi++) + +1486 ià((* + ggi +). +g‘_cÛf +( +v +) != 0) { + +1487 +GEQ_HªdË + +h + = +f_roÙ +-> +add_GEQ +(); + +1488 +CÚ¡r_V¬s_I‹r + +cvi +(* +gi +); + gcvi +; cvi++) + +1489 (* + gcvi +). + gv¬ +-> +kšd +()) { + +1490 + gIÅut_V¬ +: { + +1491 +pos + = (* +cvi +). +v¬ +-> +g‘_pos™iÚ +(); + +1492 + gh +. +upd©e_cÛf +( +’fÜûd +. +£t_v¬ +( +pos +), (* +cvi +). +cÛf +); + +1495 + gExi¡s_V¬ +: + +1496 +Wždÿrd_V¬ +: { + +1497 +¡d +:: +m +< +V¬ŸbË_ID +, + gV¬ŸbË_ID +>:: +™”©Ü + +p + = +exi¡s_mpšg +. +fšd +((* +cvi +). +v¬ +); + +1498 +V¬ŸbË_ID + + ge +; + +1499 ià( + gp + =ð +exi¡s_mpšg +. +’d +()) { + +1500 +e + = +ã +-> +deþ¬e +(); + +1501 + gexi¡s_mpšg +[(* +cvi +). +v¬ +] = +e +; + +1504 + ge + = (* +p +). +£cÚd +; + +1505 + gh +. +upd©e_cÛf +( +e +, (* +cvi +). +cÛf +); + +1507 ià( + gæoÜ_v¬_£t +. +fšd +((* +cvi +). +v¬ +è=ð +æoÜ_v¬_£t +. +’d +()) { + +1508 +GEQ_HªdË + +h2 +; + +1509 +fšdFloÜIÃqu®™y +( +b +, (* +cvi +). +v¬ +, +h2 +, +v +); + +1510 + gæoÜ_geq_¡ack +. +push +( +¡d +:: +make_·œ +( +h2 +, (* +cvi +). +v¬ +)); + +1511 + gæoÜ_v¬_£t +. +š£¹ +((* +cvi +). +v¬ +); + +1515 + gGlob®_V¬ +: { + +1516 +Glob®_V¬_ID + +g + = (* +cvi +). +v¬ +-> +g‘_glob®_v¬ +(); + +1517 +V¬ŸbË_ID + + ge +; + +1518 ià( + gg +-> +¬™y +() == 0) + +1519 +e + = +’fÜûd +. +g‘_loÿl +( +g +); + +1521 + ge + = +’fÜûd +. +g‘_loÿl +( +g +, (* +cvi +). +v¬ +-> +funùiÚ_of +()); + +1522 + gh +. +upd©e_cÛf +( +e +, (* +cvi +). +cÛf +); + +1526 +as£¹ +(0); + +1528 + gh +. +upd©e_cÚ¡ +((* +gi +). +g‘_cÚ¡ +()); + +1532 ! + gæoÜ_geq_¡ack +. +em±y +()) { + +1533 + g¡d +:: +·œ +< +GEQ_HªdË +, + gV¬ŸbË_ID +> + gp + = +æoÜ_geq_¡ack +. +tÝ +(); + +1534 + gæoÜ_geq_¡ack +. +pÝ +(); + +1536 +GEQ_HªdË + + gh1 + = +f_roÙ +-> +add_GEQ +(); + +1537 +GEQ_HªdË + + gh2 + = +f_roÙ +-> +add_GEQ +(); + +1538 +CÚ¡r_V¬s_I‹r + +cvi +( +p +. +fœ¡ +); + gcvi +; cvi++) { + +1539 (* + gcvi +). + gv¬ +-> +kšd +()) { + +1540 + gIÅut_V¬ +: { + +1541 +pos + = (* +cvi +). +v¬ +-> +g‘_pos™iÚ +(); + +1542 + gh1 +. +upd©e_cÛf +( +’fÜûd +. +šput_v¬ +( +pos +), (* +cvi +). +cÛf +); + +1543 + gh2 +. +upd©e_cÛf +( +’fÜûd +. +šput_v¬ +( +pos +), -(* +cvi +). +cÛf +); + +1546 + gExi¡s_V¬ +: + +1547 +Wždÿrd_V¬ +: { + +1548 +¡d +:: +m +< +V¬ŸbË_ID +, + gV¬ŸbË_ID +>:: +™”©Ü + +p2 + = +exi¡s_mpšg +. +fšd +((* +cvi +). +v¬ +); + +1549 +V¬ŸbË_ID + + ge +; + +1550 ià( + gp2 + =ð +exi¡s_mpšg +. +’d +()) { + +1551 +e + = +ã +-> +deþ¬e +(); + +1552 + gexi¡s_mpšg +[(* +cvi +). +v¬ +] = +e +; + +1555 + ge + = (* +p2 +). +£cÚd +; + +1556 + gh1 +. +upd©e_cÛf +( +e +, (* +cvi +). +cÛf +); + +1557 + gh2 +. +upd©e_cÛf +( +e +, -(* +cvi +). +cÛf +); + +1559 ià( + gæoÜ_v¬_£t +. +fšd +((* +cvi +). +v¬ +è=ð +æoÜ_v¬_£t +. +’d +()) { + +1560 +GEQ_HªdË + +h3 +; + +1561 +fšdFloÜIÃqu®™y +( +b +, (* +cvi +). +v¬ +, +h3 +, +v +); + +1562 + gæoÜ_geq_¡ack +. +push +( +¡d +:: +make_·œ +( +h3 +, (* +cvi +). +v¬ +)); + +1563 + gæoÜ_v¬_£t +. +š£¹ +((* +cvi +). +v¬ +); + +1567 + gGlob®_V¬ +: { + +1568 +Glob®_V¬_ID + +g + = (* +cvi +). +v¬ +-> +g‘_glob®_v¬ +(); + +1569 +V¬ŸbË_ID + + ge +; + +1570 ià( + gg +-> +¬™y +() == 0) + +1571 +e + = +’fÜûd +. +g‘_loÿl +( +g +); + +1573 + ge + = +’fÜûd +. +g‘_loÿl +( +g +, (* +cvi +). +v¬ +-> +funùiÚ_of +()); + +1574 + gh1 +. +upd©e_cÛf +( +e +, (* +cvi +). +cÛf +); + +1575 + gh2 +. +upd©e_cÛf +( +e +, -(* +cvi +). +cÛf +); + +1579 +as£¹ +(0); + +1582 + gh1 +. +upd©e_cÚ¡ +( +p +. +fœ¡ +. +g‘_cÚ¡ +()); + +1583 + gh2 +. +upd©e_cÚ¡ +(- +p +. +fœ¡ +. +g‘_cÚ¡ +()); + +1584 + gh2 +. +upd©e_cÚ¡ +(- +p +. +fœ¡ +. +g‘_cÛf +Õ. +£cÚd +)-1); + +1586 + g’fÜûd +. +sim¶ify +(); + +1588 +CG_ouutR•r + * + g¡R•r + = +NULL +; + +1589 ià( + g¡• + != 1) + +1590 +¡R•r + = +ocg +-> +C»©eIÁ +( +abs +( +¡• +)); + +1591 +CG_ouutR•r + * + gšdexR•r + = +ouutId’t +( +ocg +, +b +, +v +, +assigÃd_Ú_the_æy +); + +1592 +CG_ouutR•r + * + gù¾R•r + = +ocg +-> +C»©eInduùive +( +šdexR•r +, +lbR•r +, +ubR•r +, +¡R•r +); + +1594 + g¡d +:: +make_·œ +( +ù¾R•r +, +Œue +); + +1599 +R–©iÚ + +´ojeù_Úto_Ëv–s +(R–©iÚ +R +, +Ï¡_Ëv– +, +boÞ + +wždÿrds +) { + +1600 +as£¹ +( +Ï¡_Ëv– + >ð0 && +R +. +is_£t +(è&&†a¡_Ëv– <ðR. +n_£t +()); + +1601 ià( + gÏ¡_Ëv– + =ð +R +. +n_£t +()) R; + +1603 + gÜig_v¬s + = +R +. +n_£t +(); + +1604 + gnum_´ojeùed + = +Üig_v¬s + - +Ï¡_Ëv– +; + +1605 + gR + = +Ex‹nd_S‘ +( +R +, +num_´ojeùed + + +1607 +Mpšg + + gm1 + = Mpšg:: +Id’t™y +( +R +. +n_£t +()); + +1609 + gi += +Ï¡_Ëv– ++1; i <ð +Üig_v¬s +; i++) { + +1610 + gm1 +. +£t_m +( +S‘_V¬ +, +i +, +Exi¡s_V¬ +, i); + +1611 + gm1 +. +£t_m +( +S‘_V¬ +, +i ++ +num_´ojeùed +, Set_Var, i); + +1614 +MR–1 +( +R +, +m1 +, +Comb_Id +); + +1615 + gR +. +fš®ize +(); + +1616 + gR +. +sim¶ify +(); + +1617 ià(! + gwždÿrds +) + +1618 + gR + = +Aµroxim©e +( +R +,1); + +1619 +as£¹ +( +R +. +is_£t +()); + +1620 + gR +; + +1627 +boÞ + +boundH™sSŒide +(cÚ¡ +GEQ_HªdË + & +g +, +V¬ŸbË_ID + +v +, + +1628 cÚ¡ +EQ_HªdË + & +¡rideEQ +, + +1629 +cÛf_t + , + +1630 +R–©iÚ + +known +) { + +1635 +cÛf_t + + gm + = +g +. +g‘_cÛf +( +v +); + +1636 +R–©iÚ + +‹¡ +( +known +. +n_£t +()); + +1637 +F_Exi¡s + * + ge + = +‹¡ +. +add_exi¡s +(); + +1638 +V¬ŸbË_ID + + g®pha + = +e +-> +deþ¬e +(); + +1639 +F_And + * + ga + = +e +-> +add_ªd +(); + +1640 +EQ_HªdË + + gh + = +a +-> +add_EQ +(); + +1641 +CÚ¡r_V¬s_I‹r + +I +( +g +, +çl£ +); + gI +; I++) + +1642 if((* + gI +). + gv¬ + !ð +v +) { + +1643 if((* +I +). +v¬ +-> +kšd +(è!ð +Glob®_V¬ +) + +1644 +h +. +upd©e_cÛf +((* +I +). +v¬ +, (*I). +cÛf +); + +1646 + gh +. +upd©e_cÛf +( +‹¡ +. +g‘_loÿl +((* +I +). +v¬ +-> +g‘_glob®_v¬ +()), (*I). +cÛf +); + +1649 + gh +. +upd©e_cÚ¡ +( +g +. +g‘_cÚ¡ +()); + +1650 + gh +. +upd©e_cÛf +( +®pha +, +m +); + +1651 ià(!( +Gi¡ +( +‹¡ +, +cÝy +( +known +)). +is_obvious_utÞogy +())) + +1652 + gçl£ +; + +1654 +R–©iÚ + + gboundR– + = +known +; + +1655 + gboundR– +. +ªd_w™h_EQ +( +g +); + +1656 +R–©iÚ + +¡rideR– +( +known +. +n_£t +()); + +1657 + g¡rideR– +. +ªd_w™h_EQ +( +¡rideEQ +); + +1658 +Gi¡ +( +¡rideR– +, +boundR– +). +is_obvious_utÞogy +(); + +1663 +boÞ + +isSim¶eSŒide +(cÚ¡ +EQ_HªdË + & +g +, +V¬ŸbË_ID + +v +) { + +1664 +EQ_HªdË + + ggg + = +g +; + +1666 +boÞ + + gis_sim¶e += +Œue +; + +1667 +CÚ¡r_V¬s_I‹r + +cvi +( +gg +, +çl£ +); + gcvi + && + gis_sim¶e +; cvi++) + +1668 + gis_sim¶e + = ((* +cvi +). +cÛf + =ð0 || (*cvi). +v¬ + =ð +v + + +1669 || (* +cvi +). +v¬ +-> +kšd +(è=ð +Wždÿrd_V¬ +); + +1670 + gis_sim¶e +; + +1674 +couÁSŒides +( +CÚjunù + * +c +, +V¬ŸbË_ID + +v +, +EQ_HªdË + & +¡rideEQ +, + +1675 +boÞ + & +sim¶e +) { + +1676 + g¡rides +=0; + +1677 +EQ_I‹¿tÜ + +G +( +c +); + gG +; G++) + +1678 +CÚ¡r_V¬s_I‹r + +I +(* +G +, +Œue +); + gI +; I++) + +1679 ià(((* + gI +). + gcÛf + !ð0è&& (* +G +). +g‘_cÛf +( +v +) != 0) { + +1680 +¡rides +++; + +1681 + gsim¶e + = +isSim¶eSŒide +(* +G +, +v +); + +1682 + g¡rideEQ + = * +G +; + +1685 + g¡rides +; + +1688 + gÇme¥aû + { + +1690 +boÞ + +hasEQ +( +R–©iÚ + +r +, +Ëv– +) { + +1691 + gr +. +sim¶ify +(); + +1692 +V¬ŸbË_ID + + gv + = +£t_v¬ +( +Ëv– +); + +1693 +CÚjunù + * + gs_cÚj + = +r +. +sšgË_cÚjunù +(); + +1694 +EQ_I‹¿tÜ + +G +( +s_cÚj +); + gG +; G++) + +1695 ià((* + gG +). +g‘_cÛf +( +v +)) + +1696 + gŒue +; + +1697 + gçl£ +; + +1702 +R–©iÚ + +pickEQ +(R–©iÚ +r +, +Ëv– +) { + +1703 + gr +. +sim¶ify +(); + +1704 +V¬ŸbË_ID + + gv + = +£t_v¬ +( +Ëv– +); + +1705 +CÚjunù + * + gs_cÚj + = +r +. +sšgË_cÚjunù +(); + +1706 +EQ_I‹¿tÜ + +E +( +s_cÚj +); + gE +; E++) + +1707 ià((* + gE +). +g‘_cÛf +( +v +)) { + +1708 +R–©iÚ + +‹¡_»l +( +r +. +n_£t +()); + +1709 + g‹¡_»l +. +ªd_w™h_EQ +(* +E +); + +1710 + g‹¡_»l +; + +1712 +as£¹ +(0); + +1713 + gr +; + +1717 +R–©iÚ + +pickBound +(R–©iÚ +r +, +Ëv– +, +UB +) { + +1718 + gr +. +sim¶ify +(); + +1719 +V¬ŸbË_ID + + gv + = +£t_v¬ +( +Ëv– +); + +1720 +CÚjunù + * + gs_cÚj + = +r +. +sšgË_cÚjunù +(); + +1721 +GEQ_I‹¿tÜ + +G +( +s_cÚj +); + gG +; G++) { + +1722 ià(( + gUB + && (* + gG +). +g‘_cÛf +( +v +) < 0) + +1723 || (! + gUB + && (* + gG +). +g‘_cÛf +( +v +) > 0) ) { + +1724 +R–©iÚ + +‹¡_»l +( +r +. +n_£t +()); + +1725 + g‹¡_»l +. +ªd_w™h_GEQ +(* +G +); + +1726 + g‹¡_»l +; + +1729 +EQ_I‹¿tÜ + +E +( +s_cÚj +); + gE +; E++) { + +1730 ià((* + gE +). +g‘_cÛf +( +v +)) { + +1731 +R–©iÚ + +‹¡_»l +( +r +. +n_£t +()); + +1732 + g‹¡_»l +. +ªd_w™h_GEQ +(* +E +); + +1733 ià(( + gUB + && (* + gE +). +g‘_cÛf +( +v +) > 0) + +1734 || (! + gUB + && (* + gE +). +g‘_cÛf +( +v +) < 0) ) + +1735 + g‹¡_»l + = +Com¶em’t +( +‹¡_»l +); + +1736 + g‹¡_»l +; + +1739 +as£¹ +(0); + +1740 + gr +; + +1745 +R–©iÚ + +pickOv”h—d +(R–©iÚ +r +, +liáTo +) { + +1746 + gr +. +sim¶ify +(); + +1747 +CÚjunù + * + gs_cÚj + = +r +. +sšgË_cÚjunù +(); + +1748 +GEQ_I‹¿tÜ + +G +( +s_cÚj +); + gG +; G++) { + +1749 +R–©iÚ + +‹¡_»l +( +r +. +n_£t +()); + +1750 + g‹¡_»l +. +ªd_w™h_GEQ +(* +G +); + +1751 +V¬ŸbË_ID + + gv +; + +1752 +cÛf_t + + gpos + = -1; + +1753 +cÛf_t + + gc += 0; + +1754 +CÚ¡r_V¬s_I‹r + +cvi +(* +G +, +çl£ +); + gcvi +; cvi++) + +1755 ià((* + gcvi +). + gcÛf + && (*cvi). + gv¬ +-> +kšd +(è=ð +IÅut_V¬ + + +1756 && (* +cvi +). +v¬ +-> +g‘_pos™iÚ +(è> +pos +) { + +1757 +v + = (* +cvi +). +v¬ +; + +1758 + gpos + = (* +cvi +). +v¬ +-> +g‘_pos™iÚ +(); + +1759 + gc + = (* +cvi +). +cÛf +; + +1762 +årštf +( +DebugFže +,"Coef = %d, constraint = %s\n", + +1763 +c +,(cÚ¡ *) +‹¡_»l +. +´št_fÜmuÏ_to_¡ršg +()); + +1765 + g‹¡_»l +; + +1767 +EQ_I‹¿tÜ + +E +( +s_cÚj +); + gE +; E++) { + +1768 +as£¹ +( +liáTo + >= 1); + +1769 + gpos + = +max +((* +E +). +max_tu¶e_pos +(), +max_fs_¬™y +(*E)+1); + +1773 ià((* + gE +). +has_wždÿrds +(è&& + gpos + < + gliáTo +) { + +1774 +R–©iÚ + +‹¡_»l +( +r +. +n_£t +()); + +1775 + g‹¡_»l +. +ªd_w™h_EQ +(* +E +); + +1776 + g‹¡_»l +; + +1778 ià(!(* + gE +). +has_wždÿrds +(è&& + gpos + <ð +liáTo +) { + +1779 +R–©iÚ + +‹¡_»l +( +r +. +n_£t +()); + +1780 + g‹¡_»l +. +ªd_w™h_EQ +(* +E +); + +1781 + g‹¡_»l +. +sim¶ify +(); + +1782 + g‹¡_»l + = +EQs_to_GEQs +( +‹¡_»l +, +Œue +); + +1783 +pickOv”h—d +( +‹¡_»l +, +liáTo +); + +1786 ià( + gcode_g’_debug +>1) { + +1787 +årštf +( +DebugFže +,"Could‚ot find overhead:\n"); + +1788 + gr +. +´efix_´št +( +DebugFže +); + +1790 + gR–©iÚ +:: +True +( +r +. +n_£t +()); + +1795 +boÞ + +hasBound +( +R–©iÚ + +r +, +Ëv– +, +UB +) { + +1796 + gr +. +sim¶ify +(); + +1797 +V¬ŸbË_ID + + gv + = +£t_v¬ +( +Ëv– +); + +1798 +CÚjunù + * + gs_cÚj + = +r +. +sšgË_cÚjunù +(); + +1799 +GEQ_I‹¿tÜ + +G +( +s_cÚj +); + gG +; G++) { + +1800 ià( + gUB + && (* + gG +). +g‘_cÛf +( +v +è< 0è + gŒue +; + +1801 ià(! + gUB + && (* + gG +). +g‘_cÛf +( +v +è> 0è + gŒue +; + +1803 +EQ_I‹¿tÜ + +E +( +s_cÚj +); + gE +; E++) { + +1804 ià((* + gE +). +g‘_cÛf +( +v +)è + gŒue +; + +1806 + gçl£ +; + +1809 +boÞ + +fšd_ªy_cÚ¡¿št +( +s +, +Ëv– +, +R–©iÚ + & +kr +, +dœeùiÚ +, + +1810 +R–©iÚ + & +S +, +boÞ + +´ox +) { + +1816 +R–©iÚ + + gI + = +´ojeùed_nIS +[ +Ëv– +][ +s +]; + +1817 + gI + = +Gi¡ +( +I +, +cÝy +( +kr +)); + +1818 if( + g´ox +è + gI + = +Aµroxim©e +( +I +); + +1819 ià( +hasBound +( +I +, +Ëv– +, +dœeùiÚ +)) { + +1820 +R–©iÚ + + gpickäom +; + +1821 if( +has_nÚ¡ride_EQ +( +I +, +Ëv– +)) + +1822 + gpickäom + = +pickEQ +( +I +, +Ëv– +); + +1824 + gpickäom + = +pickBound +( +I +, +Ëv– +, +dœeùiÚ +); + +1825 + gS + = +pickOv”h—d +( +pickäom +, +Ëv– +); + +1826 if( + gS +. +is_obvious_utÞogy +()èS = +R–©iÚ +:: +NuÎ +(); + +1827 ! + gS +. +is_nuÎ +(); + +1829 + gçl£ +; + +1833 +boÞ + +has_nÚ¡ride_EQ +( +R–©iÚ + +r +, +Ëv– +) { + +1834 + gr +. +sim¶ify +(); + +1835 +V¬ŸbË_ID + + gv + = +£t_v¬ +( +Ëv– +); + +1836 +CÚjunù + * + gs_cÚj + = +r +. +sšgË_cÚjunù +(); + +1837 +EQ_I‹¿tÜ + +G +( +s_cÚj +); + gG +; G++) + +1838 ià((* + gG +). +g‘_cÛf +( +v +è&& !(*G). +has_wždÿrds +()) + +1839 + gŒue +; + +1840 + gçl£ +; + +1844 +R–©iÚ + +mšMaxOv”h—d +(R–©iÚ +r +, +Ëv– +) { + +1845 + gr +. +fš®ize +(); + +1846 + gr +. +sim¶ify +(); + +1847 +CÚjunù + * + gs_cÚj + = +r +. +sšgË_cÚjunù +(); + +1848 +GEQ_HªdË + + gLBs +[50], + gUBs +[50]; + +1849 + gnumLBs + = 0; + +1850 + gnumUBs + = 0; + +1851 +V¬ŸbË_ID + + gv + = +£t_v¬ +( +Ëv– +); + +1852 +GEQ_I‹¿tÜ + +G +( +s_cÚj +); + gG +; G++èià((*G). +g‘_cÛf +( +v +)) { + +1853 +GEQ_HªdË + + gg + = * +G +; + +1854 ià( + gg +. +g‘_cÛf +( +v +è> 0è + gLBs +[ +numLBs +++] = +g +; + +1855 + gUBs +[ +numUBs +++] = +g +; + +1857 ià( + gnumLBs + <ð1 && +numUBs + <= 1) { + +1858 +R–©iÚ +:: +True +( +r +. +n_£t +()); + +1860 +R–©iÚ + +r1 +( +r +. +n_£t +()); + +1861 +R–©iÚ + +r2 +( +r +. +n_£t +()); + +1862 ià( + gnumLBs + > 1) { + +1864 + gr1 +. +ªd_w™h_GEQ +( +LBs +[0]); + +1865 + gr2 +. +ªd_w™h_GEQ +( +LBs +[1]); + +1866 + gr1 + = +´ojeù_Úto_Ëv–s +( +Difã»nû +( +r1 +, +r2 +), +Ëv– +-1,0); + +1870 + gr1 +. +ªd_w™h_GEQ +( +UBs +[0]); + +1871 + gr2 +. +ªd_w™h_GEQ +( +UBs +[1]); + +1872 + gr1 + = +´ojeù_Úto_Ëv–s +( +Difã»nû +( +r1 +, +r2 +), +Ëv– +-1,0); + +1875 +årštf +( +DebugFže +,"Te¡šg %s\n",(cÚ¡ *) +r1 +. +´št_fÜmuÏ_to_¡ršg +()); + +1876 +årštf +( +DebugFže +,"wžÈ»moved ov”h—d oÀbound oàt%d: %s\n", +Ëv– +, + +1877 (cÚ¡ *) +r +. +´št_fÜmuÏ_to_¡ršg +()); + +1880 +pickOv”h—d +( +r1 +, -1); + +1883 + g¡d +:: +·œ +< +EQ_HªdË +, > +fšd_sim¶e¡_assignm’t +(cÚ¡ +R–©iÚ + & +R_ +, +V¬ŸbË_ID + +v +, cÚ¡ +¡d +:: +veùÜ +< +CG_ouutR•r + *> & +assigÃd_Ú_the_æy +) { + +1884 +R–©iÚ + & +R + = +cÚ¡_ÿ¡ +<R–©iÚ &>( +R_ +); + +1885 +CÚjunù + * + gc + = +R +. +sšgË_cÚjunù +(); + +1887 + gmš_co¡ + = +INT_MAX +; + +1888 +EQ_HªdË + + geq +; + +1889 +EQ_I‹¿tÜ + +ei +( +c +-> +EQs +()); + gei +;ƒi++) + +1890 ià(!(* + gei +). +has_wždÿrds +(è&& (*ei). +g‘_cÛf +( +v +) != 0) { + +1891 +co¡ + = 0; + +1893 ià( +abs +((* +ei +). +g‘_cÛf +( +v +)) != 1) + +1894 +co¡ + += 4; + +1896 + gnum_v¬ + = 0; + +1897 +CÚ¡r_V¬s_I‹r + +cvi +(* +ei +); + gcvi +; cvi++) + +1898 ià((* + gcvi +). + gv¬ + !ð +v +) { + +1899 +num_v¬ +++; + +1900 ià((* + gcvi +). + gv¬ +-> +kšd +(è=ð +Glob®_V¬ + && (* +cvi +). +v¬ +-> +g‘_glob®_v¬ +()-> +¬™y +() > 0) { + +1901 +co¡ + += 10; + +1903 ià( +abs +((* +cvi +). +cÛf +) != 1) + +1904 +co¡ + += 2; + +1905 ià((* + gcvi +). + gv¬ +-> +kšd +(è=ð +IÅut_V¬ + && +assigÃd_Ú_the_æy +[(* +cvi +). +v¬ +-> +g‘_pos™iÚ +()-1] !ð +NULL +) { + +1906 +co¡ + += 5; + +1909 ià((* + gei +). +g‘_cÚ¡ +() != 0) + +1910 +num_v¬ +++; + +1911 ià( + gnum_v¬ + > 1) + +1912 + gco¡ + +ð +num_v¬ + - 1; + +1914 ià( + gco¡ + < + gmš_co¡ +) { + +1915 + gmš_co¡ + = +co¡ +; + +1916 + geq + = * +ei +; + +1920 + g¡d +:: +make_·œ +( +eq +, +mš_co¡ +); + +1923 +max_fs_¬™y +(cÚ¡ +CÚ¡¿št_HªdË + & +c +) { + +1924 + gmax_¬™y +=0; + +1925 +CÚ¡r_V¬s_I‹r + +cv +( +c +); + gcv +; cv++) + +1926 if((* + gcv +). + gv¬ +-> +kšd +(è=ð +Glob®_V¬ +) + +1927 +max_¬™y + = +max +(max_¬™y,(* +cv +). +v¬ +-> +g‘_glob®_v¬ +()-> +¬™y +()); + +1928 + gmax_¬™y +; + + @/usr/include/math.h + +25 #iâdef +_MATH_H + + +26 + #_MATH_H + 1 + + ) + +28 + ~<ã©u»s.h +> + +30 + g__BEGIN_DECLS + + +34 + ~<b™s/huge_v®.h +> + +35 #ifdeà +__USE_ISOC99 + + +36 + ~<b™s/huge_v®f.h +> + +37 + ~<b™s/huge_v®l.h +> + +40 + ~<b™s/šf.h +> + +43 + ~<b™s/Çn.h +> + +47 + ~<b™s/m©hdef.h +> + +54 + #__MATHCALL +( +funùiÚ +, +suffix +, +¬gs +) \ + +55 + `__MATHDECL + ( +_MdoubË_ +, +funùiÚ +, +suffix +, +¬gs +) + + ) + +56 + #__MATHDECL +( +ty³ +, +funùiÚ +, +suffix +, +¬gs +) \ + +57 + `__MATHDECL_1 +( +ty³ +, +funùiÚ +, +suffix +, +¬gs +); \ + +58 + `__MATHDECL_1 +( +ty³ +, + `__CONCAT +( +__ +, +funùiÚ +), +suffix +, +¬gs +) + + ) + +59 + #__MATHCALLX +( +funùiÚ +, +suffix +, +¬gs +, +©Œib +) \ + +60 + `__MATHDECLX + ( +_MdoubË_ +, +funùiÚ +, +suffix +, +¬gs +, +©Œib +) + + ) + +61 + #__MATHDECLX +( +ty³ +, +funùiÚ +, +suffix +, +¬gs +, +©Œib +) \ + +62 + `__MATHDECL_1 +( +ty³ +, +funùiÚ +, +suffix +, +¬gs +è + `__©Œibu‹__ + ( +©Œib +); \ + +63 + `__MATHDECL_1 +( +ty³ +, + `__CONCAT +( +__ +, +funùiÚ +), +suffix +, +¬gs +è + `__©Œibu‹__ + ( +©Œib +) + + ) + +64 + #__MATHDECL_1 +( +ty³ +, +funùiÚ +, +suffix +, +¬gs +) \ + +65
+ty³ + + `__MATH_PRECNAME +( +funùiÚ +, +suffix +è +¬gs + +__THROW + + + ) + +67 + #_MdoubË_ + + + ) + +68 + #__MATH_PRECNAME +( +Çme +, +r +è + `__CONCAT +Òame,r) + + ) + +69 + #_MdoubË_BEGIN_NAMESPACE + +__BEGIN_NAMESPACE_STD + + + ) + +70 + #_MdoubË_END_NAMESPACE + +__END_NAMESPACE_STD + + + ) + +71 + ~<b™s/m©hÿÎs.h +> + +72 #undeà +_MdoubË_ + + +73 #undeà +_MdoubË_BEGIN_NAMESPACE + + +74 #undeà +_MdoubË_END_NAMESPACE + + +75 #undeà +__MATH_PRECNAME + + +77 #ià +defšed + +__USE_MISC + || defšed +__USE_ISOC99 + + +83 #iâdeà +_Mæßt_ + + +84 + #_Mæßt_ + + + ) + +86 + #_MdoubË_ + +_Mæßt_ + + + ) + +87 #ifdeà +__STDC__ + + +88 + #__MATH_PRECNAME +( +Çme +, +r +èÇme## +f +## + ) +r + +90 + #__MATH_PRECNAME +( +Çme +, +r +èÇm +f + + ) +r + +92 + #_MdoubË_BEGIN_NAMESPACE + +__BEGIN_NAMESPACE_C99 + + + ) + +93 + #_MdoubË_END_NAMESPACE + +__END_NAMESPACE_C99 + + + ) + +94 + ~<b™s/m©hÿÎs.h +> + +95 #undeà +_MdoubË_ + + +96 #undeà +_MdoubË_BEGIN_NAMESPACE + + +97 #undeà +_MdoubË_END_NAMESPACE + + +98 #undeà +__MATH_PRECNAME + + +100 #ià( +__STDC__ + - 0 || +__GNUC__ + - 0) \ + +101 && (! +defšed + +__NO_LONG_DOUBLE_MATH + \ + +102 || +defšed + +__LDBL_COMPAT + \ + +103 || ! +defšed + +_LIBC +) + +104 #ifdeà +__LDBL_COMPAT + + +106 #ifdeà +__USE_ISOC99 + + +107
+ $__Ædbl_Ãx‰ow¬df + ( +__x +, +__y +) + +108 +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)); + +109 #ifdeà +__REDIRECT_NTH + + +110
+ `__REDIRECT_NTH + ( +Ãx‰ow¬df +, ( +__x +, +__y +), + +111 +__Ædbl_Ãx‰ow¬df +) + +112 + `__©Œibu‹__ + (( +__cÚ¡__ +)); + +113
+ `__REDIRECT_NTH + ( +Ãx‰ow¬d +, ( +__x +, +__y +), + +114 +Ãxá” +è + `__©Œibu‹__ + (( +__cÚ¡__ +)); + +115
+ `__REDIRECT_NTH + ( +Ãx‰ow¬dl +, + +116 ( +__x +, +__y +), + +117 +Ãxá” +è + `__©Œibu‹__ + (( +__cÚ¡__ +)); + +122 #ià +defšed + +__LDBL_COMPAT + || defšed +__NO_LONG_DOUBLE_MATH + + +124 #undeà +__MATHDECL_1 + + +125 + #__MATHDECL_2 +( +ty³ +, +funùiÚ +, +suffix +, +¬gs +, +®Ÿs +) \ + +126
+ty³ + + `__REDIRECT_NTH +( + `__MATH_PRECNAME +( +funùiÚ +, +suffix +), \ + +127 +¬gs +, +®Ÿs +) + + ) + +128 + #__MATHDECL_1 +( +ty³ +, +funùiÚ +, +suffix +, +¬gs +) \ + +129 + `__MATHDECL_2 +( +ty³ +, +funùiÚ +, +suffix +, +¬gs +, + `__CONCAT +(funùiÚ,suffix)) + + ) + +134 #iâdeà +_MlÚg_doubË_ + + +135 + #_MlÚg_doubË_ + + + ) + +137 + #_MdoubË_ + +_MlÚg_doubË_ + + + ) + +138 #ifdeà +__STDC__ + + +139 + #__MATH_PRECNAME +( +Çme +, +r +èÇme## +l +## + ) +r + +141 + #__MATH_PRECNAME +( +Çme +, +r +èÇm +l + + ) +r + +143 + #_MdoubË_BEGIN_NAMESPACE + +__BEGIN_NAMESPACE_C99 + + + ) + +144 + #_MdoubË_END_NAMESPACE + +__END_NAMESPACE_C99 + + + ) + +145 + ~<b™s/m©hÿÎs.h +> + +146 #undeà +_MdoubË_ + + +147 #undeà +_MdoubË_BEGIN_NAMESPACE + + +148 #undeà +_MdoubË_END_NAMESPACE + + +149 #undeà +__MATH_PRECNAME + + +154 #undeà +__MATHDECL_1 + + +155 #undeà +__MATHDECL + + +156 #undeà +__MATHCALL + + +159 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN + + +161
+signgam +; + +166 #ifdeà +__USE_ISOC99 + + +204 +FP_NAN +, + +205 + #FP_NAN + +FP_NAN + + + ) + +206 +FP_INFINITE +, + +207 + #FP_INFINITE + +FP_INFINITE + + + ) + +208 +FP_ZERO +, + +209 + #FP_ZERO + +FP_ZERO + + + ) + +210 +FP_SUBNORMAL +, + +211 + #FP_SUBNORMAL + +FP_SUBNORMAL + + + ) + +212 +FP_NORMAL + + +213 + #FP_NORMAL + +FP_NORMAL + + + ) + +217 #ifdeà +__NO_LONG_DOUBLE_MATH + + +218 + #åþassify +( +x +) \ + +219 ( ( +x +è=ð (è? + `__åþassifyf + (xè: + `__åþassify + (x)) + + ) + +221 + #åþassify +( +x +) \ + +222 ( ( +x +) == () \ + +223 ? + `__åþassifyf + ( +x +) \ + +224 : ( +x +) == () \ + +225 ? + `__åþassify + ( +x +è: + `__åþassifyl + (x)) + + ) + +229 #ifdeà +__NO_LONG_DOUBLE_MATH + + +230 + #signb™ +( +x +) \ + +231 ( ( +x +è=ð (è? + `__signb™f + (xè: + `__signb™ + (x)) + + ) + +233 + #signb™ +( +x +) \ + +234 ( ( +x +) == () \ + +235 ? + `__signb™f + ( +x +) \ + +236 : ( +x +) == () \ + +237 ? + `__signb™ + ( +x +è: + `__signb™l + (x)) + + ) + +241 #ifdeà +__NO_LONG_DOUBLE_MATH + + +242 + #isfš™e +( +x +) \ + +243 ( ( +x +è=ð (è? + `__fš™ef + (xè: + `__fš™e + (x)) + + ) + +245 + #isfš™e +( +x +) \ + +246 ( ( +x +) == () \ + +247 ? + `__fš™ef + ( +x +) \ + +248 : ( +x +) == () \ + +249 ? + `__fš™e + ( +x +è: + `__fš™– + (x)) + + ) + +253 + #i¢Üm® +( +x +è( + `åþassify + (xè=ð +FP_NORMAL +) + + ) + +257 #ifdeà +__NO_LONG_DOUBLE_MATH + + +258 + #i¢ª +( +x +) \ + +259 ( ( +x +è=ð (è? + `__i¢ªf + (xè: + `__i¢ª + (x)) + + ) + +261 + #i¢ª +( +x +) \ + +262 ( ( +x +) == () \ + +263 ? + `__i¢ªf + ( +x +) \ + +264 : ( +x +) == () \ + +265 ? + `__i¢ª + ( +x +è: + `__i¢ªl + (x)) + + ) + +269 #ifdeà +__NO_LONG_DOUBLE_MATH + + +270 + #isšf +( +x +) \ + +271 ( ( +x +è=ð (è? + `__isšff + (xè: + `__isšf + (x)) + + ) + +273 + #isšf +( +x +) \ + +274 ( ( +x +) == () \ + +275 ? + `__isšff + ( +x +) \ + +276 : ( +x +) == () \ + +277 ? + `__isšf + ( +x +è: + `__isšæ + (x)) + + ) + +281 + #MATH_ERRNO + 1 + + ) + +282 + #MATH_ERREXCEPT + 2 + + ) + +287 #iâdeà +__FAST_MATH__ + + +288 + #m©h_”rhªdlšg + ( +MATH_ERRNO + | +MATH_ERREXCEPT +) + + ) + +293 #ifdef +__USE_MISC + + +297 +_IEEE_ + = -1, + +298 +_SVID_ +, + +299 +_XOPEN_ +, + +300 +_POSIX_ +, + +301 +_ISOC_ + + +302 } + t_LIB_VERSION_TYPE +; + +307
+_LIB_VERSION_TYPE + +_LIB_VERSION +; + +311 #ifdeà +__USE_SVID + + +317 #ifdeà +__ýlu¥lus + + +318 +__exû±iÚ + + +320 +exû±iÚ + + +323 +ty³ +; + +324 * +Çme +; + +325 +¬g1 +; + +326 +¬g2 +; + +327 +»tv® +; + +328 + } +}; + +330 #ifdeà +__ýlu¥lus + + +331
+ $m©h”r + ( +__exû±iÚ + * +__exc +è + `throw + (); + +333
+ `m©h”r + ( +exû±iÚ + * +__exc +); + +336 + #X_TLOSS + 1.41484755040568800000e+16 + + ) + +339 + #DOMAIN + 1 + + ) + +340 + #SING + 2 + + ) + +341 + #OVERFLOW + 3 + + ) + +342 + #UNDERFLOW + 4 + + ) + +343 + #TLOSS + 5 + + ) + +344 + #PLOSS + 6 + + ) + +347 + #HUGE + 3.40282347e+38F + + ) + +351 #ifdeà +__USE_XOPEN + + +353 + #MAXFLOAT + 3.40282347e+38F + + ) + +360 #ià +defšed + +__USE_BSD + || defšed +__USE_XOPEN + + +361 + #M_E + 2.7182818284590452354 + + ) + +362 + #M_LOG2E + 1.4426950408889634074 + + ) + +363 + #M_LOG10E + 0.43429448190325182765 + + ) + +364 + #M_LN2 + 0.69314718055994530942 + + ) + +365 + #M_LN10 + 2.30258509299404568402 + + ) + +366 + #M_PI + 3.14159265358979323846 + + ) + +367 + #M_PI_2 + 1.57079632679489661923 + + ) + +368 + #M_PI_4 + 0.78539816339744830962 + + ) + +369 + #M_1_PI + 0.31830988618379067154 + + ) + +370 + #M_2_PI + 0.63661977236758134308 + + ) + +371 + #M_2_SQRTPI + 1.12837916709551257390 + + ) + +372 + #M_SQRT2 + 1.41421356237309504880 + + ) + +373 + #M_SQRT1_2 + 0.70710678118654752440 + + ) + +379 #ifdeà +__USE_GNU + + +380 + #M_El + 2.7182818284590452353602874713526625L + + ) + +381 + #M_LOG2El + 1.4426950408889634073599246810018921L + + ) + +382 + #M_LOG10El + 0.4342944819032518276511289189166051L + + ) + +383 + #M_LN2l + 0.6931471805599453094172321214581766L + + ) + +384 + #M_LN10l + 2.3025850929940456840179914546843642L + + ) + +385 + #M_PIl + 3.1415926535897932384626433832795029L + + ) + +386 + #M_PI_2l + 1.5707963267948966192313216916397514L + + ) + +387 + #M_PI_4l + 0.7853981633974483096156608458198757L + + ) + +388 + #M_1_PIl + 0.3183098861837906715377675267450287L + + ) + +389 + #M_2_PIl + 0.6366197723675813430755350534900574L + + ) + +390 + #M_2_SQRTPIl + 1.1283791670955125738961589031215452L + + ) + +391 + #M_SQRT2l + 1.4142135623730950488016887242096981L + + ) + +392 + #M_SQRT1_2l + 0.7071067811865475244008443621048490L + + ) + +399 #ià +defšed + +__STRICT_ANSI__ + && !defšed +__NO_MATH_INLINES + + +400 + #__NO_MATH_INLINES + 1 + + ) + +403 #ià +defšed + +__USE_ISOC99 + && + `__GNUC_PREREQ +(2,97) + +410 + #isg»©” +( +x +, +y +è + `__bužtš_isg»©” +(x, y) + + ) + +411 + #isg»©”equ® +( +x +, +y +è + `__bužtš_isg»©”equ® +(x, y) + + ) + +412 + #i¦ess +( +x +, +y +è + `__bužtš_i¦ess +(x, y) + + ) + +413 + #i¦es£qu® +( +x +, +y +è + `__bužtš_i¦es£qu® +(x, y) + + ) + +414 + #i¦essg»©” +( +x +, +y +è + `__bužtš_i¦essg»©” +(x, y) + + ) + +415 + #isunÜd”ed +( +u +, +v +è + `__bužtš_isunÜd”ed +(u, v) + + ) + +419 #ifdeà +__USE_EXTERN_INLINES + + +420 + ~<b™s/m©hšlše.h +> + +423 #ifdeà +__USE_ISOC99 + + +427 #iâdeà +isg»©” + + +428 + #isg»©” +( +x +, +y +) \ + +429 ( +__ex‹nsiÚ__ + \ + +430 ({ + `__ty³of__ +( +x +è +__x + = (x); __ty³of__( +y +è +__y + = (y); \ + +431 ! + `isunÜd”ed + ( +__x +, +__y +è&& __x > __y; + } +})) + + ) + +435 #iâdeà +isg»©”equ® + + +436 + #isg»©”equ® +( +x +, +y +) \ + +437 ( +__ex‹nsiÚ__ + \ + +438 ({ + `__ty³of__ +( +x +è +__x + = (x); __ty³of__( +y +è +__y + = (y); \ + +439 ! + `isunÜd”ed + ( +__x +, +__y +è&& __x >ð__y; })) + + ) + +443 #iâdeà +i¦ess + + +444 + #i¦ess +( +x +, +y +) \ + +445 ( +__ex‹nsiÚ__ + \ + +446 ({ + `__ty³of__ +( +x +è +__x + = (x); __ty³of__( +y +è +__y + = (y); \ + +447 ! + `isunÜd”ed + ( +__x +, +__y +è&& __x < __y; })) + + ) + +451 #iâdeà +i¦es£qu® + + +452 + #i¦es£qu® +( +x +, +y +) \ + +453 ( +__ex‹nsiÚ__ + \ + +454 ({ + `__ty³of__ +( +x +è +__x + = (x); __ty³of__( +y +è +__y + = (y); \ + +455 ! + `isunÜd”ed + ( +__x +, +__y +è&& __x <ð__y; })) + + ) + +459 #iâdeà +i¦essg»©” + + +460 + #i¦essg»©” +( +x +, +y +) \ + +461 ( +__ex‹nsiÚ__ + \ + +462 ({ + `__ty³of__ +( +x +è +__x + = (x); __ty³of__( +y +è +__y + = (y); \ + +463 ! + `isunÜd”ed + ( +__x +, +__y +è&& (__x < __y || __y < __x); })) + + ) + +467 #iâdeà +isunÜd”ed + + +468 + #isunÜd”ed +( +u +, +v +) \ + +469 ( +__ex‹nsiÚ__ + \ + +470 ({ + `__ty³of__ +( +u +è +__u + = (u); __ty³of__( +v +è +__v + = (v); \ + +471 + `åþassify + ( +__u +è=ð +FP_NAN + || fpþassify ( +__v +è=ðFP_NAN; })) + + ) + +476 + g__END_DECLS + + + @/usr/include/stdio.h + +24 #iâdeà +_STDIO_H + + +26 #ià! +defšed + +__Ãed_FILE + && !defšed +__Ãed___FILE + + +27 + #_STDIO_H + 1 + + ) + +28 + ~<ã©u»s.h +> + +30 + g__BEGIN_DECLS + + +32 + #__Ãed_size_t + + + ) + +33 + #__Ãed_NULL + + + ) + +34 + ~<¡ddef.h +> + +36 + ~<b™s/ty³s.h +> + +37 + #__Ãed_FILE + + + ) + +38 + #__Ãed___FILE + + + ) + +42 #ià! +defšed + +__FILE_defšed + && defšed +__Ãed_FILE + + +45 + g_IO_FILE +; + +47 +__BEGIN_NAMESPACE_STD + + +49 +_IO_FILE + + tFILE +; + +50 + g__END_NAMESPACE_STD + + +51 #ià +defšed + +__USE_LARGEFILE64 + || defšed +__USE_SVID + || defšed +__USE_POSIX + \ + +52 || +defšed + + g__USE_BSD + || defšed + g__USE_ISOC99 + || defšed + g__USE_XOPEN + \ + +53 || +defšed + +__USE_POSIX2 + + +54 + $__USING_NAMESPACE_STD +( +FILE +) + +57 + #__FILE_defšed + 1 + + ) + +59 #undeà +__Ãed_FILE + + +62 #ià! +defšed + +____FILE_defšed + && defšed +__Ãed___FILE + + +65 +_IO_FILE + + t__FILE +; + +67 + #____FILE_defšed + 1 + + ) + +69 #undeà +__Ãed___FILE + + +72 #ifdef +_STDIO_H + + +73 + #_STDIO_USES_IOSTREAM + + + ) + +75 + ~<libio.h +> + +77 #ifdeà +__USE_XOPEN + + +78 #ifdeà +__GNUC__ + + +79 #iâdeà +_VA_LIST_DEFINED + + +80 +_G_va_li¡ + + tva_li¡ +; + +81 + #_VA_LIST_DEFINED + + + ) + +84 + ~<¡d¬g.h +> + +89 +__BEGIN_NAMESPACE_STD + + +90 #iâdeà +__USE_FILE_OFFSET64 + + +91 +_G_åos_t + + tåos_t +; + +93 +_G_åos64_t + + tåos_t +; + +95 +__END_NAMESPACE_STD + + +96 #ifdeà +__USE_LARGEFILE64 + + +97 +_G_åos64_t + + tåos64_t +; + +101 + #_IOFBF + 0 + + ) + +102 + #_IOLBF + 1 + + ) + +103 + #_IONBF + 2 + + ) + +107 #iâdeà +BUFSIZ + + +108 + #BUFSIZ + +_IO_BUFSIZ + + + ) + +114 #iâdeà +EOF + + +115 + #EOF + (-1) + + ) + +121 + #SEEK_SET + 0 + + ) + +122 + #SEEK_CUR + 1 + + ) + +123 + #SEEK_END + 2 + + ) + +126 #ià +defšed + +__USE_SVID + || defšed +__USE_XOPEN + + +128 + #P_tmpdœ + "/tmp" + + ) + +141 + ~<b™s/¡dio_lim.h +> + +145
+_IO_FILE + * +¡dš +; + +146
+_IO_FILE + * +¡dout +; + +147
+_IO_FILE + * +¡d”r +; + +149 + #¡dš + +¡dš + + + ) + +150 + #¡dout + +¡dout + + + ) + +151 + #¡d”r + +¡d”r + + + ) + +153 +__BEGIN_NAMESPACE_STD + + +155
+ $»move + ( +__cÚ¡ + * +__fž’ame +è +__THROW +; + +157
+ $»Çme + ( +__cÚ¡ + * +__Þd +, __cÚ¡ * +__Ãw +è +__THROW +; + +158 +__END_NAMESPACE_STD + + +160 #ifdeà +__USE_ATFILE + + +162
+ $»Çm—t + ( +__Þdfd +, +__cÚ¡ + * +__Þd +, +__Ãwfd +, + +163 +__cÚ¡ + * +__Ãw +è +__THROW +; + +166 +__BEGIN_NAMESPACE_STD + + +171 #iâdeà +__USE_FILE_OFFSET64 + + +172
+FILE + * + $tmpfže + ( è +__wur +; + +174 #ifdeà +__REDIRECT + + +175
+FILE + * + `__REDIRECT + ( +tmpfže +, ( ), +tmpfže64 +è +__wur +; + +177 + #tmpfže + +tmpfže64 + + + ) + +181 #ifdeà +__USE_LARGEFILE64 + + +182
+FILE + * + $tmpfže64 + ( è +__wur +; + +186
* + $tm²am + (* +__s +è +__THROW + +__wur +; + +187 +__END_NAMESPACE_STD + + +189 #ifdeà +__USE_MISC + + +192
* + $tm²am_r + (* +__s +è +__THROW + +__wur +; + +196 #ià +defšed + +__USE_SVID + || defšed +__USE_XOPEN + + +204
* + $‹m²am + ( +__cÚ¡ + * +__dœ +, __cÚ¡ * +__pfx +) + +205 +__THROW + +__©Œibu‹_m®loc__ + +__wur +; + +209 +__BEGIN_NAMESPACE_STD + + +214
+ `fþo£ + ( +FILE + * +__¡»am +); + +219
+ `fæush + ( +FILE + * +__¡»am +); + +220 +__END_NAMESPACE_STD + + +222 #ifdeà +__USE_MISC + + +229
+ `fæush_uÆocked + ( +FILE + * +__¡»am +); + +232 #ifdeà +__USE_GNU + + +239
+ `fþo£®l + ( ); + +243 +__BEGIN_NAMESPACE_STD + + +244 #iâdeà +__USE_FILE_OFFSET64 + + +249
+FILE + * + $fÝ’ + ( +__cÚ¡ + * +__»¡riù + +__fž’ame +, + +250 +__cÚ¡ + * +__»¡riù + +__modes +è +__wur +; + +255
+FILE + * + $äeÝ’ + ( +__cÚ¡ + * +__»¡riù + +__fž’ame +, + +256 +__cÚ¡ + * +__»¡riù + +__modes +, + +257 +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +259 #ifdeà +__REDIRECT + + +260
+FILE + * + `__REDIRECT + ( +fÝ’ +, ( +__cÚ¡ + * +__»¡riù + +__fž’ame +, + +261 +__cÚ¡ + * +__»¡riù + +__modes +), +fÝ’64 +) + +262 +__wur +; + +263
+FILE + * + `__REDIRECT + ( +äeÝ’ +, ( +__cÚ¡ + * +__»¡riù + +__fž’ame +, + +264 +__cÚ¡ + * +__»¡riù + +__modes +, + +265 +FILE + * +__»¡riù + +__¡»am +), +äeÝ’64 +) + +266 +__wur +; + +268 + #fÝ’ + +fÝ’64 + + + ) + +269 + #äeÝ’ + +äeÝ’64 + + + ) + +272 +__END_NAMESPACE_STD + + +273 #ifdeà +__USE_LARGEFILE64 + + +274
+FILE + * + $fÝ’64 + ( +__cÚ¡ + * +__»¡riù + +__fž’ame +, + +275 +__cÚ¡ + * +__»¡riù + +__modes +è +__wur +; + +276
+FILE + * + $äeÝ’64 + ( +__cÚ¡ + * +__»¡riù + +__fž’ame +, + +277 +__cÚ¡ + * +__»¡riù + +__modes +, + +278 +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +281 #ifdef +__USE_POSIX + + +283
+FILE + * + $fdÝ’ + ( +__fd +, +__cÚ¡ + * +__modes +è +__THROW + +__wur +; + +286 #ifdef +__USE_GNU + + +289
+FILE + * + $fÝ’cook› + ( * +__»¡riù + +__magic_cook› +, + +290 +__cÚ¡ + * +__»¡riù + +__modes +, + +291 +_IO_cook›_io_funùiÚs_t + +__io_funcs +è +__THROW + +__wur +; + +294 #ifdeà +__USE_XOPEN2K8 + + +296
+FILE + * + $fmemÝ’ + ( * +__s +, +size_t + +__Ën +, +__cÚ¡ + * +__modes +) + +297 +__THROW + +__wur +; + +302
+FILE + * + $Ý’_mem¡»am + (** +__buæoc +, +size_t + * +__siz–oc +è +__THROW + +__wur +; + +306 +__BEGIN_NAMESPACE_STD + + +309
+ $£tbuf + ( +FILE + * +__»¡riù + +__¡»am +, *__»¡riù +__buf +è +__THROW +; + +313
+ $£tvbuf + ( +FILE + * +__»¡riù + +__¡»am +, *__»¡riù +__buf +, + +314 +__modes +, +size_t + +__n +è +__THROW +; + +315 +__END_NAMESPACE_STD + + +317 #ifdef +__USE_BSD + + +320
+ $£tbufãr + ( +FILE + * +__»¡riù + +__¡»am +, *__»¡riù +__buf +, + +321 +size_t + +__size +è +__THROW +; + +324
+ $£Žšebuf + ( +FILE + * +__¡»am +è +__THROW +; + +328 +__BEGIN_NAMESPACE_STD + + +333
+ `årštf + ( +FILE + * +__»¡riù + +__¡»am +, + +334 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...); + +339
+ `´štf + ( +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...); + +341
+ $¥rštf + (* +__»¡riù + +__s +, + +342 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...è +__THROW +; + +348
+ `vårštf + ( +FILE + * +__»¡riù + +__s +, +__cÚ¡ + *__»¡riù +__fÜm© +, + +349 +_G_va_li¡ + +__¬g +); + +354
+ `v´štf + ( +__cÚ¡ + * +__»¡riù + +__fÜm© +, +_G_va_li¡ + +__¬g +); + +356
+ $v¥rštf + (* +__»¡riù + +__s +, +__cÚ¡ + *__»¡riù +__fÜm© +, + +357 +_G_va_li¡ + +__¬g +è +__THROW +; + +358 +__END_NAMESPACE_STD + + +360 #ià +defšed + +__USE_BSD + || defšed +__USE_ISOC99 + || defšed +__USE_UNIX98 + + +361 +__BEGIN_NAMESPACE_C99 + + +363
+ $¢´štf + (* +__»¡riù + +__s +, +size_t + +__maxËn +, + +364 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...) + +365 +__THROW + + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__´štf__ +, 3, 4))); + +367
+ $v¢´štf + (* +__»¡riù + +__s +, +size_t + +__maxËn +, + +368 +__cÚ¡ + * +__»¡riù + +__fÜm© +, +_G_va_li¡ + +__¬g +) + +369 +__THROW + + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__´štf__ +, 3, 0))); + +370 +__END_NAMESPACE_C99 + + +373 #ifdeà +__USE_GNU + + +376
+ $va¥rštf + (** +__»¡riù + +__±r +, +__cÚ¡ + *__»¡riù +__f +, + +377 +_G_va_li¡ + +__¬g +) + +378 +__THROW + + `__©Œibu‹__ + (( + $__fÜm©__ + ( +__´štf__ +, 2, 0))è +__wur +; + +379
+ $__a¥rštf + (** +__»¡riù + +__±r +, + +380 +__cÚ¡ + * +__»¡riù + +__fmt +, ...) + +381 +__THROW + + `__©Œibu‹__ + (( + $__fÜm©__ + ( +__´štf__ +, 2, 3))è +__wur +; + +382
+ $a¥rštf + (** +__»¡riù + +__±r +, + +383 +__cÚ¡ + * +__»¡riù + +__fmt +, ...) + +384 +__THROW + + `__©Œibu‹__ + (( + $__fÜm©__ + ( +__´štf__ +, 2, 3))è +__wur +; + +387 #ifdeà +__USE_XOPEN2K8 + + +394
+ $vd´štf + ( +__fd +, +__cÚ¡ + * +__»¡riù + +__fmt +, + +395 +_G_va_li¡ + +__¬g +) + +396 + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__´štf__ +, 2, 0))); + +397
+ $d´štf + ( +__fd +, +__cÚ¡ + * +__»¡riù + +__fmt +, ...) + +398 + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__´štf__ +, 2, 3))); + +402 +__BEGIN_NAMESPACE_STD + + +407
+ $fsÿnf + ( +FILE + * +__»¡riù + +__¡»am +, + +408 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...è +__wur +; + +413
+ $sÿnf + ( +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...è +__wur +; + +415
+ $ssÿnf + ( +__cÚ¡ + * +__»¡riù + +__s +, + +416 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...è +__THROW +; + +418 #ià +defšed + +__USE_ISOC99 + && !defšed +__USE_GNU + \ + +419 && (! +defšed + +__LDBL_COMPAT + || !defšed +__REDIRECT +) \ + +420 && ( +defšed + +__STRICT_ANSI__ + || defšed +__USE_XOPEN2K +) + +421 #ifdeà +__REDIRECT + + +425
+ `__REDIRECT + ( +fsÿnf +, ( +FILE + * +__»¡riù + +__¡»am +, + +426 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...), + +427 +__isoc99_fsÿnf +è +__wur +; + +428
+ `__REDIRECT + ( +sÿnf +, ( +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...), + +429 +__isoc99_sÿnf +è +__wur +; + +430
+ `__REDIRECT + ( +ssÿnf +, ( +__cÚ¡ + * +__»¡riù + +__s +, + +431 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...), + +432 +__isoc99_ssÿnf +è +__THROW +; + +434
+ $__isoc99_fsÿnf + ( +FILE + * +__»¡riù + +__¡»am +, + +435 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...è +__wur +; + +436
+ $__isoc99_sÿnf + ( +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...è +__wur +; + +437
+ $__isoc99_ssÿnf + ( +__cÚ¡ + * +__»¡riù + +__s +, + +438 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...è +__THROW +; + +439 + #fsÿnf + +__isoc99_fsÿnf + + + ) + +440 + #sÿnf + +__isoc99_sÿnf + + + ) + +441 + #ssÿnf + +__isoc99_ssÿnf + + + ) + +445 +__END_NAMESPACE_STD + + +447 #ifdef +__USE_ISOC99 + + +448 +__BEGIN_NAMESPACE_C99 + + +453
+ $vfsÿnf + ( +FILE + * +__»¡riù + +__s +, +__cÚ¡ + *__»¡riù +__fÜm© +, + +454 +_G_va_li¡ + +__¬g +) + +455 + `__©Œibu‹__ + (( + $__fÜm©__ + ( +__sÿnf__ +, 2, 0))è +__wur +; + +461
+ $vsÿnf + ( +__cÚ¡ + * +__»¡riù + +__fÜm© +, +_G_va_li¡ + +__¬g +) + +462 + `__©Œibu‹__ + (( + $__fÜm©__ + ( +__sÿnf__ +, 1, 0))è +__wur +; + +465
+ $vssÿnf + ( +__cÚ¡ + * +__»¡riù + +__s +, + +466 +__cÚ¡ + * +__»¡riù + +__fÜm© +, +_G_va_li¡ + +__¬g +) + +467 +__THROW + + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__sÿnf__ +, 2, 0))); + +469 #ià! +defšed + +__USE_GNU + \ + +470 && (! +defšed + +__LDBL_COMPAT + || !defšed +__REDIRECT +) \ + +471 && ( +defšed + +__STRICT_ANSI__ + || defšed +__USE_XOPEN2K +) + +472 #ifdeà +__REDIRECT + + +476
+ `__REDIRECT + ( +vfsÿnf +, + +477 ( +FILE + * +__»¡riù + +__s +, + +478 +__cÚ¡ + * +__»¡riù + +__fÜm© +, +_G_va_li¡ + +__¬g +), + +479 +__isoc99_vfsÿnf +) + +480 + `__©Œibu‹__ + (( + $__fÜm©__ + ( +__sÿnf__ +, 2, 0))è +__wur +; + +481
+ `__REDIRECT + ( +vsÿnf +, ( +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +482 +_G_va_li¡ + +__¬g +), +__isoc99_vsÿnf +) + +483 + `__©Œibu‹__ + (( + $__fÜm©__ + ( +__sÿnf__ +, 1, 0))è +__wur +; + +484
+ `__REDIRECT + ( +vssÿnf +, + +485 ( +__cÚ¡ + * +__»¡riù + +__s +, + +486 +__cÚ¡ + * +__»¡riù + +__fÜm© +, +_G_va_li¡ + +__¬g +), + +487 +__isoc99_vssÿnf +) + +488 +__THROW + + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__sÿnf__ +, 2, 0))); + +490
+ $__isoc99_vfsÿnf + ( +FILE + * +__»¡riù + +__s +, + +491 +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +492 +_G_va_li¡ + +__¬g +è +__wur +; + +493
+ $__isoc99_vsÿnf + ( +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +494 +_G_va_li¡ + +__¬g +è +__wur +; + +495
+ $__isoc99_vssÿnf + ( +__cÚ¡ + * +__»¡riù + +__s +, + +496 +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +497 +_G_va_li¡ + +__¬g +è +__THROW +; + +498 + #vfsÿnf + +__isoc99_vfsÿnf + + + ) + +499 + #vsÿnf + +__isoc99_vsÿnf + + + ) + +500 + #vssÿnf + +__isoc99_vssÿnf + + + ) + +504 +__END_NAMESPACE_C99 + + +508 +__BEGIN_NAMESPACE_STD + + +513
+ `fg‘c + ( +FILE + * +__¡»am +); + +514
+ `g‘c + ( +FILE + * +__¡»am +); + +520
+ `g‘ch¬ + ( ); + +521 +__END_NAMESPACE_STD + + +525 + #g‘c +( +_å +è + `_IO_g‘c + (_å) + + ) + +527 #ià +defšed + +__USE_POSIX + || defšed +__USE_MISC + + +532
+ `g‘c_uÆocked + ( +FILE + * +__¡»am +); + +533
+ `g‘ch¬_uÆocked + ( ); + +536 #ifdeà +__USE_MISC + + +543
+ `fg‘c_uÆocked + ( +FILE + * +__¡»am +); + +547 +__BEGIN_NAMESPACE_STD + + +555
+ `åutc + ( +__c +, +FILE + * +__¡»am +); + +556
+ `putc + ( +__c +, +FILE + * +__¡»am +); + +562
+ `putch¬ + ( +__c +); + +563 +__END_NAMESPACE_STD + + +567 + #putc +( +_ch +, +_å +è + `_IO_putc + (_ch, _å) + + ) + +569 #ifdeà +__USE_MISC + + +576
+ `åutc_uÆocked + ( +__c +, +FILE + * +__¡»am +); + +579 #ià +defšed + +__USE_POSIX + || defšed +__USE_MISC + + +584
+ `putc_uÆocked + ( +__c +, +FILE + * +__¡»am +); + +585
+ `putch¬_uÆocked + ( +__c +); + +589 #ià +defšed + +__USE_SVID + || defšed +__USE_MISC + \ + +590 || ( +defšed + +__USE_XOPEN + && !defšed +__USE_XOPEN2K +) + +592
+ `g‘w + ( +FILE + * +__¡»am +); + +595
+ `putw + ( +__w +, +FILE + * +__¡»am +); + +599 +__BEGIN_NAMESPACE_STD + + +604
* + $fg‘s + (* +__»¡riù + +__s +, +__n +, +FILE + *__»¡riù +__¡»am +) + +605 +__wur +; + +612
* + $g‘s + (* +__s +è +__wur +; + +613 +__END_NAMESPACE_STD + + +615 #ifdeà +__USE_GNU + + +622
* + $fg‘s_uÆocked + (* +__»¡riù + +__s +, +__n +, + +623 +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +627 #ifdef +__USE_XOPEN2K8 + + +638
+_IO_ssize_t + + $__g‘d–im + (** +__»¡riù + +__lš•Œ +, + +639 +size_t + * +__»¡riù + +__n +, +__d–im™” +, + +640 +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +641
+_IO_ssize_t + + $g‘d–im + (** +__»¡riù + +__lš•Œ +, + +642 +size_t + * +__»¡riù + +__n +, +__d–im™” +, + +643 +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +651
+_IO_ssize_t + + $g‘lše + (** +__»¡riù + +__lš•Œ +, + +652 +size_t + * +__»¡riù + +__n +, + +653 +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +657 +__BEGIN_NAMESPACE_STD + + +662
+ `åuts + ( +__cÚ¡ + * +__»¡riù + +__s +, +FILE + *__»¡riù +__¡»am +); + +668
+ `puts + ( +__cÚ¡ + * +__s +); + +675
+ `ung‘c + ( +__c +, +FILE + * +__¡»am +); + +682
+size_t + + $ä—d + ( * +__»¡riù + +__±r +, +size_t + +__size +, + +683 +size_t + +__n +, +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +688
+size_t + + `fwr™e + ( +__cÚ¡ + * +__»¡riù + +__±r +, size_ˆ +__size +, + +689 +size_t + +__n +, +FILE + * +__»¡riù + +__s +); + +690 +__END_NAMESPACE_STD + + +692 #ifdeà +__USE_GNU + + +699
+ `åuts_uÆocked + ( +__cÚ¡ + * +__»¡riù + +__s +, + +700 +FILE + * +__»¡riù + +__¡»am +); + +703 #ifdeà +__USE_MISC + + +710
+size_t + + $ä—d_uÆocked + ( * +__»¡riù + +__±r +, +size_t + +__size +, + +711 +size_t + +__n +, +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +712
+size_t + + `fwr™e_uÆocked + ( +__cÚ¡ + * +__»¡riù + +__±r +, size_ˆ +__size +, + +713 +size_t + +__n +, +FILE + * +__»¡riù + +__¡»am +); + +717 +__BEGIN_NAMESPACE_STD + + +722
+ `f£ek + ( +FILE + * +__¡»am +, +__off +, +__wh’û +); + +727
+ $á–l + ( +FILE + * +__¡»am +è +__wur +; + +732
+ `»wšd + ( +FILE + * +__¡»am +); + +733 +__END_NAMESPACE_STD + + +740 #ià +defšed + +__USE_LARGEFILE + || defšed +__USE_XOPEN2K + + +741 #iâdeà +__USE_FILE_OFFSET64 + + +746
+ `f£eko + ( +FILE + * +__¡»am +, +__off_t + +__off +, +__wh’û +); + +751
+__off_t + + $á–lo + ( +FILE + * +__¡»am +è +__wur +; + +753 #ifdeà +__REDIRECT + + +754
+ `__REDIRECT + ( +f£eko +, + +755 ( +FILE + * +__¡»am +, +__off64_t + +__off +, +__wh’û +), + +756 +f£eko64 +); + +757
+__off64_t + + `__REDIRECT + ( +á–lo +, ( +FILE + * +__¡»am +), +á–lo64 +); + +759 + #f£eko + +f£eko64 + + + ) + +760 + #á–lo + +á–lo64 + + + ) + +765 +__BEGIN_NAMESPACE_STD + + +766 #iâdeà +__USE_FILE_OFFSET64 + + +771
+ `fg‘pos + ( +FILE + * +__»¡riù + +__¡»am +, +åos_t + *__»¡riù +__pos +); + +776
+ `f£os + ( +FILE + * +__¡»am +, +__cÚ¡ + +åos_t + * +__pos +); + +778 #ifdeà +__REDIRECT + + +779
+ `__REDIRECT + ( +fg‘pos +, ( +FILE + * +__»¡riù + +__¡»am +, + +780 +åos_t + * +__»¡riù + +__pos +), +fg‘pos64 +); + +781
+ `__REDIRECT + ( +f£os +, + +782 ( +FILE + * +__¡»am +, +__cÚ¡ + +åos_t + * +__pos +), +f£os64 +); + +784 + #fg‘pos + +fg‘pos64 + + + ) + +785 + #f£os + +f£os64 + + + ) + +788 +__END_NAMESPACE_STD + + +790 #ifdeà +__USE_LARGEFILE64 + + +791
+ `f£eko64 + ( +FILE + * +__¡»am +, +__off64_t + +__off +, +__wh’û +); + +792
+__off64_t + + $á–lo64 + ( +FILE + * +__¡»am +è +__wur +; + +793
+ `fg‘pos64 + ( +FILE + * +__»¡riù + +__¡»am +, +åos64_t + *__»¡riù +__pos +); + +794
+ `f£os64 + ( +FILE + * +__¡»am +, +__cÚ¡ + +åos64_t + * +__pos +); + +797 +__BEGIN_NAMESPACE_STD + + +799
+ $þ—»¼ + ( +FILE + * +__¡»am +è +__THROW +; + +801
+ $ãof + ( +FILE + * +__¡»am +è +__THROW + +__wur +; + +803
+ $ã¼Ü + ( +FILE + * +__¡»am +è +__THROW + +__wur +; + +804 +__END_NAMESPACE_STD + + +806 #ifdeà +__USE_MISC + + +808
+ $þ—»¼_uÆocked + ( +FILE + * +__¡»am +è +__THROW +; + +809
+ $ãof_uÆocked + ( +FILE + * +__¡»am +è +__THROW + +__wur +; + +810
+ $ã¼Ü_uÆocked + ( +FILE + * +__¡»am +è +__THROW + +__wur +; + +814 +__BEGIN_NAMESPACE_STD + + +819
+ `³¼Ü + ( +__cÚ¡ + * +__s +); + +820 +__END_NAMESPACE_STD + + +826 + ~<b™s/sys_”¾i¡.h +> + +829 #ifdef +__USE_POSIX + + +831
+ $fž’o + ( +FILE + * +__¡»am +è +__THROW + +__wur +; + +834 #ifdeà +__USE_MISC + + +836
+ $fž’o_uÆocked + ( +FILE + * +__¡»am +è +__THROW + +__wur +; + +840 #ià( +defšed + +__USE_POSIX2 + || defšed +__USE_SVID + || defšed +__USE_BSD + || \ + +841 +defšed + +__USE_MISC +) + +846
+FILE + * + $pÝ’ + ( +__cÚ¡ + * +__commªd +, __cÚ¡ * +__modes +è +__wur +; + +852
+ `pþo£ + ( +FILE + * +__¡»am +); + +856 #ifdef +__USE_POSIX + + +858
* + $ù”mid + (* +__s +è +__THROW +; + +862 #ifdeà +__USE_XOPEN + + +864
* + `cu£rid + (* +__s +); + +868 #ifdef +__USE_GNU + + +869 +ob¡ack +; + +872
+ $ob¡ack_´štf + ( +ob¡ack + * +__»¡riù + +__ob¡ack +, + +873 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...) + +874 +__THROW + + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__´štf__ +, 2, 3))); + +875
+ $ob¡ack_v´štf + ( +ob¡ack + * +__»¡riù + +__ob¡ack +, + +876 +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +877 +_G_va_li¡ + +__¬gs +) + +878 +__THROW + + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__´štf__ +, 2, 0))); + +882 #ià +defšed + +__USE_POSIX + || defšed +__USE_MISC + + +886
+ $æockfže + ( +FILE + * +__¡»am +è +__THROW +; + +890
+ $árylockfže + ( +FILE + * +__¡»am +è +__THROW + +__wur +; + +893
+ $fuÆockfže + ( +FILE + * +__¡»am +è +__THROW +; + +896 #ià +defšed + +__USE_XOPEN + && !defšed +__USE_XOPEN2K + && !defšed +__USE_GNU + + +900 + #__Ãed_g‘Ýt + + + ) + +901 + ~<g‘Ýt.h +> + +906 #ifdeà +__USE_EXTERN_INLINES + + +907 + ~<b™s/¡dio.h +> + +909 #ià +__USE_FORTIFY_LEVEL + > 0 && +defšed + +__ex‹º_®ways_šlše + + +910 + ~<b™s/¡dio2.h +> + +912 #ifdeà +__LDBL_COMPAT + + +913 + ~<b™s/¡dio-ldbl.h +> + +916 +__END_DECLS + + + @/usr/include/string.h + +23 #iâdef +_STRING_H + + +24 + #_STRING_H + 1 + + ) + +26 + ~<ã©u»s.h +> + +28 + g__BEGIN_DECLS + + +31 + #__Ãed_size_t + + + ) + +32 + #__Ãed_NULL + + + ) + +33 + ~<¡ddef.h +> + +36 #ià +defšed + +__ýlu¥lus + && +__GNUC_PREREQ + (4, 4) + +37 + #__CORRECT_ISO_CPP_STRING_H_PROTO + + + ) + +41 +__BEGIN_NAMESPACE_STD + + +43
* + $memýy + ( * +__»¡riù + +__de¡ +, + +44 +__cÚ¡ + * +__»¡riù + +__¤c +, +size_t + +__n +) + +45 +__THROW + + `__nÚnuÎ + ((1, 2)); + +48
* + $memmove + ( * +__de¡ +, +__cÚ¡ + * +__¤c +, +size_t + +__n +) + +49 +__THROW + + `__nÚnuÎ + ((1, 2)); + +50 +__END_NAMESPACE_STD + + +55 #ià +defšed + +__USE_SVID + || defšed +__USE_BSD + || defšed +__USE_XOPEN + + +56
* + $memcýy + ( * +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +, + +57 +__c +, +size_t + +__n +) + +58 +__THROW + + `__nÚnuÎ + ((1, 2)); + +62 +__BEGIN_NAMESPACE_STD + + +64
* + $mem£t + ( * +__s +, +__c +, +size_t + +__n +è +__THROW + + `__nÚnuÎ + ((1)); + +67
+ $memcmp + ( +__cÚ¡ + * +__s1 +, __cÚ¡ * +__s2 +, +size_t + +__n +) + +68 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +71 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +74
* + `memchr + ( * +__s +, +__c +, +size_t + +__n +) + +75 +__THROW + + `__asm + ("memchr"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +76
+__cÚ¡ + * + `memchr + (__cÚ¡ * +__s +, +__c +, +size_t + +__n +) + +77 +__THROW + + `__asm + ("memchr"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +79 #ifdeà +__OPTIMIZE__ + + +80 +__ex‹º_®ways_šlše + * + +81 + `memchr + ( * +__s +, +__c +, +size_t + +__n +è +__THROW + + +83 + `__bužtš_memchr + ( +__s +, +__c +, +__n +); + +86 +__ex‹º_®ways_šlše + +__cÚ¡ + * + +87 + `memchr + ( +__cÚ¡ + * +__s +, +__c +, +size_t + +__n +è +__THROW + + +89 + `__bužtš_memchr + ( +__s +, +__c +, +__n +); + +92 + } +} + +94
* + $memchr + ( +__cÚ¡ + * +__s +, +__c +, +size_t + +__n +) + +95 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +97 +__END_NAMESPACE_STD + + +99 #ifdeà +__USE_GNU + + +102 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +103
"C++" * + $¿wmemchr + ( * +__s +, +__c +) + +104 +__THROW + + `__asm + ("¿wmemchr"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +105
"C++" +__cÚ¡ + * + $¿wmemchr + ( +__cÚ¡ + * +__s +, +__c +) + +106 +__THROW + + `__asm + ("¿wmemchr"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +108
* + $¿wmemchr + ( +__cÚ¡ + * +__s +, +__c +) + +109 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +113 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +114
"C++" * + $memrchr + ( * +__s +, +__c +, +size_t + +__n +) + +115 +__THROW + + `__asm + ("memrchr"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +116
"C++" +__cÚ¡ + * + $memrchr + ( +__cÚ¡ + * +__s +, +__c +, +size_t + +__n +) + +117 +__THROW + + `__asm + ("memrchr"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +119
* + $memrchr + ( +__cÚ¡ + * +__s +, +__c +, +size_t + +__n +) + +120 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +125 +__BEGIN_NAMESPACE_STD + + +127
* + $¡rýy + (* +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +) + +128 +__THROW + + `__nÚnuÎ + ((1, 2)); + +130
* + $¡ºýy + (* +__»¡riù + +__de¡ +, + +131 +__cÚ¡ + * +__»¡riù + +__¤c +, +size_t + +__n +) + +132 +__THROW + + `__nÚnuÎ + ((1, 2)); + +135
* + $¡rÿt + (* +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +) + +136 +__THROW + + `__nÚnuÎ + ((1, 2)); + +138
* + $¡ºÿt + (* +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +, + +139 +size_t + +__n +è +__THROW + + `__nÚnuÎ + ((1, 2)); + +142
+ $¡rcmp + ( +__cÚ¡ + * +__s1 +, __cÚ¡ * +__s2 +) + +143 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +145
+ $¡ºcmp + ( +__cÚ¡ + * +__s1 +, __cÚ¡ * +__s2 +, +size_t + +__n +) + +146 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +149
+ $¡rcÞl + ( +__cÚ¡ + * +__s1 +, __cÚ¡ * +__s2 +) + +150 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +152
+size_t + + $¡rxäm + (* +__»¡riù + +__de¡ +, + +153 +__cÚ¡ + * +__»¡riù + +__¤c +, +size_t + +__n +) + +154 +__THROW + + `__nÚnuÎ + ((2)); + +155 +__END_NAMESPACE_STD + + +157 #ifdeà +__USE_XOPEN2K8 + + +161 + ~<xloÿË.h +> + +164
+ $¡rcÞl_l + ( +__cÚ¡ + * +__s1 +, __cÚ¡ * +__s2 +, +__loÿË_t + +__l +) + +165 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2, 3)); + +167
+size_t + + $¡rxäm_l + (* +__de¡ +, +__cÚ¡ + * +__¤c +, +size_t + +__n +, + +168 +__loÿË_t + +__l +è +__THROW + + `__nÚnuÎ + ((2, 4)); + +171 #ià +defšed + +__USE_SVID + || defšed +__USE_BSD + || defšed +__USE_XOPEN_EXTENDED + + +173
* + $¡rdup + ( +__cÚ¡ + * +__s +) + +174 +__THROW + +__©Œibu‹_m®loc__ + + `__nÚnuÎ + ((1)); + +180 #ià +defšed + +__USE_XOPEN2K8 + + +181
* + $¡ºdup + ( +__cÚ¡ + * +__¡ršg +, +size_t + +__n +) + +182 +__THROW + +__©Œibu‹_m®loc__ + + `__nÚnuÎ + ((1)); + +185 #ià +defšed + +__USE_GNU + && defšed +__GNUC__ + + +187 + #¡rdu· +( +s +) \ + +188 ( +__ex‹nsiÚ__ + \ + +190 +__cÚ¡ + * +__Þd + = ( +s +); \ + +191 +size_t + +__Ën + = + `¡¾’ + ( +__Þd +) + 1; \ + +192 * +__Ãw + = (*è + `__bužtš_®loÿ + ( +__Ën +); \ + +193 (*è + `memýy + ( +__Ãw +, +__Þd +, +__Ën +); \ + +194 + } +})) + + ) + +197 + #¡ºdu· +( +s +, +n +) \ + +198 ( +__ex‹nsiÚ__ + \ + +200 +__cÚ¡ + * +__Þd + = ( +s +); \ + +201 +size_t + +__Ën + = + `¡ºËn + ( +__Þd +, ( +n +)); \ + +202 * +__Ãw + = (*è + `__bužtš_®loÿ + ( +__Ën + + 1); \ + +203 +__Ãw +[ +__Ën +] = '\0'; \ + +204 (*è + `memýy + ( +__Ãw +, +__Þd +, +__Ën +); \ + +205 })) + + ) + +208 + g__BEGIN_NAMESPACE_STD + + +210 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +213
* +¡rchr + (* +__s +, +__c +) + +214 +__THROW + +__asm + ("¡rchr"è +__©Œibu‹_pu»__ + +__nÚnuÎ + ((1)); + +215
+__cÚ¡ + * +¡rchr + (__cÚ¡ * +__s +, +__c +) + +216 +__THROW + +__asm + ("¡rchr"è +__©Œibu‹_pu»__ + +__nÚnuÎ + ((1)); + +218 #ifdeà +__OPTIMIZE__ + + +219 +__ex‹º_®ways_šlše + * + +220 +¡rchr + (* +__s +, +__c +è + g__THROW + + +222 +__bužtš_¡rchr + ( +__s +, +__c +); + +225 +__ex‹º_®ways_šlše + +__cÚ¡ + * + +226 +¡rchr + ( +__cÚ¡ + * +__s +, +__c +è + g__THROW + + +228 +__bužtš_¡rchr + ( +__s +, +__c +); + +233
* + $¡rchr + ( +__cÚ¡ + * +__s +, +__c +) + +234 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +237 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +240
* + `¡¼chr + (* +__s +, +__c +) + +241 +__THROW + + `__asm + ("¡¼chr"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +242
+__cÚ¡ + * + `¡¼chr + (__cÚ¡ * +__s +, +__c +) + +243 +__THROW + + `__asm + ("¡¼chr"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +245 #ifdeà +__OPTIMIZE__ + + +246 +__ex‹º_®ways_šlše + * + +247 + `¡¼chr + (* +__s +, +__c +è +__THROW + + +249 + `__bužtš_¡¼chr + ( +__s +, +__c +); + +252 +__ex‹º_®ways_šlše + +__cÚ¡ + * + +253 + `¡¼chr + ( +__cÚ¡ + * +__s +, +__c +è +__THROW + + +255 + `__bužtš_¡¼chr + ( +__s +, +__c +); + +258 + } +} + +260
* + $¡¼chr + ( +__cÚ¡ + * +__s +, +__c +) + +261 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +263 +__END_NAMESPACE_STD + + +265 #ifdeà +__USE_GNU + + +268 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +269
"C++" * + $¡rchºul + (* +__s +, +__c +) + +270 +__THROW + + `__asm + ("¡rchºul"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +271
"C++" +__cÚ¡ + * + $¡rchºul + ( +__cÚ¡ + * +__s +, +__c +) + +272 +__THROW + + `__asm + ("¡rchºul"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +274
* + $¡rchºul + ( +__cÚ¡ + * +__s +, +__c +) + +275 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +279 +__BEGIN_NAMESPACE_STD + + +282
+size_t + + $¡rc¥n + ( +__cÚ¡ + * +__s +, __cÚ¡ * +__»jeù +) + +283 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +286
+size_t + + $¡r¥n + ( +__cÚ¡ + * +__s +, __cÚ¡ * +__acû± +) + +287 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +289 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +292
* + `¡½brk + (* +__s +, +__cÚ¡ + * +__acû± +) + +293 +__THROW + + `__asm + ("¡½brk"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +294
+__cÚ¡ + * + `¡½brk + (__cÚ¡ * +__s +, __cÚ¡ * +__acû± +) + +295 +__THROW + + `__asm + ("¡½brk"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +297 #ifdeà +__OPTIMIZE__ + + +298 +__ex‹º_®ways_šlše + * + +299 + `¡½brk + (* +__s +, +__cÚ¡ + * +__acû± +è +__THROW + + +301 + `__bužtš_¡½brk + ( +__s +, +__acû± +); + +304 +__ex‹º_®ways_šlše + +__cÚ¡ + * + +305 + `¡½brk + ( +__cÚ¡ + * +__s +, __cÚ¡ * +__acû± +è +__THROW + + +307 + `__bužtš_¡½brk + ( +__s +, +__acû± +); + +310 + } +} + +312
* + $¡½brk + ( +__cÚ¡ + * +__s +, __cÚ¡ * +__acû± +) + +313 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +316 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +319
* + `¡r¡r + (* +__hay¡ack +, +__cÚ¡ + * +__ÃedË +) + +320 +__THROW + + `__asm + ("¡r¡r"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +321
+__cÚ¡ + * + `¡r¡r + (__cÚ¡ * +__hay¡ack +, + +322 +__cÚ¡ + * +__ÃedË +) + +323 +__THROW + + `__asm + ("¡r¡r"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +325 #ifdeà +__OPTIMIZE__ + + +326 +__ex‹º_®ways_šlše + * + +327 + `¡r¡r + (* +__hay¡ack +, +__cÚ¡ + * +__ÃedË +è +__THROW + + +329 + `__bužtš_¡r¡r + ( +__hay¡ack +, +__ÃedË +); + +332 +__ex‹º_®ways_šlše + +__cÚ¡ + * + +333 + `¡r¡r + ( +__cÚ¡ + * +__hay¡ack +, __cÚ¡ * +__ÃedË +è +__THROW + + +335 + `__bužtš_¡r¡r + ( +__hay¡ack +, +__ÃedË +); + +338 + } +} + +340
* + $¡r¡r + ( +__cÚ¡ + * +__hay¡ack +, __cÚ¡ * +__ÃedË +) + +341 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +346
* + $¡¹ok + (* +__»¡riù + +__s +, +__cÚ¡ + *__»¡riù +__d–im +) + +347 +__THROW + + `__nÚnuÎ + ((2)); + +348 +__END_NAMESPACE_STD + + +352
* + $__¡¹ok_r + (* +__»¡riù + +__s +, + +353 +__cÚ¡ + * +__»¡riù + +__d–im +, + +354 ** +__»¡riù + +__§ve_±r +) + +355 +__THROW + + `__nÚnuÎ + ((2, 3)); + +356 #ià +defšed + +__USE_POSIX + || defšed +__USE_MISC + + +357
* + $¡¹ok_r + (* +__»¡riù + +__s +, +__cÚ¡ + *__»¡riù +__d–im +, + +358 ** +__»¡riù + +__§ve_±r +) + +359 +__THROW + + `__nÚnuÎ + ((2, 3)); + +362 #ifdeà +__USE_GNU + + +364 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +365
"C++" * + $¡rÿ£¡r + (* +__hay¡ack +, +__cÚ¡ + * +__ÃedË +) + +366 +__THROW + + `__asm + ("¡rÿ£¡r"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +367
"C++" +__cÚ¡ + * + $¡rÿ£¡r + ( +__cÚ¡ + * +__hay¡ack +, + +368 +__cÚ¡ + * +__ÃedË +) + +369 +__THROW + + `__asm + ("¡rÿ£¡r"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +371
* + $¡rÿ£¡r + ( +__cÚ¡ + * +__hay¡ack +, __cÚ¡ * +__ÃedË +) + +372 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +376 #ifdeà +__USE_GNU + + +380
* + $memmem + ( +__cÚ¡ + * +__hay¡ack +, +size_t + +__hay¡ackËn +, + +381 +__cÚ¡ + * +__ÃedË +, +size_t + +__ÃedËËn +) + +382 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 3)); + +386
* + $__mempýy + ( * +__»¡riù + +__de¡ +, + +387 +__cÚ¡ + * +__»¡riù + +__¤c +, +size_t + +__n +) + +388 +__THROW + + `__nÚnuÎ + ((1, 2)); + +389
* + $mempýy + ( * +__»¡riù + +__de¡ +, + +390 +__cÚ¡ + * +__»¡riù + +__¤c +, +size_t + +__n +) + +391 +__THROW + + `__nÚnuÎ + ((1, 2)); + +395 +__BEGIN_NAMESPACE_STD + + +397
+size_t + + $¡¾’ + ( +__cÚ¡ + * +__s +) + +398 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +399 +__END_NAMESPACE_STD + + +401 #ifdef +__USE_XOPEN2K8 + + +404
+size_t + + $¡ºËn + ( +__cÚ¡ + * +__¡ršg +, +size_t + +__maxËn +) + +405 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +409 +__BEGIN_NAMESPACE_STD + + +411
* + $¡»¼Ü + ( +__”ºum +è +__THROW +; + +412 +__END_NAMESPACE_STD + + +413 #ià +defšed + +__USE_XOPEN2K + || defšed +__USE_MISC + + +421 #ià +defšed + +__USE_XOPEN2K + && !defšed +__USE_GNU + + +424 #ifdeà +__REDIRECT_NTH + + +425
+ `__REDIRECT_NTH + ( +¡»¼Ü_r +, + +426 ( +__”ºum +, * +__buf +, +size_t + +__buæ’ +), + +427 +__xpg_¡»¼Ü_r +è + `__nÚnuÎ + ((2)); + +429
+ $__xpg_¡»¼Ü_r + ( +__”ºum +, * +__buf +, +size_t + +__buæ’ +) + +430 +__THROW + + `__nÚnuÎ + ((2)); + +431 + #¡»¼Ü_r + +__xpg_¡»¼Ü_r + + + ) + +436
* + $¡»¼Ü_r + ( +__”ºum +, * +__buf +, +size_t + +__buæ’ +) + +437 +__THROW + + `__nÚnuÎ + ((2)); + +441 #ifdeà +__USE_XOPEN2K8 + + +443
* + $¡»¼Ü_l + ( +__”ºum +, +__loÿË_t + +__l +è +__THROW +; + +449
+ $__bz”o + ( * +__s +, +size_t + +__n +è +__THROW + + `__nÚnuÎ + ((1)); + +451 #ifdeà +__USE_BSD + + +453
+ $bcÝy + ( +__cÚ¡ + * +__¤c +, * +__de¡ +, +size_t + +__n +) + +454 +__THROW + + `__nÚnuÎ + ((1, 2)); + +457
+ $bz”o + ( * +__s +, +size_t + +__n +è +__THROW + + `__nÚnuÎ + ((1)); + +460
+ $bcmp + ( +__cÚ¡ + * +__s1 +, __cÚ¡ * +__s2 +, +size_t + +__n +) + +461 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +464 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +467
* + `šdex + (* +__s +, +__c +) + +468 +__THROW + + `__asm + ("šdex"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +469
+__cÚ¡ + * + `šdex + (__cÚ¡ * +__s +, +__c +) + +470 +__THROW + + `__asm + ("šdex"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +472 #ià +defšed + +__OPTIMIZE__ + && !defšed +__CORRECT_ISO_CPP_STRINGS_H_PROTO + + +473 +__ex‹º_®ways_šlše + * + +474 + `šdex + (* +__s +, +__c +è +__THROW + + +476 + `__bužtš_šdex + ( +__s +, +__c +); + +479 +__ex‹º_®ways_šlše + +__cÚ¡ + * + +480 + `šdex + ( +__cÚ¡ + * +__s +, +__c +è +__THROW + + +482 + `__bužtš_šdex + ( +__s +, +__c +); + +485 + } +} + +487
* + $šdex + ( +__cÚ¡ + * +__s +, +__c +) + +488 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +492 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +495
* + `ršdex + (* +__s +, +__c +) + +496 +__THROW + + `__asm + ("ršdex"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +497
+__cÚ¡ + * + `ršdex + (__cÚ¡ * +__s +, +__c +) + +498 +__THROW + + `__asm + ("ršdex"è +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +500 #ià +defšed + +__OPTIMIZE__ + && !defšed +__CORRECT_ISO_CPP_STRINGS_H_PROTO + + +501 +__ex‹º_®ways_šlše + * + +502 + `ršdex + (* +__s +, +__c +è +__THROW + + +504 + `__bužtš_ršdex + ( +__s +, +__c +); + +507 +__ex‹º_®ways_šlše + +__cÚ¡ + * + +508 + `ršdex + ( +__cÚ¡ + * +__s +, +__c +è +__THROW + + +510 + `__bužtš_ršdex + ( +__s +, +__c +); + +513 + } +} + +515
* + $ršdex + ( +__cÚ¡ + * +__s +, +__c +) + +516 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)); + +521
+ $ffs + ( +__i +è +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)); + +525 #ifdef +__USE_GNU + + +526
+ $ff¦ + ( +__l +è +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)); + +527 #ifdeà +__GNUC__ + + +528 +__ex‹nsiÚ__ +
+ $ff¦l + ( +__Î +) + +529 +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)); + +534
+ $¡rÿ£cmp + ( +__cÚ¡ + * +__s1 +, __cÚ¡ * +__s2 +) + +535 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +538
+ $¡ºÿ£cmp + ( +__cÚ¡ + * +__s1 +, __cÚ¡ * +__s2 +, +size_t + +__n +) + +539 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +542 #ifdef +__USE_GNU + + +545
+ $¡rÿ£cmp_l + ( +__cÚ¡ + * +__s1 +, __cÚ¡ * +__s2 +, + +546 +__loÿË_t + +__loc +) + +547 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2, 3)); + +549
+ $¡ºÿ£cmp_l + ( +__cÚ¡ + * +__s1 +, __cÚ¡ * +__s2 +, + +550 +size_t + +__n +, +__loÿË_t + +__loc +) + +551 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2, 4)); + +554 #ifdef +__USE_BSD + + +557
* + $¡r£p + (** +__»¡riù + +__¡ršgp +, + +558 +__cÚ¡ + * +__»¡riù + +__d–im +) + +559 +__THROW + + `__nÚnuÎ + ((1, 2)); + +562 #ifdef +__USE_XOPEN2K8 + + +564
* + $¡rsigÇl + ( +__sig +è +__THROW +; + +567
* + $__¡pýy + (* +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +) + +568 +__THROW + + `__nÚnuÎ + ((1, 2)); + +569
* + $¡pýy + (* +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +) + +570 +__THROW + + `__nÚnuÎ + ((1, 2)); + +574
* + $__¡²ýy + (* +__»¡riù + +__de¡ +, + +575 +__cÚ¡ + * +__»¡riù + +__¤c +, +size_t + +__n +) + +576 +__THROW + + `__nÚnuÎ + ((1, 2)); + +577
* + $¡²ýy + (* +__»¡riù + +__de¡ +, + +578 +__cÚ¡ + * +__»¡riù + +__¤c +, +size_t + +__n +) + +579 +__THROW + + `__nÚnuÎ + ((1, 2)); + +582 #ifdef +__USE_GNU + + +584
+ $¡rv”scmp + ( +__cÚ¡ + * +__s1 +, __cÚ¡ * +__s2 +) + +585 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1, 2)); + +588
* + $¡räy + (* +__¡ršg +è +__THROW + + `__nÚnuÎ + ((1)); + +591
* + $memäob + ( * +__s +, +size_t + +__n +è +__THROW + + `__nÚnuÎ + ((1)); + +593 #iâdeà +ba£Çme + + +598 #ifdeà +__CORRECT_ISO_CPP_STRING_H_PROTO + + +599
"C++" * + $ba£Çme + (* +__fž’ame +) + +600 +__THROW + + `__asm + ("ba£Çme"è + `__nÚnuÎ + ((1)); + +601
"C++" +__cÚ¡ + * + $ba£Çme + ( +__cÚ¡ + * +__fž’ame +) + +602 +__THROW + + `__asm + ("ba£Çme"è + `__nÚnuÎ + ((1)); + +604
* + $ba£Çme + ( +__cÚ¡ + * +__fž’ame +è +__THROW + + `__nÚnuÎ + ((1)); + +610 #ià +defšed + +__GNUC__ + && __GNUC__ >= 2 + +611 #ià +defšed + +__OPTIMIZE__ + && !defšed +__OPTIMIZE_SIZE__ + \ + +612 && ! +defšed + +__NO_INLINE__ + && !defšed +__ýlu¥lus + + +632 + ~<b™s/¡ršg.h +> + +635 + ~<b™s/¡ršg2.h +> + +638 #ià +__USE_FORTIFY_LEVEL + > 0 && +defšed + +__ex‹º_®ways_šlše + + +640 + ~<b™s/¡ršg3.h +> + +644 +__END_DECLS + + + @/usr/include/bits/huge_val.h + +22 #iâdeà +_MATH_H + + +28 #ià +__GNUC_PREREQ +(3,3) + +29 + #HUGE_VAL + ( + `__bužtš_huge_v® +()) + + ) + +30 #–ià +__GNUC_PREREQ +(2,96) + +31 + #HUGE_VAL + ( +__ex‹nsiÚ__ + 0x1.0 +p2047 +) + + ) + +32 #–ià +defšed + +__GNUC__ + + +34 + #HUGE_VAL + \ + +35 ( +__ex‹nsiÚ__ + \ + +36 ((uniÚ { +__l + + `__©Œibu‹__ +(( + `__mode__ +( +__DI__ +))); +__d +; }) \ + +37 { +__l +: 0x7ff0000000000000ULL }). +__d +) + + ) + +41 + ~<’dŸn.h +> + +43 uniÚ { + m__c +[8]; + m__d +; } + t__huge_v®_t +; + +45 #ià +__BYTE_ORDER + =ð +__BIG_ENDIAN + + +46 + #__HUGE_VAL_by‹s + { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 } + + ) + +48 #ià +__BYTE_ORDER + =ð +__LITTLE_ENDIAN + + +49 + #__HUGE_VAL_by‹s + { 0, 0, 0, 0, 0, 0, 0xf0, 0x7à} + + ) + +52 +__huge_v®_t + + g__huge_v® + = { +__HUGE_VAL_by‹s + }; + +53 + #HUGE_VAL + ( +__huge_v® +. +__d +) + + ) + + @/usr/include/bits/huge_valf.h + +22 #iâdeà +_MATH_H + + +28 #ià +__GNUC_PREREQ +(3,3) + +29 + #HUGE_VALF + ( + `__bužtš_huge_v®f +()) + + ) + +30 #–ià +__GNUC_PREREQ +(2,96) + +31 + #HUGE_VALF + ( +__ex‹nsiÚ__ + 0x1.0 +p255f +) + + ) + +32 #–ià +defšed + +__GNUC__ + + +34 + #HUGE_VALF + \ + +35 ( +__ex‹nsiÚ__ + \ + +36 ((uniÚ { +__l + + `__©Œibu‹__ +(( + `__mode__ +( +__SI__ +))); +__d +; }) \ + +37 { +__l +: 0x7f800000UL }). +__d +) + + ) + +41 uniÚ { + m__c +[4]; + m__f +; } + t__huge_v®f_t +; + +43 #ià +__BYTE_ORDER + =ð +__BIG_ENDIAN + + +44 + #__HUGE_VALF_by‹s + { 0x7f, 0x80, 0, 0 } + + ) + +46 #ià +__BYTE_ORDER + =ð +__LITTLE_ENDIAN + + +47 + #__HUGE_VALF_by‹s + { 0, 0, 0x80, 0x7à} + + ) + +50 +__huge_v®f_t + + g__huge_v®f + = { +__HUGE_VALF_by‹s + }; + +51 + #HUGE_VALF + ( +__huge_v®f +. +__f +) + + ) + + @/usr/include/bits/huge_vall.h + +21 #iâdeà +_MATH_H + + +25 #ià +__GNUC_PREREQ +(3,3) + +26 + #HUGE_VALL + ( + `__bužtš_huge_v®l +()) + + ) + +28 + #HUGE_VALL + ((è +HUGE_VAL +) + + ) + + @/usr/include/bits/inf.h + +20 #iâdeà +_MATH_H + + +26 #ià +__GNUC_PREREQ +(3,3) + +27 + #INFINITY + ( + `__bužtš_šff +()) + + ) + +29 + #INFINITY + +HUGE_VALF + + + ) + + @/usr/include/bits/mathcalls.h + +46 #iâdeà +_MATH_H + + +53 +_MdoubË_BEGIN_NAMESPACE + + +55 +__MATHCALL + ( +acos +,, ( +_MdoubË_ + +__x +)); + +57 +__MATHCALL + ( +asš +,, ( +_MdoubË_ + +__x +)); + +59 +__MATHCALL + ( +©ª +,, ( +_MdoubË_ + +__x +)); + +61 +__MATHCALL + ( +©ª2 +,, ( +_MdoubË_ + +__y +, _MdoubË_ +__x +)); + +64 +__MATHCALL + ( +cos +,, ( +_MdoubË_ + +__x +)); + +66 +__MATHCALL + ( +sš +,, ( +_MdoubË_ + +__x +)); + +68 +__MATHCALL + ( +n +,, ( +_MdoubË_ + +__x +)); + +73 +__MATHCALL + ( +cosh +,, ( +_MdoubË_ + +__x +)); + +75 +__MATHCALL + ( +sšh +,, ( +_MdoubË_ + +__x +)); + +77 +__MATHCALL + ( +nh +,, ( +_MdoubË_ + +__x +)); + +78 + g_MdoubË_END_NAMESPACE + + +80 #ifdeà +__USE_GNU + + +82 +__MATHDECL + ( , +sšcos +,, + +83 ( +_MdoubË_ + +__x +, _MdoubË_ * +__sšx +, _MdoubË_ * +__cosx +)); + +86 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN_EXTENDED + || defšed +__USE_ISOC99 + + +87 +__BEGIN_NAMESPACE_C99 + + +89 +__MATHCALL + ( +acosh +,, ( +_MdoubË_ + +__x +)); + +91 +__MATHCALL + ( +asšh +,, ( +_MdoubË_ + +__x +)); + +93 +__MATHCALL + ( +©ªh +,, ( +_MdoubË_ + +__x +)); + +94 + g__END_NAMESPACE_C99 + + +99 +_MdoubË_BEGIN_NAMESPACE + + +101 +__MATHCALL + ( +exp +,, ( +_MdoubË_ + +__x +)); + +104 +__MATHCALL + ( +äexp +,, ( +_MdoubË_ + +__x +, * +__expÚ’t +)); + +107 +__MATHCALL + ( +ldexp +,, ( +_MdoubË_ + +__x +, +__expÚ’t +)); + +110 +__MATHCALL + ( +log +,, ( +_MdoubË_ + +__x +)); + +113 +__MATHCALL + ( +log10 +,, ( +_MdoubË_ + +__x +)); + +116 +__MATHCALL + ( +modf +,, ( +_MdoubË_ + +__x +, _MdoubË_ * +__Œ +)); + +117 + g_MdoubË_END_NAMESPACE + + +119 #ifdeà +__USE_GNU + + +121 +__MATHCALL + ( +exp10 +,, ( +_MdoubË_ + +__x +)); + +123 +__MATHCALL + ( +pow10 +,, ( +_MdoubË_ + +__x +)); + +126 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN_EXTENDED + || defšed +__USE_ISOC99 + + +127 +__BEGIN_NAMESPACE_C99 + + +129 +__MATHCALL + ( +expm1 +,, ( +_MdoubË_ + +__x +)); + +132 +__MATHCALL + ( +log1p +,, ( +_MdoubË_ + +__x +)); + +135 +__MATHCALL + ( +logb +,, ( +_MdoubË_ + +__x +)); + +136 + g__END_NAMESPACE_C99 + + +139 #ifdeà +__USE_ISOC99 + + +140 +__BEGIN_NAMESPACE_C99 + + +142 +__MATHCALL + ( +exp2 +,, ( +_MdoubË_ + +__x +)); + +145 +__MATHCALL + ( +log2 +,, ( +_MdoubË_ + +__x +)); + +146 + g__END_NAMESPACE_C99 + + +152 +_MdoubË_BEGIN_NAMESPACE + + +154 +__MATHCALL + ( +pow +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +)); + +157 +__MATHCALL + ( +sq¹ +,, ( +_MdoubË_ + +__x +)); + +158 + g_MdoubË_END_NAMESPACE + + +160 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN + || defšed +__USE_ISOC99 + + +161 +__BEGIN_NAMESPACE_C99 + + +163 +__MATHCALL + ( +hypÙ +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +)); + +164 + g__END_NAMESPACE_C99 + + +167 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN_EXTENDED + || defšed +__USE_ISOC99 + + +168 +__BEGIN_NAMESPACE_C99 + + +170 +__MATHCALL + ( +cb¹ +,, ( +_MdoubË_ + +__x +)); + +171 + g__END_NAMESPACE_C99 + + +177 +_MdoubË_BEGIN_NAMESPACE + + +179 +__MATHCALLX + ( +ûž +,, ( +_MdoubË_ + +__x +), ( +__cÚ¡__ +)); + +182 +__MATHCALLX + ( +çbs +,, ( +_MdoubË_ + +__x +), ( +__cÚ¡__ +)); + +185 +__MATHCALLX + ( +æoÜ +,, ( +_MdoubË_ + +__x +), ( +__cÚ¡__ +)); + +188 +__MATHCALL + ( +fmod +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +)); + +193 +__MATHDECL_1 + (, +__isšf +,, ( +_MdoubË_ + +__v®ue +)è +__©Œibu‹__ + (( +__cÚ¡__ +)); + +196 +__MATHDECL_1 + (, +__fš™e +,, ( +_MdoubË_ + +__v®ue +)è +__©Œibu‹__ + (( +__cÚ¡__ +)); + +197 + g_MdoubË_END_NAMESPACE + + +199 #ifdeà +__USE_MISC + + +202 +__MATHDECL_1 + (, +isšf +,, ( +_MdoubË_ + +__v®ue +)è +__©Œibu‹__ + (( +__cÚ¡__ +)); + +205 +__MATHDECL_1 + (, +fš™e +,, ( +_MdoubË_ + +__v®ue +)è +__©Œibu‹__ + (( +__cÚ¡__ +)); + +208 +__MATHCALL + ( +d»m +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +)); + +212 +__MATHCALL + ( +signifiÿnd +,, ( +_MdoubË_ + +__x +)); + +215 #ià +defšed + +__USE_MISC + || defšed +__USE_ISOC99 + + +216 +__BEGIN_NAMESPACE_C99 + + +218 +__MATHCALLX + ( +cÝysign +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +), ( +__cÚ¡__ +)); + +219 + g__END_NAMESPACE_C99 + + +222 #ifdeà +__USE_ISOC99 + + +223 +__BEGIN_NAMESPACE_C99 + + +225 +__MATHCALLX + ( +Çn +,, ( +__cÚ¡ + * +__gb +), ( +__cÚ¡__ +)); + +226 + g__END_NAMESPACE_C99 + + +231 +__MATHDECL_1 + (, +__i¢ª +,, ( +_MdoubË_ + +__v®ue +)è +__©Œibu‹__ + (( +__cÚ¡__ +)); + +233 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN + + +235 +__MATHDECL_1 + (, +i¢ª +,, ( +_MdoubË_ + +__v®ue +)è +__©Œibu‹__ + (( +__cÚ¡__ +)); + +238 +__MATHCALL + ( +j0 +,, ( +_MdoubË_ +)); + +239 +__MATHCALL + ( +j1 +,, ( +_MdoubË_ +)); + +240 +__MATHCALL + ( +jn +,, (, +_MdoubË_ +)); + +241 +__MATHCALL + ( +y0 +,, ( +_MdoubË_ +)); + +242 +__MATHCALL + ( +y1 +,, ( +_MdoubË_ +)); + +243 +__MATHCALL + ( +yn +,, (, +_MdoubË_ +)); + +247 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN + || defšed +__USE_ISOC99 + + +248 +__BEGIN_NAMESPACE_C99 + + +250 +__MATHCALL + ( +”f +,, ( +_MdoubË_ +)); + +251 +__MATHCALL + ( +”fc +,, ( +_MdoubË_ +)); + +252 +__MATHCALL + ( +lgamma +,, ( +_MdoubË_ +)); + +253 + g__END_NAMESPACE_C99 + + +256 #ifdeà +__USE_ISOC99 + + +257 +__BEGIN_NAMESPACE_C99 + + +259 +__MATHCALL + ( +tgamma +,, ( +_MdoubË_ +)); + +260 + g__END_NAMESPACE_C99 + + +263 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN + + +265 +__MATHCALL + ( +gamma +,, ( +_MdoubË_ +)); + +268 #ifdeà +__USE_MISC + + +272 +__MATHCALL + ( +lgamma +, +_r +, ( +_MdoubË_ +, * +__signgamp +)); + +276 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN_EXTENDED + || defšed +__USE_ISOC99 + + +277 +__BEGIN_NAMESPACE_C99 + + +280 +__MATHCALL + ( +ršt +,, ( +_MdoubË_ + +__x +)); + +283 +__MATHCALLX + ( +Ãxá” +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +), ( +__cÚ¡__ +)); + +284 #ià +defšed + +__USE_ISOC99 + && !defšed +__LDBL_COMPAT + + +285 +__MATHCALLX + ( +Ãx‰ow¬d +,, ( +_MdoubË_ + +__x +, +__y +), ( +__cÚ¡__ +)); + +289 +__MATHCALL + ( +»mašd” +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +)); + +291 #ià +defšed + +__USE_MISC + || defšed +__USE_ISOC99 + + +293 +__MATHCALL + ( +sÿlbn +,, ( +_MdoubË_ + +__x +, +__n +)); + +297 +__MATHDECL + (, +žogb +,, ( +_MdoubË_ + +__x +)); + +300 #ifdeà +__USE_ISOC99 + + +302 +__MATHCALL + ( +sÿlbÊ +,, ( +_MdoubË_ + +__x +, +__n +)); + +306 +__MATHCALL + ( +ìbyšt +,, ( +_MdoubË_ + +__x +)); + +310 +__MATHCALLX + ( +round +,, ( +_MdoubË_ + +__x +), ( +__cÚ¡__ +)); + +314 +__MATHCALLX + ( +Œunc +,, ( +_MdoubË_ + +__x +), ( +__cÚ¡__ +)); + +319 +__MATHCALL + ( +»mquo +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +, * +__quo +)); + +326 +__MATHDECL + (, +Ìšt +,, ( +_MdoubË_ + +__x +)); + +327 +__MATHDECL + (, +Îršt +,, ( +_MdoubË_ + +__x +)); + +331 +__MATHDECL + (, +Ìound +,, ( +_MdoubË_ + +__x +)); + +332 +__MATHDECL + (, +Îround +,, ( +_MdoubË_ + +__x +)); + +336 +__MATHCALL + ( +fdim +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +)); + +339 +__MATHCALL + ( +fmax +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +)); + +342 +__MATHCALL + ( +fmš +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +)); + +346 +__MATHDECL_1 + (, +__åþassify +,, ( +_MdoubË_ + +__v®ue +)) + +347 +__©Œibu‹__ + (( +__cÚ¡__ +)); + +350 +__MATHDECL_1 + (, +__signb™ +,, ( +_MdoubË_ + +__v®ue +)) + +351 +__©Œibu‹__ + (( +__cÚ¡__ +)); + +355 +__MATHCALL + ( +fma +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__y +, _MdoubË_ +__z +)); + +358 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN_EXTENDED + || defšed +__USE_ISOC99 + + +359 + g__END_NAMESPACE_C99 + + +362 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN_EXTENDED + + +364 +__MATHCALL + ( +sÿlb +,, ( +_MdoubË_ + +__x +, _MdoubË_ +__n +)); + + @/usr/include/bits/mathdef.h + +19 #ià! +defšed + +_MATH_H + && !defšed +_COMPLEX_H + + +23 #ià +defšed + +__USE_ISOC99 + && defšed +_MATH_H + && !defšed +_MATH_H_MATHDEF + + +24 + #_MATH_H_MATHDEF + 1 + + ) + +26 + ~<b™s/wÜdsize.h +> + +28 #ià +__WORDSIZE + =ð64 || ( +defšed + +__FLT_EVAL_METHOD__ + && __FLT_EVAL_METHOD__ == 0) + +31 + tæßt_t +; + +32 + tdoubË_t +; + +38 + tæßt_t +; + +40 + tdoubË_t +; + +45 + #FP_ILOGB0 + (-2147483647 - 1) + + ) + +46 + #FP_ILOGBNAN + (-2147483647 - 1) + + ) + + @/usr/include/bits/mathinline.h + +21 #iâdeà +_MATH_H + + +25 + ~<b™s/wÜdsize.h +> + +27 #iâdeà +__ex‹º_šlše + + +28 + #__MATH_INLINE + +__šlše + + + ) + +30 + #__MATH_INLINE + +__ex‹º_šlše + + + ) + +34 #ià +defšed + +__USE_ISOC99 + && defšed +__GNUC__ + && __GNUC__ >= 2 + +37 +__MATH_INLINE + + +38 +__NTH + ( + $__signb™f + ( +__x +)) + +40 #ià +__WORDSIZE + == 32 + +41 +__ex‹nsiÚ__ + uniÚ { +__f +; +__i +; } +__u + = { __f: +__x + }; + +42 +__u +. +__i + < 0; + +44 +__m +; + +45 + `__asm + ("pmovmskb %1, %0" : "ô" ( +__m +è: "x" ( +__x +)); + +46 +__m + & 0x8; + +48 + } +} + +49 +__MATH_INLINE + + +50 +__NTH + ( + $__signb™ + ( +__x +)) + +52 #ià +__WORDSIZE + == 32 + +53 +__ex‹nsiÚ__ + uniÚ { +__d +; +__i +[2]; } +__u + = { __d: +__x + }; + +54 +__u +. +__i +[1] < 0; + +56 +__m +; + +57 + `__asm + ("pmovmskb %1, %0" : "ô" ( +__m +è: "x" ( +__x +)); + +58 +__m + & 0x80; + +60 + } +} + +61 +__MATH_INLINE + + +62 +__NTH + ( + $__signb™l + ( +__x +)) + +64 +__ex‹nsiÚ__ + uniÚ { +__l +; +__i +[3]; } +__u + = { __l: +__x + }; + +65 ( +__u +. +__i +[2] & 0x8000) != 0; + +66 + } +} + + @/usr/include/bits/nan.h + +20 #iâdeà +_MATH_H + + +27 #ià +__GNUC_PREREQ +(3,3) + +29 + #NAN + ( + `__bužtš_Çnf + ("")) + + ) + +31 #–ià +defšed + +__GNUC__ + + +33 + #NAN + \ + +34 ( +__ex‹nsiÚ__ + \ + +35 ((uniÚ { +__l + + `__©Œibu‹__ + (( + `__mode__ + ( +__SI__ +))); +__d +; }) \ + +36 { +__l +: 0x7fc00000UL }). +__d +) + + ) + +40 + ~<’dŸn.h +> + +42 #ià +__BYTE_ORDER + =ð +__BIG_ENDIAN + + +43 + #__Çn_by‹s + { 0x7f, 0xc0, 0, 0 } + + ) + +45 #ià +__BYTE_ORDER + =ð +__LITTLE_ENDIAN + + +46 + #__Çn_by‹s + { 0, 0, 0xc0, 0x7à} + + ) + +49 uniÚ { + m__c +[4]; + m__d +; } +__Çn_uniÚ + + +50 + g__©Œibu‹_u£d__ + = { +__Çn_by‹s + }; + +51 + #NAN + ( +__Çn_uniÚ +. +__d +) + + ) + + @/usr/include/bits/stdio-ldbl.h + +20 #iâdeà +_STDIO_H + + +24 +__BEGIN_NAMESPACE_STD + + +25 + $__LDBL_REDIR_DECL + ( +årštf +) + +26 + $__LDBL_REDIR_DECL + ( +´štf +) + +27 + $__LDBL_REDIR_DECL + ( +¥rštf +) + +28 + $__LDBL_REDIR_DECL + ( +vårštf +) + +29 + $__LDBL_REDIR_DECL + ( +v´štf +) + +30 + $__LDBL_REDIR_DECL + ( +v¥rštf +) + +31 #ià +defšed + +__USE_ISOC99 + && !defšed +__USE_GNU + \ + +32 && ! +defšed + +__REDIRECT + \ + +33 && ( +defšed + +__STRICT_ANSI__ + || defšed +__USE_XOPEN2K +) + +34 + $__LDBL_REDIR1_DECL + ( +fsÿnf +, +__Ædbl___isoc99_fsÿnf +) + +35 + $__LDBL_REDIR1_DECL + ( +sÿnf +, +__Ædbl___isoc99_sÿnf +) + +36 + $__LDBL_REDIR1_DECL + ( +ssÿnf +, +__Ædbl___isoc99_ssÿnf +) + +38 + $__LDBL_REDIR_DECL + ( +fsÿnf +) + +39 + $__LDBL_REDIR_DECL + ( +sÿnf +) + +40 + $__LDBL_REDIR_DECL + ( +ssÿnf +) + +42 +__END_NAMESPACE_STD + + +44 #ià +defšed + +__USE_BSD + || defšed +__USE_ISOC99 + || defšed +__USE_UNIX98 + + +45 +__BEGIN_NAMESPACE_C99 + + +46 + $__LDBL_REDIR_DECL + ( +¢´štf +) + +47 + $__LDBL_REDIR_DECL + ( +v¢´štf +) + +48 +__END_NAMESPACE_C99 + + +51 #ifdef +__USE_ISOC99 + + +52 +__BEGIN_NAMESPACE_C99 + + +53 #ià! +defšed + +__USE_GNU + && !defšed +__REDIRECT + \ + +54 && ( +defšed + +__STRICT_ANSI__ + || defšed +__USE_XOPEN2K +) + +55 + $__LDBL_REDIR1_DECL + ( +vfsÿnf +, +__Ædbl___isoc99_vfsÿnf +) + +56 + $__LDBL_REDIR1_DECL + ( +vsÿnf +, +__Ædbl___isoc99_vsÿnf +) + +57 + $__LDBL_REDIR1_DECL + ( +vssÿnf +, +__Ædbl___isoc99_vssÿnf +) + +59 + $__LDBL_REDIR_DECL + ( +vfsÿnf +) + +60 + $__LDBL_REDIR_DECL + ( +vssÿnf +) + +61 + $__LDBL_REDIR_DECL + ( +vsÿnf +) + +63 +__END_NAMESPACE_C99 + + +66 #ifdeà +__USE_GNU + + +67 + $__LDBL_REDIR_DECL + ( +vd´štf +) + +68 + $__LDBL_REDIR_DECL + ( +d´štf +) + +69 + $__LDBL_REDIR_DECL + ( +va¥rštf +) + +70 + $__LDBL_REDIR_DECL + ( +__a¥rštf +) + +71 + $__LDBL_REDIR_DECL + ( +a¥rštf +) + +72 + $__LDBL_REDIR_DECL + ( +ob¡ack_´štf +) + +73 + $__LDBL_REDIR_DECL + ( +ob¡ack_v´štf +) + +76 #ià +__USE_FORTIFY_LEVEL + > 0 && +defšed + +__ex‹º_®ways_šlše + + +77 + $__LDBL_REDIR_DECL + ( +__¥rštf_chk +) + +78 + $__LDBL_REDIR_DECL + ( +__v¥rštf_chk +) + +79 #ià +defšed + +__USE_BSD + || defšed +__USE_ISOC99 + || defšed +__USE_UNIX98 + + +80 + $__LDBL_REDIR_DECL + ( +__¢´štf_chk +) + +81 + $__LDBL_REDIR_DECL + ( +__v¢´štf_chk +) + +83 #ià +__USE_FORTIFY_LEVEL + > 1 + +84 + $__LDBL_REDIR_DECL + ( +__årštf_chk +) + +85 + $__LDBL_REDIR_DECL + ( +__´štf_chk +) + +86 + $__LDBL_REDIR_DECL + ( +__vårštf_chk +) + +87 + $__LDBL_REDIR_DECL + ( +__v´štf_chk +) + +88 #ifdeà +__USE_GNU + + +89 + $__LDBL_REDIR_DECL + ( +__a¥rštf_chk +) + +90 + $__LDBL_REDIR_DECL + ( +__va¥rštf_chk +) + +91 + $__LDBL_REDIR_DECL + ( +__d´štf_chk +) + +92 + $__LDBL_REDIR_DECL + ( +__vd´štf_chk +) + +93 + $__LDBL_REDIR_DECL + ( +__ob¡ack_´štf_chk +) + +94 + $__LDBL_REDIR_DECL + ( +__ob¡ack_v´štf_chk +) + + @/usr/include/bits/stdio.h + +20 #iâdeà +_STDIO_H + + +24 #iâdeà +__ex‹º_šlše + + +25 + #__STDIO_INLINE + +šlše + + + ) + +27 + #__STDIO_INLINE + +__ex‹º_šlše + + + ) + +31 #ifdeà +__USE_EXTERN_INLINES + + +34 #ià!( +__USE_FORTIFY_LEVEL + > 0 && +defšed + +__ex‹º_®ways_šlše +) + +36 +__STDIO_INLINE + + +37 + $v´štf + ( +__cÚ¡ + * +__»¡riù + +__fmt +, +_G_va_li¡ + +__¬g +) + +39 + `vårštf + ( +¡dout +, +__fmt +, +__¬g +); + +40 + } +} + +44 +__STDIO_INLINE + + +45 + $g‘ch¬ + ( ) + +47 + `_IO_g‘c + ( +¡dš +); + +48 + } +} + +51 #ifdeà +__USE_MISC + + +53 +__STDIO_INLINE + + +54 + $fg‘c_uÆocked + ( +FILE + * +__å +) + +56 + `_IO_g‘c_uÆocked + ( +__å +); + +57 + } +} + +61 #ià +defšed + +__USE_POSIX + || defšed +__USE_MISC + + +63 +__STDIO_INLINE + + +64 + $g‘c_uÆocked + ( +FILE + * +__å +) + +66 + `_IO_g‘c_uÆocked + ( +__å +); + +67 + } +} + +70 +__STDIO_INLINE + + +71 + $g‘ch¬_uÆocked + ( ) + +73 + `_IO_g‘c_uÆocked + ( +¡dš +); + +74 + } +} + +79 +__STDIO_INLINE + + +80 + $putch¬ + ( +__c +) + +82 + `_IO_putc + ( +__c +, +¡dout +); + +83 + } +} + +86 #ifdeà +__USE_MISC + + +88 +__STDIO_INLINE + + +89 + $åutc_uÆocked + ( +__c +, +FILE + * +__¡»am +) + +91 + `_IO_putc_uÆocked + ( +__c +, +__¡»am +); + +92 + } +} + +96 #ià +defšed + +__USE_POSIX + || defšed +__USE_MISC + + +98 +__STDIO_INLINE + + +99 + $putc_uÆocked + ( +__c +, +FILE + * +__¡»am +) + +101 + `_IO_putc_uÆocked + ( +__c +, +__¡»am +); + +102 + } +} + +105 +__STDIO_INLINE + + +106 + $putch¬_uÆocked + ( +__c +) + +108 + `_IO_putc_uÆocked + ( +__c +, +¡dout +); + +109 + } +} + +113 #ifdef +__USE_GNU + + +115 +__STDIO_INLINE + +_IO_ssize_t + + +116 + $g‘lše + (** +__lš•Œ +, +size_t + * +__n +, +FILE + * +__¡»am +) + +118 + `__g‘d–im + ( +__lš•Œ +, +__n +, '\n', +__¡»am +); + +119 + } +} + +123 #ifdeà +__USE_MISC + + +125 +__STDIO_INLINE + + +126 +__NTH + ( + $ãof_uÆocked + ( +FILE + * +__¡»am +)) + +128 + `_IO_ãof_uÆocked + ( +__¡»am +); + +129 + } +} + +132 +__STDIO_INLINE + + +133 +__NTH + ( + $ã¼Ü_uÆocked + ( +FILE + * +__¡»am +)) + +135 + `_IO_ã¼Ü_uÆocked + ( +__¡»am +); + +136 + } +} + +142 #ià +defšed + +__USE_MISC + && defšed +__GNUC__ + && defšed +__OPTIMIZE__ + \ + +143 && ! +defšed + + g__ýlu¥lus + + +145 + #ä—d_uÆocked +( +±r +, +size +, +n +, +¡»am +) \ + +146 ( + `__ex‹nsiÚ__ + (( + `__bužtš_cÚ¡ªt_p + ( +size +è&& __bužtš_cÚ¡ªt_°( +n +) \ + +147 && ( +size_t +è( +size +è* (size_tè( +n +) <= 8 \ + +148 && ( +size_t +è( +size +) != 0) \ + +149 ? ({ * +__±r + = (*è( +±r +); \ + +150 +FILE + * +__¡»am + = ( +¡»am +); \ + +151 +size_t + +__út +; \ + +152 +__út + = ( +size_t +è( +size +è* (size_tè( +n +); \ + +153 +__út + > 0; --__cnt) \ + +155 +__c + = + `_IO_g‘c_uÆocked + ( +__¡»am +); \ + +156 ià( +__c + =ð +EOF +) \ + +158 * +__±r +++ = +__c +; \ + +160 (( +size_t +è( +size +è* (size_tè( +n +è- +__út +) \ + +161 / ( +size_t +è( +size +); }) \ + +162 : ((( + `__bužtš_cÚ¡ªt_p + ( +size +è&& ( +size_t +) (size) == 0) \ + +163 || ( + `__bužtš_cÚ¡ªt_p + ( +n +è&& ( +size_t +) (n) == 0)) \ + +165 ? (( è( +±r +), ( è( +¡»am +), ( è( +size +), \ + +166 ( è( +n +), ( +size_t +) 0) \ + +167 : + `ä—d_uÆocked + ( +±r +, +size +, +n +, +¡»am +)))) + + ) + +169 + #fwr™e_uÆocked +( +±r +, +size +, +n +, +¡»am +) \ + +170 ( + `__ex‹nsiÚ__ + (( + `__bužtš_cÚ¡ªt_p + ( +size +è&& __bužtš_cÚ¡ªt_°( +n +) \ + +171 && ( +size_t +è( +size +è* (size_tè( +n +) <= 8 \ + +172 && ( +size_t +è( +size +) != 0) \ + +173 ? ({ cÚ¡ * +__±r + = (cÚ¡ *è( +±r +); \ + +174 +FILE + * +__¡»am + = ( +¡»am +); \ + +175 +size_t + +__út +; \ + +176 +__út + = ( +size_t +è( +size +è* (size_tè( +n +); \ + +177 +__út + > 0; --__cnt) \ + +178 ià( + `_IO_putc_uÆocked + (* +__±r +++, +__¡»am +è=ð +EOF +) \ + +180 (( +size_t +è( +size +è* (size_tè( +n +è- +__út +) \ + +181 / ( +size_t +è( +size +); }) \ + +182 : ((( + `__bužtš_cÚ¡ªt_p + ( +size +è&& ( +size_t +) (size) == 0) \ + +183 || ( + `__bužtš_cÚ¡ªt_p + ( +n +è&& ( +size_t +) (n) == 0)) \ + +185 ? (( è( +±r +), ( è( +¡»am +), ( è( +size +), \ + +186 ( è( +n +), ( +size_t +) 0) \ + +187 : + `fwr™e_uÆocked + ( +±r +, +size +, +n +, +¡»am +)))) + + ) + +191 #undeà +__STDIO_INLINE + + + @/usr/include/bits/stdio2.h + +20 #iâdeà +_STDIO_H + + +24
+ $__¥rštf_chk + (* +__»¡riù + +__s +, +__æag +, +size_t + +__¦’ +, + +25 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...è +__THROW +; + +26
+ $__v¥rštf_chk + (* +__»¡riù + +__s +, +__æag +, +size_t + +__¦’ +, + +27 +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +28 +_G_va_li¡ + +__ +è +__THROW +; + +30 #ifdeà +__va_¬g_·ck + + +31 +__ex‹º_®ways_šlše + + +32 + `__NTH + ( + $¥rštf + (* +__»¡riù + +__s +, +__cÚ¡ + *__»¡riù +__fmt +, ...)) + +34 + `__bužtš___¥rštf_chk + ( +__s +, +__USE_FORTIFY_LEVEL + - 1, + +35 + `__bos + ( +__s +), +__fmt +, + `__va_¬g_·ck + ()); + +36 + } +} + +37 #–ià! +defšed + +__ýlu¥lus + + +38 + #¥rštf +( +¡r +, ...) \ + +39 + `__bužtš___¥rštf_chk + ( +¡r +, +__USE_FORTIFY_LEVEL + - 1, + `__bos + (str), \ + +40 +__VA_ARGS__ +) + + ) + +43 +__ex‹º_®ways_šlše + + +44 +__NTH + ( + $v¥rštf + (* +__»¡riù + +__s +, +__cÚ¡ + *__»¡riù +__fmt +, + +45 +_G_va_li¡ + +__ +)) + +47 + `__bužtš___v¥rštf_chk + ( +__s +, +__USE_FORTIFY_LEVEL + - 1, + +48 + `__bos + ( +__s +), +__fmt +, +__ +); + +49 + } +} + +51 #ià +defšed + +__USE_BSD + || defšed +__USE_ISOC99 + || defšed +__USE_UNIX98 + + +53
+ $__¢´štf_chk + (* +__»¡riù + +__s +, +size_t + +__n +, +__æag +, + +54 +size_t + +__¦’ +, +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +55 ...è +__THROW +; + +56
+ $__v¢´štf_chk + (* +__»¡riù + +__s +, +size_t + +__n +, +__æag +, + +57 +size_t + +__¦’ +, +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +58 +_G_va_li¡ + +__ +è +__THROW +; + +60 #ifdeà +__va_¬g_·ck + + +61 +__ex‹º_®ways_šlše + + +62 + `__NTH + ( + $¢´štf + (* +__»¡riù + +__s +, +size_t + +__n +, + +63 +__cÚ¡ + * +__»¡riù + +__fmt +, ...)) + +65 + `__bužtš___¢´štf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +66 + `__bos + ( +__s +), +__fmt +, + `__va_¬g_·ck + ()); + +67 + } +} + +68 #–ià! +defšed + +__ýlu¥lus + + +69 + #¢´štf +( +¡r +, +Ën +, ...) \ + +70 + `__bužtš___¢´štf_chk + ( +¡r +, +Ën +, +__USE_FORTIFY_LEVEL + - 1, + `__bos + (str), \ + +71 +__VA_ARGS__ +) + + ) + +74 +__ex‹º_®ways_šlše + + +75 +__NTH + ( + $v¢´štf + (* +__»¡riù + +__s +, +size_t + +__n +, + +76 +__cÚ¡ + * +__»¡riù + +__fmt +, +_G_va_li¡ + +__ +)) + +78 + `__bužtš___v¢´štf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +79 + `__bos + ( +__s +), +__fmt +, +__ +); + +80 + } +} + +84 #ià +__USE_FORTIFY_LEVEL + > 1 + +86
+__årštf_chk + ( +FILE + * +__»¡riù + +__¡»am +, +__æag +, + +87 +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...); + +88
+__´štf_chk + ( +__æag +, +__cÚ¡ + * +__»¡riù + +__fÜm© +, ...); + +89
+__vårštf_chk + ( +FILE + * +__»¡riù + +__¡»am +, +__æag +, + +90 +__cÚ¡ + * +__»¡riù + +__fÜm© +, +_G_va_li¡ + +__ +); + +91
+__v´štf_chk + ( +__æag +, +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +92 +_G_va_li¡ + +__ +); + +94 #ifdeà +__va_¬g_·ck + + +95 +__ex‹º_®ways_šlše + + +96 + $årštf + ( +FILE + * +__»¡riù + +__¡»am +, +__cÚ¡ + *__»¡riù +__fmt +, ...) + +98 + `__årštf_chk + ( +__¡»am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +99 + `__va_¬g_·ck + ()); + +100 + } +} + +102 +__ex‹º_®ways_šlše + + +103 + $´štf + ( +__cÚ¡ + * +__»¡riù + +__fmt +, ...) + +105 + `__´štf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + `__va_¬g_·ck + ()); + +106 + } +} + +107 #–ià! +defšed + +__ýlu¥lus + + +108 + #´štf +(...) \ + +109 + `__´štf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +110 + #årštf +( +¡»am +, ...) \ + +111 + `__årštf_chk + ( +¡»am +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +114 +__ex‹º_®ways_šlše + + +115 + $v´štf + ( +__cÚ¡ + * +__»¡riù + +__fmt +, +_G_va_li¡ + +__ +) + +117 #ifdeà +__USE_EXTERN_INLINES + + +118 + `__vårštf_chk + ( +¡dout +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +120 + `__v´štf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +122 + } +} + +124 +__ex‹º_®ways_šlše + + +125 + $vårštf + ( +FILE + * +__»¡riù + +__¡»am +, + +126 +__cÚ¡ + * +__»¡riù + +__fmt +, +_G_va_li¡ + +__ +) + +128 + `__vårštf_chk + ( +__¡»am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +129 + } +} + +131 #ifdeà +__USE_GNU + + +133
+ $__a¥rštf_chk + (** +__»¡riù + +__±r +, +__æag +, + +134 +__cÚ¡ + * +__»¡riù + +__fmt +, ...) + +135 +__THROW + + `__©Œibu‹__ + (( + $__fÜm©__ + ( +__´štf__ +, 3, 4))è +__wur +; + +136
+ $__va¥rštf_chk + (** +__»¡riù + +__±r +, +__æag +, + +137 +__cÚ¡ + * +__»¡riù + +__fmt +, +_G_va_li¡ + +__¬g +) + +138 +__THROW + + `__©Œibu‹__ + (( + $__fÜm©__ + ( +__´štf__ +, 3, 0))è +__wur +; + +139
+ $__d´štf_chk + ( +__fd +, +__æag +, +__cÚ¡ + * +__»¡riù + +__fmt +, + +140 ...è + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__´štf__ +, 3, 4))); + +141
+ $__vd´štf_chk + ( +__fd +, +__æag +, + +142 +__cÚ¡ + * +__»¡riù + +__fmt +, +_G_va_li¡ + +__¬g +) + +143 + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__´štf__ +, 3, 0))); + +144
+ $__ob¡ack_´štf_chk + ( +ob¡ack + * +__»¡riù + +__ob¡ack +, + +145 +__æag +, +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +147 +__THROW + + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__´štf__ +, 3, 4))); + +148
+ $__ob¡ack_v´štf_chk + ( +ob¡ack + * +__»¡riù + +__ob¡ack +, + +149 +__æag +, + +150 +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +151 +_G_va_li¡ + +__¬gs +) + +152 +__THROW + + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__´štf__ +, 3, 0))); + +154 #ifdeà +__va_¬g_·ck + + +155 +__ex‹º_®ways_šlše + + +156 + `__NTH + ( + $a¥rštf + (** +__»¡riù + +__±r +, +__cÚ¡ + *__»¡riù +__fmt +, ...)) + +158 + `__a¥rštf_chk + ( +__±r +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +159 + `__va_¬g_·ck + ()); + +160 + } +} + +162 +__ex‹º_®ways_šlše + + +163 +__NTH + ( + $__a¥rštf + (** +__»¡riù + +__±r +, +__cÚ¡ + *__»¡riù +__fmt +, + +166 + `__a¥rštf_chk + ( +__±r +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +167 + `__va_¬g_·ck + ()); + +168 + } +} + +170 +__ex‹º_®ways_šlše + + +171 + $d´štf + ( +__fd +, +__cÚ¡ + * +__»¡riù + +__fmt +, ...) + +173 + `__d´štf_chk + ( +__fd +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +174 + `__va_¬g_·ck + ()); + +175 + } +} + +177 +__ex‹º_®ways_šlše + + +178 +__NTH + ( + $ob¡ack_´štf + ( +ob¡ack + * +__»¡riù + +__ob¡ack +, + +179 +__cÚ¡ + * +__»¡riù + +__fmt +, ...)) + +181 + `__ob¡ack_´štf_chk + ( +__ob¡ack +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +182 + `__va_¬g_·ck + ()); + +183 + } +} + +184 #–ià! +defšed + +__ýlu¥lus + + +185 + #a¥rštf +( +±r +, ...) \ + +186 + `__a¥rštf_chk + ( +±r +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +187 + #__a¥rštf +( +±r +, ...) \ + +188 + `__a¥rštf_chk + ( +±r +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +189 + #d´štf +( +fd +, ...) \ + +190 + `__d´štf_chk + ( +fd +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +191 + #ob¡ack_´štf +( +ob¡ack +, ...) \ + +192 + `__ob¡ack_´štf_chk + ( +ob¡ack +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +195 +__ex‹º_®ways_šlše + + +196 +__NTH + ( + $va¥rštf + (** +__»¡riù + +__±r +, +__cÚ¡ + *__»¡riù +__fmt +, + +197 +_G_va_li¡ + +__ +)) + +199 + `__va¥rštf_chk + ( +__±r +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +200 + } +} + +202 +__ex‹º_®ways_šlše + + +203 + $vd´štf + ( +__fd +, +__cÚ¡ + * +__»¡riù + +__fmt +, +_G_va_li¡ + +__ +) + +205 + `__vd´štf_chk + ( +__fd +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +206 + } +} + +208 +__ex‹º_®ways_šlše + + +209 +__NTH + ( + $ob¡ack_v´štf + ( +ob¡ack + * +__»¡riù + +__ob¡ack +, + +210 +__cÚ¡ + * +__»¡riù + +__fmt +, +_G_va_li¡ + +__ +)) + +212 + `__ob¡ack_v´štf_chk + ( +__ob¡ack +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +213 +__ +); + +214 + } +} + +220
* + $__g‘s_chk + (* +__¡r +, +size_t +è +__wur +; + +221
* + `__REDIRECT + ( +__g‘s_w¬n +, (* +__¡r +), +g‘s +) + +222 +__wur + + `__w¬Ç‰r + ("please use fgets or getline instead, gets can't " + +225 +__ex‹º_®ways_šlše + +__wur + * + +226 + $g‘s + (* +__¡r +) + +228 ià( + `__bos + ( +__¡r +è!ð( +size_t +) -1) + +229 + `__g‘s_chk + ( +__¡r +, + `__bos + (__str)); + +230 + `__g‘s_w¬n + ( +__¡r +); + +231 + } +} + +233
* + $__fg‘s_chk + (* +__»¡riù + +__s +, +size_t + +__size +, +__n +, + +234 +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +235
* + `__REDIRECT + ( +__fg‘s_®Ÿs +, + +236 (* +__»¡riù + +__s +, +__n +, + +237 +FILE + * +__»¡riù + +__¡»am +), +fg‘s +è +__wur +; + +238
* + `__REDIRECT + ( +__fg‘s_chk_w¬n +, + +239 (* +__»¡riù + +__s +, +size_t + +__size +, +__n +, + +240 +FILE + * +__»¡riù + +__¡»am +), +__fg‘s_chk +) + +241 +__wur + + `__w¬Ç‰r + ("fgets called with bigger sizehan†ength " + +244 +__ex‹º_®ways_šlše + +__wur + * + +245 + $fg‘s + (* +__»¡riù + +__s +, +__n +, +FILE + *__»¡riù +__¡»am +) + +247 ià( + `__bos + ( +__s +è!ð( +size_t +) -1) + +249 ià(! + `__bužtš_cÚ¡ªt_p + ( +__n +) || __n <= 0) + +250 + `__fg‘s_chk + ( +__s +, + `__bos + (__s), +__n +, +__¡»am +); + +252 ià(( +size_t +è +__n + > + `__bos + ( +__s +)) + +253 + `__fg‘s_chk_w¬n + ( +__s +, + `__bos + (__s), +__n +, +__¡»am +); + +255 + `__fg‘s_®Ÿs + ( +__s +, +__n +, +__¡»am +); + +256 + } +} + +258
+size_t + + $__ä—d_chk + ( * +__»¡riù + +__±r +, +size_t + +__±¾’ +, + +259 +size_t + +__size +, size_ˆ +__n +, + +260 +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +261
+size_t + + `__REDIRECT + ( +__ä—d_®Ÿs +, + +262 ( * +__»¡riù + +__±r +, +size_t + +__size +, + +263 +size_t + +__n +, +FILE + * +__»¡riù + +__¡»am +), + +264 +ä—d +è +__wur +; + +265
+size_t + + `__REDIRECT + ( +__ä—d_chk_w¬n +, + +266 ( * +__»¡riù + +__±r +, +size_t + +__±¾’ +, + +267 +size_t + +__size +, size_ˆ +__n +, + +268 +FILE + * +__»¡riù + +__¡»am +), + +269 +__ä—d_chk +) + +270 +__wur + + `__w¬Ç‰r + ("fread called with bigger size *‚membhan†ength " + +273 +__ex‹º_®ways_šlše + +__wur + +size_t + + +274 + $ä—d + ( * +__»¡riù + +__±r +, +size_t + +__size +, size_ˆ +__n +, + +275 +FILE + * +__»¡riù + +__¡»am +) + +277 ià( + `__bos0 + ( +__±r +è!ð( +size_t +) -1) + +279 ià(! + `__bužtš_cÚ¡ªt_p + ( +__size +) + +280 || ! + `__bužtš_cÚ¡ªt_p + ( +__n +) + +281 || ( +__size + | +__n +è>ð((( +size_t +) 1) << (8 * (size_t) / 2))) + +282 + `__ä—d_chk + ( +__±r +, + `__bos0 + (__±r), +__size +, +__n +, +__¡»am +); + +284 ià( +__size + * +__n + > + `__bos0 + ( +__±r +)) + +285 + `__ä—d_chk_w¬n + ( +__±r +, + `__bos0 + (__±r), +__size +, +__n +, +__¡»am +); + +287 + `__ä—d_®Ÿs + ( +__±r +, +__size +, +__n +, +__¡»am +); + +288 + } +} + +290 #ifdeà +__USE_GNU + + +291
* + $__fg‘s_uÆocked_chk + (* +__»¡riù + +__s +, +size_t + +__size +, + +292 +__n +, +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +293
* + `__REDIRECT + ( +__fg‘s_uÆocked_®Ÿs +, + +294 (* +__»¡riù + +__s +, +__n +, + +295 +FILE + * +__»¡riù + +__¡»am +), +fg‘s_uÆocked +è +__wur +; + +296
* + `__REDIRECT + ( +__fg‘s_uÆocked_chk_w¬n +, + +297 (* +__»¡riù + +__s +, +size_t + +__size +, +__n +, + +298 +FILE + * +__»¡riù + +__¡»am +), +__fg‘s_uÆocked_chk +) + +299 +__wur + + `__w¬Ç‰r + ("fgets_unlocked called with bigger sizehan†ength " + +302 +__ex‹º_®ways_šlše + +__wur + * + +303 + $fg‘s_uÆocked + (* +__»¡riù + +__s +, +__n +, +FILE + *__»¡riù +__¡»am +) + +305 ià( + `__bos + ( +__s +è!ð( +size_t +) -1) + +307 ià(! + `__bužtš_cÚ¡ªt_p + ( +__n +) || __n <= 0) + +308 + `__fg‘s_uÆocked_chk + ( +__s +, + `__bos + (__s), +__n +, +__¡»am +); + +310 ià(( +size_t +è +__n + > + `__bos + ( +__s +)) + +311 + `__fg‘s_uÆocked_chk_w¬n + ( +__s +, + `__bos + (__s), +__n +, +__¡»am +); + +313 + `__fg‘s_uÆocked_®Ÿs + ( +__s +, +__n +, +__¡»am +); + +314 + } +} + +317 #ifdeà +__USE_MISC + + +318 #undeà +ä—d_uÆocked + + +319
+size_t + + $__ä—d_uÆocked_chk + ( * +__»¡riù + +__±r +, +size_t + +__±¾’ +, + +320 +size_t + +__size +, size_ˆ +__n +, + +321 +FILE + * +__»¡riù + +__¡»am +è +__wur +; + +322
+size_t + + `__REDIRECT + ( +__ä—d_uÆocked_®Ÿs +, + +323 ( * +__»¡riù + +__±r +, +size_t + +__size +, + +324 +size_t + +__n +, +FILE + * +__»¡riù + +__¡»am +), + +325 +ä—d_uÆocked +è +__wur +; + +326
+size_t + + `__REDIRECT + ( +__ä—d_uÆocked_chk_w¬n +, + +327 ( * +__»¡riù + +__±r +, +size_t + +__±¾’ +, + +328 +size_t + +__size +, size_ˆ +__n +, + +329 +FILE + * +__»¡riù + +__¡»am +), + +330 +__ä—d_uÆocked_chk +) + +331 +__wur + + `__w¬Ç‰r + ("fread_unlocked called with bigger size *‚membhan " + +334 +__ex‹º_®ways_šlše + +__wur + +size_t + + +335 + $ä—d_uÆocked + ( * +__»¡riù + +__±r +, +size_t + +__size +, size_ˆ +__n +, + +336 +FILE + * +__»¡riù + +__¡»am +) + +338 ià( + `__bos0 + ( +__±r +è!ð( +size_t +) -1) + +340 ià(! + `__bužtš_cÚ¡ªt_p + ( +__size +) + +341 || ! + `__bužtš_cÚ¡ªt_p + ( +__n +) + +342 || ( +__size + | +__n +è>ð((( +size_t +) 1) << (8 * (size_t) / 2))) + +343 + `__ä—d_uÆocked_chk + ( +__±r +, + `__bos0 + (__±r), +__size +, +__n +, + +344 +__¡»am +); + +346 ià( +__size + * +__n + > + `__bos0 + ( +__±r +)) + +347 + `__ä—d_uÆocked_chk_w¬n + ( +__±r +, + `__bos0 + (__±r), +__size +, +__n +, + +348 +__¡»am +); + +351 #ifdeà +__USE_EXTERN_INLINES + + +352 ià( + `__bužtš_cÚ¡ªt_p + ( +__size +) + +353 && + `__bužtš_cÚ¡ªt_p + ( +__n +) + +354 && ( +__size + | +__n +è< ((( +size_t +) 1) << (8 * (size_t) / 2)) + +355 && +__size + * +__n + <= 8) + +357 +size_t + +__út + = +__size + * +__n +; + +358 * +__ýŒ + = (*è +__±r +; + +359 ià( +__út + == 0) + +362 ; +__út + > 0; --__cnt) + +364 +__c + = + `_IO_g‘c_uÆocked + ( +__¡»am +); + +365 ià( +__c + =ð +EOF +) + +367 * +__ýŒ +++ = +__c +; + +369 ( +__ýŒ + - (*è +__±r +è/ +__size +; + +372 + `__ä—d_uÆocked_®Ÿs + ( +__±r +, +__size +, +__n +, +__¡»am +); + +373 + } +} + + @/usr/include/bits/stdio_lim.h + +19 #ià! +defšed + +_STDIO_H + && !defšed +__Ãed_FOPEN_MAX + && !defšed +__Ãed_IOV_MAX + + +23 #ifdeà +_STDIO_H + + +24 + #L_tm²am + 20 + + ) + +25 + #TMP_MAX + 238328 + + ) + +26 + #FILENAME_MAX + 4096 + + ) + +28 #ifdeà +__USE_POSIX + + +29 + #L_ù”mid + 9 + + ) + +30 #ià! +defšed + +__USE_XOPEN2K + || defšed +__USE_GNU + + +31 + #L_cu£rid + 9 + + ) + +36 #ià +defšed + +__Ãed_FOPEN_MAX + || defšed +_STDIO_H + + +37 #undeà +FOPEN_MAX + + +38 + #FOPEN_MAX + 16 + + ) + +41 #ià +defšed + +__Ãed_IOV_MAX + && !defšed +IOV_MAX + + +42 + #IOV_MAX + 1024 + + ) + + @/usr/include/bits/string.h + +20 #iâdeà +_STRING_H + + +26 + #_STRING_ARCH_uÇligÃd + 1 + + ) + + @/usr/include/bits/string2.h + +21 #iâdeà +_STRING_H + + +25 #ià! +defšed + +__NO_STRING_INLINES + && !defšed +__BOUNDED_POINTERS__ + + +42 #iâdeà +__STRING_INLINE + + +43 #ifdeà +__ýlu¥lus + + +44 + #__STRING_INLINE + +šlše + + + ) + +46 + #__STRING_INLINE + +__ex‹º_šlše + + + ) + +50 #ià +_STRING_ARCH_uÇligÃd + + +52 + ~<’dŸn.h +> + +53 + ~<b™s/ty³s.h +> + +55 #ià +__BYTE_ORDER + =ð +__LITTLE_ENDIAN + + +56 + #__STRING2_SMALL_GET16 +( +¤c +, +idx +) \ + +57 ((( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx + + 1] << 8 \ + +58 | (( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx +]) + + ) + +59 + #__STRING2_SMALL_GET32 +( +¤c +, +idx +) \ + +60 ((((( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx + + 3] << 8 \ + +61 | (( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx + + 2]) << 8 \ + +62 | (( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx + + 1]) << 8 \ + +63 | (( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx +]) + + ) + +65 + #__STRING2_SMALL_GET16 +( +¤c +, +idx +) \ + +66 ((( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx +] << 8 \ + +67 | (( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx + + 1]) + + ) + +68 + #__STRING2_SMALL_GET32 +( +¤c +, +idx +) \ + +69 ((((( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx +] << 8 \ + +70 | (( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx + + 1]) << 8 \ + +71 | (( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx + + 2]) << 8 \ + +72 | (( +__cÚ¡ + *è(__cÚ¡ *è( +¤c +))[ +idx + + 3]) + + ) + +77 + #__STRING2_COPY_TYPE +( +N +) \ + +78 ¡ruù { +__¬r +[ +N +]; } \ + +79 + t__©Œibu‹__ + (( + t__·cked__ +)è + t__STRING2_COPY_ARR +## + tN + + + ) + +80 + t__STRING2_COPY_TYPE + (2); + +81 +__STRING2_COPY_TYPE + (3); + +82 +__STRING2_COPY_TYPE + (4); + +83 +__STRING2_COPY_TYPE + (5); + +84 +__STRING2_COPY_TYPE + (6); + +85 +__STRING2_COPY_TYPE + (7); + +86 +__STRING2_COPY_TYPE + (8); + +87 #undeà +__STRING2_COPY_TYPE + + +93 + #__¡ršg2_1b±r_p +( +__x +) \ + +94 (( +size_t +)(cÚ¡ *)(( +__x +è+ 1è- (size_t)(cÚ¡ *)(__xè=ð1) + + ) + +97 #ià! +defšed + +_HAVE_STRING_ARCH_mem£t + + +98 #ià! +__GNUC_PREREQ + (3, 0) + +99 #ià +_STRING_ARCH_uÇligÃd + + +100 + #mem£t +( +s +, +c +, +n +) \ + +101 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +n +) && (n) <= 16 \ + +102 ? (( +n +) == 1 \ + +103 ? + `__mem£t_1 + ( +s +, +c +) \ + +104 : + `__mem£t_gc + ( +s +, +c +, +n +)) \ + +105 : ( + `__bužtš_cÚ¡ªt_p + ( +c +) && (c) == '\0' \ + +106 ? ({ * +__s + = ( +s +); + `__bz”o + (__s, +n +); __s; }) \ + +107 : + `mem£t + ( +s +, +c +, +n +)))) + + ) + +109 + #__mem£t_1 +( +s +, +c +è({ * +__s + = (s); \ + +110 *(( +__ušt8_t + *è +__s +èð(__ušt8_tè +c +; __s; }) + + ) + +112 + #__mem£t_gc +( +s +, +c +, +n +) \ + +113 ({ * +__s + = ( +s +); \ + +115 +__ui +; \ + +116 +__usi +; \ + +117 +__uc +; \ + +118 } * +__u + = +__s +; \ + +119 +__ušt8_t + +__c + = (__ušt8_tè( +c +); \ + +122 ( è( +n +)) \ + +125 +__u +-> +__ui + = +__c + * 0x01010101; \ + +126 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +128 +__u +-> +__ui + = +__c + * 0x01010101; \ + +129 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +131 +__u +-> +__ui + = +__c + * 0x01010101; \ + +132 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +134 +__u +-> +__usi + = ( è +__c + * 0x0101; \ + +135 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 2); \ + +136 +__u +-> +__uc + = ( è +__c +; \ + +140 +__u +-> +__ui + = +__c + * 0x01010101; \ + +141 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +143 +__u +-> +__ui + = +__c + * 0x01010101; \ + +144 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +146 +__u +-> +__ui + = +__c + * 0x01010101; \ + +147 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +149 +__u +-> +__usi + = ( è +__c + * 0x0101; \ + +153 +__u +-> +__ui + = +__c + * 0x01010101; \ + +154 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +156 +__u +-> +__ui + = +__c + * 0x01010101; \ + +157 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +159 +__u +-> +__ui + = +__c + * 0x01010101; \ + +160 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +162 +__u +-> +__uc + = ( è +__c +; \ + +166 +__u +-> +__ui + = +__c + * 0x01010101; \ + +167 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +169 +__u +-> +__ui + = +__c + * 0x01010101; \ + +170 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +172 +__u +-> +__ui + = +__c + * 0x01010101; \ + +173 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); \ + +175 +__u +-> +__ui + = +__c + * 0x01010101; \ + +180 +__s +; }) + + ) + +182 + #mem£t +( +s +, +c +, +n +) \ + +183 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +c +) && (c) == '\0' \ + +184 ? ({ * +__s + = ( +s +); + `__bz”o + (__s, +n +); __s; }) \ + +185 : + `mem£t + ( +s +, +c +, +n +))) + + ) + +194 #ià +__GNUC_PREREQ + (2, 91) + +195 + #__bz”o +( +s +, +n +è + `__bužtš_mem£t + (s, '\0',‚) + + ) + +203 #ifdeà +__USE_GNU + + +204 #ià! +defšed + +_HAVE_STRING_ARCH_mempýy + || defšed +_FORCE_INLINES + + +205 #iâdeà +_HAVE_STRING_ARCH_mempýy + + +206 #ià +__GNUC_PREREQ + (3, 4) + +207 + #__mempýy +( +de¡ +, +¤c +, +n +è + `__bužtš_mempýy + (de¡, src,‚) + + ) + +208 #–ià +__GNUC_PREREQ + (3, 0) + +209 + #__mempýy +( +de¡ +, +¤c +, +n +) \ + +210 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +¤c +è&& __bužtš_cÚ¡ªt_°( +n +) \ + +211 && + `__¡ršg2_1b±r_p + ( +¤c +è&& +n + <= 8 \ + +212 ? + `__bužtš_memýy + ( +de¡ +, +¤c +, +n +) + (n) \ + +213 : + `__mempýy + ( +de¡ +, +¤c +, +n +))) + + ) + +215 + #__mempýy +( +de¡ +, +¤c +, +n +) \ + +216 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +¤c +è&& __bužtš_cÚ¡ªt_°( +n +) \ + +217 && + `__¡ršg2_1b±r_p + ( +¤c +è&& +n + <= 8 \ + +218 ? + `__mempýy_sm®l + ( +de¡ +, + `__mempýy_¬gs + ( +¤c +), +n +) \ + +219 : + `__mempýy + ( +de¡ +, +¤c +, +n +))) + + ) + +223 + #mempýy +( +de¡ +, +¤c +, +n +è + `__mempýy + (de¡, src,‚) + + ) + +226 #ià! +__GNUC_PREREQ + (3, 0è|| +defšed + +_FORCE_INLINES + + +227 #ià +_STRING_ARCH_uÇligÃd + + +228 #iâdeà +_FORCE_INLINES + + +229 + #__mempýy_¬gs +( +¤c +) \ + +230 (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[2], \ + +231 (( +__cÚ¡ + *è( +¤c +))[4], ((__const *) (src))[6], \ + +232 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET16 + ( +¤c +, 0), \ + +233 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET16 + ( +¤c +, 4), \ + +234 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET32 + ( +¤c +, 0), \ + +235 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET32 + ( +¤c +, 4) + + ) + +237 +__STRING_INLINE + * +__mempýy_sm®l + ( *, , , , , + +238 +__ušt16_t +, __ušt16_t, +__ušt32_t +, + +239 +__ušt32_t +, +size_t +); + +240 +__STRING_INLINE + * + +241 + $__mempýy_sm®l + ( * +__de¡1 +, + +242 +__¤c0_1 +, +__¤c2_1 +, +__¤c4_1 +, +__¤c6_1 +, + +243 +__ušt16_t + +__¤c0_2 +, __ušt16_ˆ +__¤c4_2 +, + +244 +__ušt32_t + +__¤c0_4 +, __ušt32_ˆ +__¤c4_4 +, + +245 +size_t + +__¤þ’ +) + +248 +__ušt32_t + +__ui +; + +249 +__ušt16_t + +__usi +; + +250 +__uc +; + +251 +__c +; + +252 } * +__u + = +__de¡1 +; + +253 ( è +__¤þ’ +) + +256 +__u +-> +__c + = +__¤c0_1 +; + +257 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 1); + +260 +__u +-> +__usi + = +__¤c0_2 +; + +261 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 2); + +264 +__u +-> +__usi + = +__¤c0_2 +; + +265 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 2); + +266 +__u +-> +__c + = +__¤c2_1 +; + +267 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 1); + +270 +__u +-> +__ui + = +__¤c0_4 +; + +271 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +274 +__u +-> +__ui + = +__¤c0_4 +; + +275 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +276 +__u +-> +__c + = +__¤c4_1 +; + +277 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 1); + +280 +__u +-> +__ui + = +__¤c0_4 +; + +281 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +282 +__u +-> +__usi + = +__¤c4_2 +; + +283 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 2); + +286 +__u +-> +__ui + = +__¤c0_4 +; + +287 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +288 +__u +-> +__usi + = +__¤c4_2 +; + +289 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 2); + +290 +__u +-> +__c + = +__¤c6_1 +; + +291 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 1); + +294 +__u +-> +__ui + = +__¤c0_4 +; + +295 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +296 +__u +-> +__ui + = +__¤c4_4 +; + +297 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +300 ( *è +__u +; + +301 + } +} + +303 #iâdeà +_FORCE_INLINES + + +304 + #__mempýy_¬gs +( +¤c +) \ + +305 (( +__cÚ¡ + *è( +¤c +))[0], \ + +306 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR2 +) \ + +307 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1] } }), \ + +308 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR3 +) \ + +309 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +310 (( +__cÚ¡ + *è( +¤c +))[2] } }), \ + +311 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR4 +) \ + +312 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +313 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3] } }), \ + +314 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR5 +) \ + +315 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +316 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +317 (( +__cÚ¡ + *è( +¤c +))[4] } }), \ + +318 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR6 +) \ + +319 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +320 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +321 (( +__cÚ¡ + *è( +¤c +))[4], ((__const *) (src))[5] } }), \ + +322 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR7 +) \ + +323 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +324 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +325 (( +__cÚ¡ + *è( +¤c +))[4], ((__const *) (src))[5], \ + +326 (( +__cÚ¡ + *è( +¤c +))[6] } }), \ + +327 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR8 +) \ + +328 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +329 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +330 (( +__cÚ¡ + *è( +¤c +))[4], ((__const *) (src))[5], \ + +331 (( +__cÚ¡ + *è( +¤c +))[6], ((__cÚ¡ *è(¤c))[7] } }) + + ) + +333 +__STRING_INLINE + * +__mempýy_sm®l + ( *, , +__STRING2_COPY_ARR2 +, + +334 +__STRING2_COPY_ARR3 +, + +335 +__STRING2_COPY_ARR4 +, + +336 +__STRING2_COPY_ARR5 +, + +337 +__STRING2_COPY_ARR6 +, + +338 +__STRING2_COPY_ARR7 +, + +339 +__STRING2_COPY_ARR8 +, +size_t +); + +340 +__STRING_INLINE + * + +341 + $__mempýy_sm®l + ( * +__de¡ +, +__¤c1 +, + +342 +__STRING2_COPY_ARR2 + +__¤c2 +, +__STRING2_COPY_ARR3 + +__¤c3 +, + +343 +__STRING2_COPY_ARR4 + +__¤c4 +, +__STRING2_COPY_ARR5 + +__¤c5 +, + +344 +__STRING2_COPY_ARR6 + +__¤c6 +, +__STRING2_COPY_ARR7 + +__¤c7 +, + +345 +__STRING2_COPY_ARR8 + +__¤c8 +, +size_t + +__¤þ’ +) + +348 +__c +; + +349 +__STRING2_COPY_ARR2 + +__sÿ2 +; + +350 +__STRING2_COPY_ARR3 + +__sÿ3 +; + +351 +__STRING2_COPY_ARR4 + +__sÿ4 +; + +352 +__STRING2_COPY_ARR5 + +__sÿ5 +; + +353 +__STRING2_COPY_ARR6 + +__sÿ6 +; + +354 +__STRING2_COPY_ARR7 + +__sÿ7 +; + +355 +__STRING2_COPY_ARR8 + +__sÿ8 +; + +356 } * +__u + = +__de¡ +; + +357 ( è +__¤þ’ +) + +360 +__u +-> +__c + = +__¤c1 +; + +363 +__ex‹nsiÚ__ + +__u +-> +__sÿ2 + = +__¤c2 +; + +366 +__ex‹nsiÚ__ + +__u +-> +__sÿ3 + = +__¤c3 +; + +369 +__ex‹nsiÚ__ + +__u +-> +__sÿ4 + = +__¤c4 +; + +372 +__ex‹nsiÚ__ + +__u +-> +__sÿ5 + = +__¤c5 +; + +375 +__ex‹nsiÚ__ + +__u +-> +__sÿ6 + = +__¤c6 +; + +378 +__ex‹nsiÚ__ + +__u +-> +__sÿ7 + = +__¤c7 +; + +381 +__ex‹nsiÚ__ + +__u +-> +__sÿ8 + = +__¤c8 +; + +384 + `__ex‹nsiÚ__ + (( *è +__u + + +__¤þ’ +); + +385 + } +} + +393 #iâdeà +_HAVE_STRING_ARCH_¡rchr + + +394
* +__¿wmemchr + (cÚ¡ * +__s +, +__c +); + +395 #ià +__GNUC_PREREQ + (3, 2) + +396 + #¡rchr +( +s +, +c +) \ + +397 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +c +è&& !__bužtš_cÚ¡ªt_°( +s +) \ + +398 && ( +c +) == '\0' \ + +399 ? (*è + `__¿wmemchr + ( +s +, +c +) \ + +400 : + `__bužtš_¡rchr + ( +s +, +c +))) + + ) + +402 + #¡rchr +( +s +, +c +) \ + +403 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +c +) && (c) == '\0' \ + +404 ? (*è + `__¿wmemchr + ( +s +, +c +) \ + +405 : + `¡rchr + ( +s +, +c +))) + + ) + +411 #ià(! +defšed + +_HAVE_STRING_ARCH_¡rýy + && ! +__GNUC_PREREQ + (3, 0)) \ + +412 || +defšed + + g_FORCE_INLINES + + +413 #ià! +defšed + +_HAVE_STRING_ARCH_¡rýy + && ! +__GNUC_PREREQ + (3, 0) + +414 + #¡rýy +( +de¡ +, +¤c +) \ + +415 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +¤c +) \ + +416 ? ( + `__¡ršg2_1b±r_p + ( +¤c +è&& + `¡¾’ + (src) + 1 <= 8 \ + +417 ? + `__¡rýy_sm®l + ( +de¡ +, + `__¡rýy_¬gs + ( +¤c +), \ + +418 + `¡¾’ + ( +¤c +) + 1) \ + +419 : (*è + `memýy + ( +de¡ +, +¤c +, + `¡¾’ + (src) + 1)) \ + +420 : + `¡rýy + ( +de¡ +, +¤c +))) + + ) + +423 #ià +_STRING_ARCH_uÇligÃd + + +424 #iâdeà +_FORCE_INLINES + + +425 + #__¡rýy_¬gs +( +¤c +) \ + +426 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET16 + ( +¤c +, 0), \ + +427 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET16 + ( +¤c +, 4), \ + +428 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET32 + ( +¤c +, 0), \ + +429 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET32 + ( +¤c +, 4) + + ) + +431 +__STRING_INLINE + * +__¡rýy_sm®l + (*, +__ušt16_t +, __uint16_t, + +432 +__ušt32_t +, __ušt32_t, +size_t +); + +433 +__STRING_INLINE + * + +434 + $__¡rýy_sm®l + (* +__de¡ +, + +435 +__ušt16_t + +__¤c0_2 +, __ušt16_ˆ +__¤c4_2 +, + +436 +__ušt32_t + +__¤c0_4 +, __ušt32_ˆ +__¤c4_4 +, + +437 +size_t + +__¤þ’ +) + +440 +__ušt32_t + +__ui +; + +441 +__ušt16_t + +__usi +; + +442 +__uc +; + +443 } * +__u + = ( *è +__de¡ +; + +444 ( è +__¤þ’ +) + +447 +__u +-> +__uc + = '\0'; + +450 +__u +-> +__usi + = +__¤c0_2 +; + +453 +__u +-> +__usi + = +__¤c0_2 +; + +454 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 2); + +455 +__u +-> +__uc + = '\0'; + +458 +__u +-> +__ui + = +__¤c0_4 +; + +461 +__u +-> +__ui + = +__¤c0_4 +; + +462 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +463 +__u +-> +__uc + = '\0'; + +466 +__u +-> +__ui + = +__¤c0_4 +; + +467 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +468 +__u +-> +__usi + = +__¤c4_2 +; + +471 +__u +-> +__ui + = +__¤c0_4 +; + +472 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +473 +__u +-> +__usi + = +__¤c4_2 +; + +474 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 2); + +475 +__u +-> +__uc + = '\0'; + +478 +__u +-> +__ui + = +__¤c0_4 +; + +479 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +480 +__u +-> +__ui + = +__¤c4_4 +; + +483 +__de¡ +; + +484 + } +} + +486 #iâdeà +_FORCE_INLINES + + +487 + #__¡rýy_¬gs +( +¤c +) \ + +488 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR2 +) \ + +489 { { (( +__cÚ¡ + *è( +¤c +))[0], '\0' } }), \ + +490 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR3 +) \ + +491 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +493 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR4 +) \ + +494 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +495 (( +__cÚ¡ + *è( +¤c +))[2], '\0' } }), \ + +496 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR5 +) \ + +497 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +498 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +500 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR6 +) \ + +501 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +502 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +503 (( +__cÚ¡ + *è( +¤c +))[4], '\0' } }), \ + +504 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR7 +) \ + +505 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +506 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +507 (( +__cÚ¡ + *è( +¤c +))[4], ((__const *) (src))[5], \ + +509 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR8 +) \ + +510 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +511 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +512 (( +__cÚ¡ + *è( +¤c +))[4], ((__const *) (src))[5], \ + +513 (( +__cÚ¡ + *è( +¤c +))[6], '\0' } }) + + ) + +515 +__STRING_INLINE + * +__¡rýy_sm®l + (*, +__STRING2_COPY_ARR2 +, + +516 +__STRING2_COPY_ARR3 +, + +517 +__STRING2_COPY_ARR4 +, + +518 +__STRING2_COPY_ARR5 +, + +519 +__STRING2_COPY_ARR6 +, + +520 +__STRING2_COPY_ARR7 +, + +521 +__STRING2_COPY_ARR8 +, +size_t +); + +522 +__STRING_INLINE + * + +523 + $__¡rýy_sm®l + (* +__de¡ +, + +524 +__STRING2_COPY_ARR2 + +__¤c2 +, +__STRING2_COPY_ARR3 + +__¤c3 +, + +525 +__STRING2_COPY_ARR4 + +__¤c4 +, +__STRING2_COPY_ARR5 + +__¤c5 +, + +526 +__STRING2_COPY_ARR6 + +__¤c6 +, +__STRING2_COPY_ARR7 + +__¤c7 +, + +527 +__STRING2_COPY_ARR8 + +__¤c8 +, +size_t + +__¤þ’ +) + +530 +__c +; + +531 +__STRING2_COPY_ARR2 + +__sÿ2 +; + +532 +__STRING2_COPY_ARR3 + +__sÿ3 +; + +533 +__STRING2_COPY_ARR4 + +__sÿ4 +; + +534 +__STRING2_COPY_ARR5 + +__sÿ5 +; + +535 +__STRING2_COPY_ARR6 + +__sÿ6 +; + +536 +__STRING2_COPY_ARR7 + +__sÿ7 +; + +537 +__STRING2_COPY_ARR8 + +__sÿ8 +; + +538 } * +__u + = ( *è +__de¡ +; + +539 ( è +__¤þ’ +) + +542 +__u +-> +__c + = '\0'; + +545 +__ex‹nsiÚ__ + +__u +-> +__sÿ2 + = +__¤c2 +; + +548 +__ex‹nsiÚ__ + +__u +-> +__sÿ3 + = +__¤c3 +; + +551 +__ex‹nsiÚ__ + +__u +-> +__sÿ4 + = +__¤c4 +; + +554 +__ex‹nsiÚ__ + +__u +-> +__sÿ5 + = +__¤c5 +; + +557 +__ex‹nsiÚ__ + +__u +-> +__sÿ6 + = +__¤c6 +; + +560 +__ex‹nsiÚ__ + +__u +-> +__sÿ7 + = +__¤c7 +; + +563 +__ex‹nsiÚ__ + +__u +-> +__sÿ8 + = +__¤c8 +; + +566 +__de¡ +; + +567 + } +} + +573 #ifdeà +__USE_GNU + + +574 #ià! +defšed + +_HAVE_STRING_ARCH_¡pýy + || defšed +_FORCE_INLINES + + +575 #iâdeà +_HAVE_STRING_ARCH_¡pýy + + +576 #ià +__GNUC_PREREQ + (3, 4) + +577 + #__¡pýy +( +de¡ +, +¤c +è + `__bužtš_¡pýy + (de¡, src) + + ) + +578 #–ià +__GNUC_PREREQ + (3, 0) + +579 + #__¡pýy +( +de¡ +, +¤c +) \ + +580 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +¤c +) \ + +581 ? ( + `__¡ršg2_1b±r_p + ( +¤c +è&& + `¡¾’ + (src) + 1 <= 8 \ + +582 ? + `__bužtš_¡rýy + ( +de¡ +, +¤c +è+ + `¡¾’ + (src) \ + +583 : ((*è( +__mempýy +è( +de¡ +, +¤c +, + `¡¾’ + (src) + 1) \ + +585 : + `__¡pýy + ( +de¡ +, +¤c +))) + + ) + +587 + #__¡pýy +( +de¡ +, +¤c +) \ + +588 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +¤c +) \ + +589 ? ( + `__¡ršg2_1b±r_p + ( +¤c +è&& + `¡¾’ + (src) + 1 <= 8 \ + +590 ? + `__¡pýy_sm®l + ( +de¡ +, + `__¡pýy_¬gs + ( +¤c +), \ + +591 + `¡¾’ + ( +¤c +) + 1) \ + +592 : ((*è( +__mempýy +è( +de¡ +, +¤c +, + `¡¾’ + (src) + 1) \ + +594 : + `__¡pýy + ( +de¡ +, +¤c +))) + + ) + +598 + #¡pýy +( +de¡ +, +¤c +è + `__¡pýy + (de¡, src) + + ) + +601 #ià! +__GNUC_PREREQ + (3, 0è|| +defšed + +_FORCE_INLINES + + +602 #ià +_STRING_ARCH_uÇligÃd + + +603 #iâdeà +_FORCE_INLINES + + +604 + #__¡pýy_¬gs +( +¤c +) \ + +605 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET16 + ( +¤c +, 0), \ + +606 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET16 + ( +¤c +, 4), \ + +607 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET32 + ( +¤c +, 0), \ + +608 +__ex‹nsiÚ__ + + `__STRING2_SMALL_GET32 + ( +¤c +, 4) + + ) + +610 +__STRING_INLINE + * +__¡pýy_sm®l + (*, +__ušt16_t +, __uint16_t, + +611 +__ušt32_t +, __ušt32_t, +size_t +); + +612 +__STRING_INLINE + * + +613 + $__¡pýy_sm®l + (* +__de¡ +, + +614 +__ušt16_t + +__¤c0_2 +, __ušt16_ˆ +__¤c4_2 +, + +615 +__ušt32_t + +__¤c0_4 +, __ušt32_ˆ +__¤c4_4 +, + +616 +size_t + +__¤þ’ +) + +619 +__ui +; + +620 +__usi +; + +621 +__uc +; + +622 +__c +; + +623 } * +__u + = ( *è +__de¡ +; + +624 ( è +__¤þ’ +) + +627 +__u +-> +__uc + = '\0'; + +630 +__u +-> +__usi + = +__¤c0_2 +; + +631 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 1); + +634 +__u +-> +__usi + = +__¤c0_2 +; + +635 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 2); + +636 +__u +-> +__uc + = '\0'; + +639 +__u +-> +__ui + = +__¤c0_4 +; + +640 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 3); + +643 +__u +-> +__ui + = +__¤c0_4 +; + +644 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +645 +__u +-> +__uc + = '\0'; + +648 +__u +-> +__ui + = +__¤c0_4 +; + +649 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +650 +__u +-> +__usi + = +__¤c4_2 +; + +651 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 1); + +654 +__u +-> +__ui + = +__¤c0_4 +; + +655 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +656 +__u +-> +__usi + = +__¤c4_2 +; + +657 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 2); + +658 +__u +-> +__uc + = '\0'; + +661 +__u +-> +__ui + = +__¤c0_4 +; + +662 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 4); + +663 +__u +-> +__ui + = +__¤c4_4 +; + +664 +__u + = + `__ex‹nsiÚ__ + (( *) __u + 3); + +667 & +__u +-> +__c +; + +668 + } +} + +670 #iâdeà +_FORCE_INLINES + + +671 + #__¡pýy_¬gs +( +¤c +) \ + +672 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR2 +) \ + +673 { { (( +__cÚ¡ + *è( +¤c +))[0], '\0' } }), \ + +674 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR3 +) \ + +675 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +677 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR4 +) \ + +678 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +679 (( +__cÚ¡ + *è( +¤c +))[2], '\0' } }), \ + +680 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR5 +) \ + +681 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +682 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +684 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR6 +) \ + +685 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +686 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +687 (( +__cÚ¡ + *è( +¤c +))[4], '\0' } }), \ + +688 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR7 +) \ + +689 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +690 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +691 (( +__cÚ¡ + *è( +¤c +))[4], ((__const *) (src))[5], \ + +693 + `__ex‹nsiÚ__ + (( +__STRING2_COPY_ARR8 +) \ + +694 { { (( +__cÚ¡ + *è( +¤c +))[0], ((__const *) (src))[1], \ + +695 (( +__cÚ¡ + *è( +¤c +))[2], ((__const *) (src))[3], \ + +696 (( +__cÚ¡ + *è( +¤c +))[4], ((__const *) (src))[5], \ + +697 (( +__cÚ¡ + *è( +¤c +))[6], '\0' } }) + + ) + +699 +__STRING_INLINE + * +__¡pýy_sm®l + (*, +__STRING2_COPY_ARR2 +, + +700 +__STRING2_COPY_ARR3 +, + +701 +__STRING2_COPY_ARR4 +, + +702 +__STRING2_COPY_ARR5 +, + +703 +__STRING2_COPY_ARR6 +, + +704 +__STRING2_COPY_ARR7 +, + +705 +__STRING2_COPY_ARR8 +, +size_t +); + +706 +__STRING_INLINE + * + +707 + $__¡pýy_sm®l + (* +__de¡ +, + +708 +__STRING2_COPY_ARR2 + +__¤c2 +, +__STRING2_COPY_ARR3 + +__¤c3 +, + +709 +__STRING2_COPY_ARR4 + +__¤c4 +, +__STRING2_COPY_ARR5 + +__¤c5 +, + +710 +__STRING2_COPY_ARR6 + +__¤c6 +, +__STRING2_COPY_ARR7 + +__¤c7 +, + +711 +__STRING2_COPY_ARR8 + +__¤c8 +, +size_t + +__¤þ’ +) + +714 +__c +; + +715 +__STRING2_COPY_ARR2 + +__sÿ2 +; + +716 +__STRING2_COPY_ARR3 + +__sÿ3 +; + +717 +__STRING2_COPY_ARR4 + +__sÿ4 +; + +718 +__STRING2_COPY_ARR5 + +__sÿ5 +; + +719 +__STRING2_COPY_ARR6 + +__sÿ6 +; + +720 +__STRING2_COPY_ARR7 + +__sÿ7 +; + +721 +__STRING2_COPY_ARR8 + +__sÿ8 +; + +722 } * +__u + = ( *è +__de¡ +; + +723 ( è +__¤þ’ +) + +726 +__u +-> +__c + = '\0'; + +729 +__ex‹nsiÚ__ + +__u +-> +__sÿ2 + = +__¤c2 +; + +732 +__ex‹nsiÚ__ + +__u +-> +__sÿ3 + = +__¤c3 +; + +735 +__ex‹nsiÚ__ + +__u +-> +__sÿ4 + = +__¤c4 +; + +738 +__ex‹nsiÚ__ + +__u +-> +__sÿ5 + = +__¤c5 +; + +741 +__ex‹nsiÚ__ + +__u +-> +__sÿ6 + = +__¤c6 +; + +744 +__ex‹nsiÚ__ + +__u +-> +__sÿ7 + = +__¤c7 +; + +747 +__ex‹nsiÚ__ + +__u +-> +__sÿ8 + = +__¤c8 +; + +750 +__de¡ + + +__¤þ’ + - 1; + +751 + } +} + +759 #iâdeà +_HAVE_STRING_ARCH_¡ºýy + + +760 #ià +__GNUC_PREREQ + (3, 2) + +761 + #¡ºýy +( +de¡ +, +¤c +, +n +è + `__bužtš_¡ºýy + (de¡, src,‚) + + ) + +763 + #¡ºýy +( +de¡ +, +¤c +, +n +) \ + +764 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +¤c +è&& __bužtš_cÚ¡ªt_°( +n +) \ + +765 ? ( + `¡¾’ + ( +¤c +è+ 1 >ð(( +size_t +è( +n +)) \ + +766 ? (*è + `memýy + ( +de¡ +, +¤c +, +n +) \ + +767 : + `¡ºýy + ( +de¡ +, +¤c +, +n +)) \ + +768 : + `¡ºýy + ( +de¡ +, +¤c +, +n +))) + + ) + +774 #iâdeà +_HAVE_STRING_ARCH_¡ºÿt + + +775 #ifdeà +_USE_STRING_ARCH_¡rchr + + +776 + #¡ºÿt +( +de¡ +, +¤c +, +n +) \ + +777 ( + `__ex‹nsiÚ__ + ({ * +__de¡ + = ( +de¡ +); \ + +778 + `__bužtš_cÚ¡ªt_p + ( +¤c +è&& __bužtš_cÚ¡ªt_°( +n +) \ + +779 ? ( + `¡¾’ + ( +¤c +è< (( +size_t +è( +n +)) \ + +780 ? + `¡rÿt + ( +__de¡ +, +¤c +) \ + +781 : (*((*è + `__mempýy + ( + `¡rchr + ( +__de¡ +, '\0'), \ + +782 +¤c +, +n +)èð'\0', +__de¡ +)) \ + +783 : + `¡ºÿt + ( +de¡ +, +¤c +, +n +); })) + + ) + +784 #–ià +__GNUC_PREREQ + (3, 2) + +785 + #¡ºÿt +( +de¡ +, +¤c +, +n +è + `__bužtš_¡ºÿt + (de¡, src,‚) + + ) + +787 + #¡ºÿt +( +de¡ +, +¤c +, +n +) \ + +788 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +¤c +è&& __bužtš_cÚ¡ªt_°( +n +) \ + +789 ? ( + `¡¾’ + ( +¤c +è< (( +size_t +è( +n +)) \ + +790 ? + `¡rÿt + ( +de¡ +, +¤c +) \ + +791 : + `¡ºÿt + ( +de¡ +, +¤c +, +n +)) \ + +792 : + `¡ºÿt + ( +de¡ +, +¤c +, +n +))) + + ) + +798 #iâdeà +_HAVE_STRING_ARCH_¡rcmp + + +799 #ià +__GNUC_PREREQ + (3, 2) + +800 + #¡rcmp +( +s1 +, +s2 +) \ + +801 +__ex‹nsiÚ__ + \ + +802 ({ +size_t + +__s1_Ën +, +__s2_Ën +; \ + +803 ( + `__bužtš_cÚ¡ªt_p + ( +s1 +è&& __bužtš_cÚ¡ªt_°( +s2 +) \ + +804 && ( +__s1_Ën + = + `¡¾’ + ( +s1 +), +__s2_Ën + = sŒËÀ( +s2 +), \ + +805 (! + `__¡ršg2_1b±r_p + ( +s1 +è|| +__s1_Ën + >= 4) \ + +806 && (! + `__¡ršg2_1b±r_p + ( +s2 +è|| +__s2_Ën + >= 4)) \ + +807 ? + `__bužtš_¡rcmp + ( +s1 +, +s2 +) \ + +808 : ( + `__bužtš_cÚ¡ªt_p + ( +s1 +è&& + `__¡ršg2_1b±r_p + (s1) \ + +809 && ( +__s1_Ën + = + `¡¾’ + ( +s1 +), __s1_len < 4) \ + +810 ? ( + `__bužtš_cÚ¡ªt_p + ( +s2 +è&& + `__¡ršg2_1b±r_p + (s2) \ + +811 ? + `__bužtš_¡rcmp + ( +s1 +, +s2 +) \ + +812 : + `__¡rcmp_cg + ( +s1 +, +s2 +, +__s1_Ën +)) \ + +813 : ( + `__bužtš_cÚ¡ªt_p + ( +s2 +è&& + `__¡ršg2_1b±r_p + (s2) \ + +814 && ( +__s2_Ën + = + `¡¾’ + ( +s2 +), __s2_len < 4) \ + +815 ? ( + `__bužtš_cÚ¡ªt_p + ( +s1 +è&& + `__¡ršg2_1b±r_p + (s1) \ + +816 ? + `__bužtš_¡rcmp + ( +s1 +, +s2 +) \ + +817 : + `__¡rcmp_gc + ( +s1 +, +s2 +, +__s2_Ën +)) \ + +818 : + `__bužtš_¡rcmp + ( +s1 +, +s2 +)))); }) + + ) + +820 + #¡rcmp +( +s1 +, +s2 +) \ + +821 +__ex‹nsiÚ__ + \ + +822 ({ +size_t + +__s1_Ën +, +__s2_Ën +; \ + +823 ( + `__bužtš_cÚ¡ªt_p + ( +s1 +è&& __bužtš_cÚ¡ªt_°( +s2 +) \ + +824 && ( +__s1_Ën + = + `¡¾’ + ( +s1 +), +__s2_Ën + = sŒËÀ( +s2 +), \ + +825 (! + `__¡ršg2_1b±r_p + ( +s1 +è|| +__s1_Ën + >= 4) \ + +826 && (! + `__¡ršg2_1b±r_p + ( +s2 +è|| +__s2_Ën + >= 4)) \ + +827 ? + `memcmp + (( +__cÚ¡ + *è( +s1 +), (__cÚ¡ *è( +s2 +), \ + +828 ( +__s1_Ën + < +__s2_Ën + ? __s1_len : __s2_len) + 1) \ + +829 : ( + `__bužtš_cÚ¡ªt_p + ( +s1 +è&& + `__¡ršg2_1b±r_p + (s1) \ + +830 && ( +__s1_Ën + = + `¡¾’ + ( +s1 +), __s1_len < 4) \ + +831 ? ( + `__bužtš_cÚ¡ªt_p + ( +s2 +è&& + `__¡ršg2_1b±r_p + (s2) \ + +832 ? + `__¡rcmp_cc + ( +s1 +, +s2 +, +__s1_Ën +) \ + +833 : + `__¡rcmp_cg + ( +s1 +, +s2 +, +__s1_Ën +)) \ + +834 : ( + `__bužtš_cÚ¡ªt_p + ( +s2 +è&& + `__¡ršg2_1b±r_p + (s2) \ + +835 && ( +__s2_Ën + = + `¡¾’ + ( +s2 +), __s2_len < 4) \ + +836 ? ( + `__bužtš_cÚ¡ªt_p + ( +s1 +è&& + `__¡ršg2_1b±r_p + (s1) \ + +837 ? + `__¡rcmp_cc + ( +s1 +, +s2 +, +__s2_Ën +) \ + +838 : + `__¡rcmp_gc + ( +s1 +, +s2 +, +__s2_Ën +)) \ + +839 : + `¡rcmp + ( +s1 +, +s2 +)))); }) + + ) + +842 + #__¡rcmp_cc +( +s1 +, +s2 +, +l +) \ + +843 ( + `__ex‹nsiÚ__ + ({ +__»suÉ + = \ + +844 ((( +__cÚ¡ + *è(__cÚ¡ *è( +s1 +))[0] \ + +845 - (( +__cÚ¡ + *è(__cÚ¡ *)( +s2 +))[0]);\ + +846 ià( +l + > 0 && +__»suÉ + == 0) \ + +848 +__»suÉ + = ((( +__cÚ¡ + *) \ + +849 ( +__cÚ¡ + *è( +s1 +))[1] \ + +850 - (( +__cÚ¡ + *) \ + +851 ( +__cÚ¡ + *è( +s2 +))[1]); \ + +852 ià( +l + > 1 && +__»suÉ + == 0) \ + +854 +__»suÉ + = \ + +855 ((( +__cÚ¡ + *) \ + +856 ( +__cÚ¡ + *è( +s1 +))[2] \ + +857 - (( +__cÚ¡ + *) \ + +858 ( +__cÚ¡ + *è( +s2 +))[2]); \ + +859 ià( +l + > 2 && +__»suÉ + == 0) \ + +860 +__»suÉ + = \ + +861 ((( +__cÚ¡ + *) \ + +862 ( +__cÚ¡ + *è( +s1 +))[3] \ + +863 - (( +__cÚ¡ + *) \ + +864 ( +__cÚ¡ + *è( +s2 +))[3]); \ + +867 +__»suÉ +; })) + + ) + +869 + #__¡rcmp_cg +( +s1 +, +s2 +, +l1 +) \ + +870 ( + `__ex‹nsiÚ__ + ({ +__cÚ¡ + * +__s2 + = \ + +871 ( +__cÚ¡ + *è(__cÚ¡ *è( +s2 +); \ + +872 +__»suÉ + = \ + +873 ((( +__cÚ¡ + *è(__cÚ¡ *è( +s1 +))[0] \ + +874 - +__s2 +[0]); \ + +875 ià( +l1 + > 0 && +__»suÉ + == 0) \ + +877 +__»suÉ + = ((( +__cÚ¡ + *) \ + +878 ( +__cÚ¡ + *è( +s1 +))[1] - +__s2 +[1]); \ + +879 ià( +l1 + > 1 && +__»suÉ + == 0) \ + +881 +__»suÉ + = ((( +__cÚ¡ + *) \ + +882 ( +__cÚ¡ + *è( +s1 +))[2] - +__s2 +[2]);\ + +883 ià( +l1 + > 2 && +__»suÉ + == 0) \ + +884 +__»suÉ + = ((( +__cÚ¡ + *) \ + +885 ( +__cÚ¡ + *è( +s1 +))[3] \ + +886 - +__s2 +[3]); \ + +889 +__»suÉ +; })) + + ) + +891 + #__¡rcmp_gc +( +s1 +, +s2 +, +l2 +) \ + +892 ( + `__ex‹nsiÚ__ + ({ +__cÚ¡ + * +__s1 + = \ + +893 ( +__cÚ¡ + *è(__cÚ¡ *è( +s1 +); \ + +894 +__»suÉ + = \ + +895 +__s1 +[0] - (( +__cÚ¡ + *) \ + +896 ( +__cÚ¡ + *è( +s2 +))[0]; \ + +897 ià( +l2 + > 0 && +__»suÉ + == 0) \ + +899 +__»suÉ + = ( +__s1 +[1] \ + +900 - (( +__cÚ¡ + *) \ + +901 ( +__cÚ¡ + *è( +s2 +))[1]); \ + +902 ià( +l2 + > 1 && +__»suÉ + == 0) \ + +904 +__»suÉ + = \ + +905 ( +__s1 +[2] - (( +__cÚ¡ + *) \ + +906 ( +__cÚ¡ + *è( +s2 +))[2]); \ + +907 ià( +l2 + > 2 && +__»suÉ + == 0) \ + +908 +__»suÉ + = \ + +909 ( +__s1 +[3] \ + +910 - (( +__cÚ¡ + *) \ + +911 ( +__cÚ¡ + *è( +s2 +))[3]); \ + +914 +__»suÉ +; })) + + ) + +919 #iâdeà +_HAVE_STRING_ARCH_¡ºcmp + + +920 + #¡ºcmp +( +s1 +, +s2 +, +n +) \ + +921 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +n +) \ + +922 && (( + `__bužtš_cÚ¡ªt_p + ( +s1 +) \ + +923 && + `¡¾’ + ( +s1 +è< (( +size_t +è( +n +))) \ + +924 || ( + `__bužtš_cÚ¡ªt_p + ( +s2 +) \ + +925 && + `¡¾’ + ( +s2 +è< (( +size_t +è( +n +)))) \ + +926 ? + `¡rcmp + ( +s1 +, +s2 +è: + `¡ºcmp + (s1, s2, +n +))) + + ) + +932 #ià! +defšed + +_HAVE_STRING_ARCH_¡rc¥n + || defšed +_FORCE_INLINES + + +933 #iâdeà +_HAVE_STRING_ARCH_¡rc¥n + + +934 #ià +__GNUC_PREREQ + (3, 2) + +935 + #¡rc¥n +( +s +, +»jeù +) \ + +936 +__ex‹nsiÚ__ + \ + +937 ({ +__r0 +, +__r1 +, +__r2 +; \ + +938 ( + `__bužtš_cÚ¡ªt_p + ( +»jeù +è&& + `__¡ršg2_1b±r_p + (reject) \ + +939 ? (( + `__bužtš_cÚ¡ªt_p + ( +s +è&& + `__¡ršg2_1b±r_p + (s)) \ + +940 ? + `__bužtš_¡rc¥n + ( +s +, +»jeù +) \ + +941 : (( +__r0 + = (( +__cÚ¡ + *è( +»jeù +))[0], __r0 == '\0') \ + +942 ? + `¡¾’ + ( +s +) \ + +943 : (( +__r1 + = (( +__cÚ¡ + *è( +»jeù +))[1], __r1 == '\0') \ + +944 ? + `__¡rc¥n_c1 + ( +s +, +__r0 +) \ + +945 : (( +__r2 + = (( +__cÚ¡ + *è( +»jeù +))[2], __r2 == '\0') \ + +946 ? + `__¡rc¥n_c2 + ( +s +, +__r0 +, +__r1 +) \ + +947 : ((( +__cÚ¡ + *è( +»jeù +))[3] == '\0' \ + +948 ? + `__¡rc¥n_c3 + ( +s +, +__r0 +, +__r1 +, +__r2 +) \ + +949 : + `__bužtš_¡rc¥n + ( +s +, +»jeù +)))))) \ + +950 : + `__bužtš_¡rc¥n + ( +s +, +»jeù +)); }) + + ) + +952 + #¡rc¥n +( +s +, +»jeù +) \ + +953 +__ex‹nsiÚ__ + \ + +954 ({ +__r0 +, +__r1 +, +__r2 +; \ + +955 ( + `__bužtš_cÚ¡ªt_p + ( +»jeù +è&& + `__¡ršg2_1b±r_p + (reject) \ + +956 ? (( +__r0 + = (( +__cÚ¡ + *è( +»jeù +))[0], __r0 == '\0') \ + +957 ? + `¡¾’ + ( +s +) \ + +958 : (( +__r1 + = (( +__cÚ¡ + *è( +»jeù +))[1], __r1 == '\0') \ + +959 ? + `__¡rc¥n_c1 + ( +s +, +__r0 +) \ + +960 : (( +__r2 + = (( +__cÚ¡ + *è( +»jeù +))[2], __r2 == '\0') \ + +961 ? + `__¡rc¥n_c2 + ( +s +, +__r0 +, +__r1 +) \ + +962 : ((( +__cÚ¡ + *è( +»jeù +))[3] == '\0' \ + +963 ? + `__¡rc¥n_c3 + ( +s +, +__r0 +, +__r1 +, +__r2 +) \ + +964 : + `¡rc¥n + ( +s +, +»jeù +))))) \ + +965 : + `¡rc¥n + ( +s +, +»jeù +)); }) + + ) + +969 +__STRING_INLINE + +size_t + +__¡rc¥n_c1 + ( +__cÚ¡ + * +__s +, +__»jeù +); + +970 +__STRING_INLINE + +size_t + + +971 + $__¡rc¥n_c1 + ( +__cÚ¡ + * +__s +, +__»jeù +) + +973 +size_t + +__»suÉ + = 0; + +974 +__s +[ +__»suÉ +] !ð'\0' && __s[__»suÉ] !ð +__»jeù +) + +975 ++ +__»suÉ +; + +976 +__»suÉ +; + +977 + } +} + +979 +__STRING_INLINE + +size_t + +__¡rc¥n_c2 + ( +__cÚ¡ + * +__s +, +__»jeù1 +, + +980 +__»jeù2 +); + +981 +__STRING_INLINE + +size_t + + +982 + $__¡rc¥n_c2 + ( +__cÚ¡ + * +__s +, +__»jeù1 +, +__»jeù2 +) + +984 +size_t + +__»suÉ + = 0; + +985 +__s +[ +__»suÉ +] !ð'\0' && __s[__»suÉ] !ð +__»jeù1 + + +986 && +__s +[ +__»suÉ +] !ð +__»jeù2 +) + +987 ++ +__»suÉ +; + +988 +__»suÉ +; + +989 + } +} + +991 +__STRING_INLINE + +size_t + +__¡rc¥n_c3 + ( +__cÚ¡ + * +__s +, +__»jeù1 +, + +992 +__»jeù2 +, +__»jeù3 +); + +993 +__STRING_INLINE + +size_t + + +994 + $__¡rc¥n_c3 + ( +__cÚ¡ + * +__s +, +__»jeù1 +, +__»jeù2 +, + +995 +__»jeù3 +) + +997 +size_t + +__»suÉ + = 0; + +998 +__s +[ +__»suÉ +] !ð'\0' && __s[__»suÉ] !ð +__»jeù1 + + +999 && +__s +[ +__»suÉ +] !ð +__»jeù2 + && __s[__»suÉ] !ð +__»jeù3 +) + +1000 ++ +__»suÉ +; + +1001 +__»suÉ +; + +1002 + } +} + +1008 #ià! +defšed + +_HAVE_STRING_ARCH_¡r¥n + || defšed +_FORCE_INLINES + + +1009 #iâdeà +_HAVE_STRING_ARCH_¡r¥n + + +1010 #ià +__GNUC_PREREQ + (3, 2) + +1011 + #¡r¥n +( +s +, +acû± +) \ + +1012 +__ex‹nsiÚ__ + \ + +1013 ({ +__a0 +, +__a1 +, +__a2 +; \ + +1014 ( + `__bužtš_cÚ¡ªt_p + ( +acû± +è&& + `__¡ršg2_1b±r_p + (accept) \ + +1015 ? (( + `__bužtš_cÚ¡ªt_p + ( +s +è&& + `__¡ršg2_1b±r_p + (s)) \ + +1016 ? + `__bužtš_¡r¥n + ( +s +, +acû± +) \ + +1017 : (( +__a0 + = (( +__cÚ¡ + *è( +acû± +))[0], __a0 == '\0') \ + +1018 ? (( è( +s +), 0) \ + +1019 : (( +__a1 + = (( +__cÚ¡ + *è( +acû± +))[1], __a1 == '\0') \ + +1020 ? + `__¡r¥n_c1 + ( +s +, +__a0 +) \ + +1021 : (( +__a2 + = (( +__cÚ¡ + *è( +acû± +))[2], __a2 == '\0') \ + +1022 ? + `__¡r¥n_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1023 : ((( +__cÚ¡ + *è( +acû± +))[3] == '\0' \ + +1024 ? + `__¡r¥n_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1025 : + `__bužtš_¡r¥n + ( +s +, +acû± +)))))) \ + +1026 : + `__bužtš_¡r¥n + ( +s +, +acû± +)); }) + + ) + +1028 + #¡r¥n +( +s +, +acû± +) \ + +1029 +__ex‹nsiÚ__ + \ + +1030 ({ +__a0 +, +__a1 +, +__a2 +; \ + +1031 ( + `__bužtš_cÚ¡ªt_p + ( +acû± +è&& + `__¡ršg2_1b±r_p + (accept) \ + +1032 ? (( +__a0 + = (( +__cÚ¡ + *è( +acû± +))[0], __a0 == '\0') \ + +1033 ? (( è( +s +), 0) \ + +1034 : (( +__a1 + = (( +__cÚ¡ + *è( +acû± +))[1], __a1 == '\0') \ + +1035 ? + `__¡r¥n_c1 + ( +s +, +__a0 +) \ + +1036 : (( +__a2 + = (( +__cÚ¡ + *è( +acû± +))[2], __a2 == '\0') \ + +1037 ? + `__¡r¥n_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1038 : ((( +__cÚ¡ + *è( +acû± +))[3] == '\0' \ + +1039 ? + `__¡r¥n_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1040 : + `¡r¥n + ( +s +, +acû± +))))) \ + +1041 : + `¡r¥n + ( +s +, +acû± +)); }) + + ) + +1045 +__STRING_INLINE + +size_t + +__¡r¥n_c1 + ( +__cÚ¡ + * +__s +, +__acû± +); + +1046 +__STRING_INLINE + +size_t + + +1047 + $__¡r¥n_c1 + ( +__cÚ¡ + * +__s +, +__acû± +) + +1049 +size_t + +__»suÉ + = 0; + +1051 +__s +[ +__»suÉ +] =ð +__acû± +) + +1052 ++ +__»suÉ +; + +1053 +__»suÉ +; + +1054 + } +} + +1056 +__STRING_INLINE + +size_t + +__¡r¥n_c2 + ( +__cÚ¡ + * +__s +, +__acû±1 +, + +1057 +__acû±2 +); + +1058 +__STRING_INLINE + +size_t + + +1059 + $__¡r¥n_c2 + ( +__cÚ¡ + * +__s +, +__acû±1 +, +__acû±2 +) + +1061 +size_t + +__»suÉ + = 0; + +1063 +__s +[ +__»suÉ +] =ð +__acû±1 + || __s[__»suÉ] =ð +__acû±2 +) + +1064 ++ +__»suÉ +; + +1065 +__»suÉ +; + +1066 + } +} + +1068 +__STRING_INLINE + +size_t + +__¡r¥n_c3 + ( +__cÚ¡ + * +__s +, +__acû±1 +, + +1069 +__acû±2 +, +__acû±3 +); + +1070 +__STRING_INLINE + +size_t + + +1071 + $__¡r¥n_c3 + ( +__cÚ¡ + * +__s +, +__acû±1 +, +__acû±2 +, +__acû±3 +) + +1073 +size_t + +__»suÉ + = 0; + +1075 +__s +[ +__»suÉ +] =ð +__acû±1 + || __s[__»suÉ] =ð +__acû±2 + + +1076 || +__s +[ +__»suÉ +] =ð +__acû±3 +) + +1077 ++ +__»suÉ +; + +1078 +__»suÉ +; + +1079 + } +} + +1084 #ià! +defšed + +_HAVE_STRING_ARCH_¡½brk + || defšed +_FORCE_INLINES + + +1085 #iâdeà +_HAVE_STRING_ARCH_¡½brk + + +1086 #ià +__GNUC_PREREQ + (3, 2) + +1087 + #¡½brk +( +s +, +acû± +) \ + +1088 +__ex‹nsiÚ__ + \ + +1089 ({ +__a0 +, +__a1 +, +__a2 +; \ + +1090 ( + `__bužtš_cÚ¡ªt_p + ( +acû± +è&& + `__¡ršg2_1b±r_p + (accept) \ + +1091 ? (( + `__bužtš_cÚ¡ªt_p + ( +s +è&& + `__¡ršg2_1b±r_p + (s)) \ + +1092 ? + `__bužtš_¡½brk + ( +s +, +acû± +) \ + +1093 : (( +__a0 + = (( +__cÚ¡ + *è( +acû± +))[0], __a0 == '\0') \ + +1094 ? (( è( +s +), (*è +NULL +) \ + +1095 : (( +__a1 + = (( +__cÚ¡ + *è( +acû± +))[1], __a1 == '\0') \ + +1096 ? + `__bužtš_¡rchr + ( +s +, +__a0 +) \ + +1097 : (( +__a2 + = (( +__cÚ¡ + *è( +acû± +))[2], __a2 == '\0') \ + +1098 ? + `__¡½brk_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1099 : ((( +__cÚ¡ + *è( +acû± +))[3] == '\0' \ + +1100 ? + `__¡½brk_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1101 : + `__bužtš_¡½brk + ( +s +, +acû± +)))))) \ + +1102 : + `__bužtš_¡½brk + ( +s +, +acû± +)); }) + + ) + +1104 + #¡½brk +( +s +, +acû± +) \ + +1105 +__ex‹nsiÚ__ + \ + +1106 ({ +__a0 +, +__a1 +, +__a2 +; \ + +1107 ( + `__bužtš_cÚ¡ªt_p + ( +acû± +è&& + `__¡ršg2_1b±r_p + (accept) \ + +1108 ? (( +__a0 + = (( +__cÚ¡ + *è( +acû± +))[0], __a0 == '\0') \ + +1109 ? (( è( +s +), (*è +NULL +) \ + +1110 : (( +__a1 + = (( +__cÚ¡ + *è( +acû± +))[1], __a1 == '\0') \ + +1111 ? + `¡rchr + ( +s +, +__a0 +) \ + +1112 : (( +__a2 + = (( +__cÚ¡ + *è( +acû± +))[2], __a2 == '\0') \ + +1113 ? + `__¡½brk_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1114 : ((( +__cÚ¡ + *è( +acû± +))[3] == '\0' \ + +1115 ? + `__¡½brk_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1116 : + `¡½brk + ( +s +, +acû± +))))) \ + +1117 : + `¡½brk + ( +s +, +acû± +)); }) + + ) + +1121 +__STRING_INLINE + * +__¡½brk_c2 + ( +__cÚ¡ + * +__s +, +__acû±1 +, + +1122 +__acû±2 +); + +1123 +__STRING_INLINE + * + +1124 + $__¡½brk_c2 + ( +__cÚ¡ + * +__s +, +__acû±1 +, +__acû±2 +) + +1127 * +__s + !ð'\0' && *__ !ð +__acû±1 + && *__ !ð +__acû±2 +) + +1128 ++ +__s +; + +1129 * +__s + =ð'\0' ? +NULL + : (*è( +size_t +) __s; + +1130 + } +} + +1132 +__STRING_INLINE + * +__¡½brk_c3 + ( +__cÚ¡ + * +__s +, +__acû±1 +, + +1133 +__acû±2 +, +__acû±3 +); + +1134 +__STRING_INLINE + * + +1135 + $__¡½brk_c3 + ( +__cÚ¡ + * +__s +, +__acû±1 +, +__acû±2 +, + +1136 +__acû±3 +) + +1139 * +__s + !ð'\0' && *__ !ð +__acû±1 + && *__ !ð +__acû±2 + + +1140 && * +__s + !ð +__acû±3 +) + +1141 ++ +__s +; + +1142 * +__s + =ð'\0' ? +NULL + : (*è( +size_t +) __s; + +1143 + } +} + +1149 #ià! +defšed + +_HAVE_STRING_ARCH_¡r¡r + && ! +__GNUC_PREREQ + (2, 97) + +1150 + #¡r¡r +( +hay¡ack +, +ÃedË +) \ + +1151 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +ÃedË +è&& + `__¡ršg2_1b±r_p + (needle) \ + +1152 ? ((( +__cÚ¡ + *è( +ÃedË +))[0] == '\0' \ + +1153 ? (*è( +size_t +è( +hay¡ack +) \ + +1154 : ((( +__cÚ¡ + *è( +ÃedË +))[1] == '\0' \ + +1155 ? + `¡rchr + ( +hay¡ack +, \ + +1156 (( +__cÚ¡ + *è( +ÃedË +))[0]) \ + +1157 : + `¡r¡r + ( +hay¡ack +, +ÃedË +))) \ + +1158 : + `¡r¡r + ( +hay¡ack +, +ÃedË +))) + + ) + +1162 #ià! +defšed + +_HAVE_STRING_ARCH_¡¹ok_r + || defšed +_FORCE_INLINES + + +1163 #iâdeà +_HAVE_STRING_ARCH_¡¹ok_r + + +1164 + #__¡¹ok_r +( +s +, +£p +, +Ãx +) \ + +1165 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +£p +è&& + `__¡ršg2_1b±r_p + (sep) \ + +1166 && (( +__cÚ¡ + *è( +£p +))[0] != '\0' \ + +1167 && (( +__cÚ¡ + *è( +£p +))[1] == '\0' \ + +1168 ? + `__¡¹ok_r_1c + ( +s +, (( +__cÚ¡ + *è( +£p +))[0], +Ãx +) \ + +1169 : + `__¡¹ok_r + ( +s +, +£p +, +Ãx +))) + + ) + +1172 +__STRING_INLINE + * +__¡¹ok_r_1c + (* +__s +, +__£p +, ** +__Ãx +); + +1173 +__STRING_INLINE + * + +1174 + $__¡¹ok_r_1c + (* +__s +, +__£p +, ** +__Ãx +) + +1176 * +__»suÉ +; + +1177 ià( +__s + =ð +NULL +) + +1178 +__s + = * +__Ãx +; + +1179 * +__s + =ð +__£p +) + +1180 ++ +__s +; + +1181 +__»suÉ + = +NULL +; + +1182 ià(* +__s + != '\0') + +1184 +__»suÉ + = +__s +++; + +1185 * +__s + != '\0') + +1186 ià(* +__s +++ =ð +__£p +) + +1188 +__s +[-1] = '\0'; + +1192 * +__Ãx + = +__s +; + +1193 +__»suÉ +; + +1194 + } +} + +1195 #ià +defšed + +__USE_POSIX + || defšed +__USE_MISC + + +1196 + #¡¹ok_r +( +s +, +£p +, +Ãx +è + `__¡¹ok_r + (s, s•,‚ex) + + ) + +1201 #ià! +defšed + +_HAVE_STRING_ARCH_¡r£p + || defšed +_FORCE_INLINES + + +1202 #iâdeà +_HAVE_STRING_ARCH_¡r£p + + +1204
* +__¡r£p_g + (** +__¡ršgp +, +__cÚ¡ + * +__d–im +); + +1205 + #__¡r£p +( +s +, +»jeù +) \ + +1206 +__ex‹nsiÚ__ + \ + +1207 ({ +__r0 +, +__r1 +, +__r2 +; \ + +1208 ( + `__bužtš_cÚ¡ªt_p + ( +»jeù +è&& + `__¡ršg2_1b±r_p + (reject) \ + +1209 && ( +__r0 + = (( +__cÚ¡ + *è( +»jeù +))[0], \ + +1210 (( +__cÚ¡ + *è( +»jeù +))[0] != '\0') \ + +1211 ? (( +__r1 + = (( +__cÚ¡ + *è( +»jeù +))[1], \ + +1212 (( +__cÚ¡ + *è( +»jeù +))[1] == '\0') \ + +1213 ? + `__¡r£p_1c + ( +s +, +__r0 +) \ + +1214 : (( +__r2 + = (( +__cÚ¡ + *è( +»jeù +))[2], __r2 == '\0') \ + +1215 ? + `__¡r£p_2c + ( +s +, +__r0 +, +__r1 +) \ + +1216 : ((( +__cÚ¡ + *è( +»jeù +))[3] == '\0' \ + +1217 ? + `__¡r£p_3c + ( +s +, +__r0 +, +__r1 +, +__r2 +) \ + +1218 : + `__¡r£p_g + ( +s +, +»jeù +)))) \ + +1219 : + `__¡r£p_g + ( +s +, +»jeù +)); }) + + ) + +1222 +__STRING_INLINE + * +__¡r£p_1c + (** +__s +, +__»jeù +); + +1223 +__STRING_INLINE + * + +1224 + $__¡r£p_1c + (** +__s +, +__»jeù +) + +1226 * +__»tv® + = * +__s +; + +1227 ià( +__»tv® + !ð +NULL + && (* +__s + = + `¡rchr + (__»tv®, +__»jeù +)) != NULL) + +1228 *(* +__s +)++ = '\0'; + +1229 +__»tv® +; + +1230 + } +} + +1232 +__STRING_INLINE + * +__¡r£p_2c + (** +__s +, +__»jeù1 +, +__»jeù2 +); + +1233 +__STRING_INLINE + * + +1234 + $__¡r£p_2c + (** +__s +, +__»jeù1 +, +__»jeù2 +) + +1236 * +__»tv® + = * +__s +; + +1237 ià( +__»tv® + !ð +NULL +) + +1239 * +__ý + = +__»tv® +; + +1242 ià(* +__ý + == '\0') + +1244 +__ý + = +NULL +; + +1247 ià(* +__ý + =ð +__»jeù1 + || *__ý =ð +__»jeù2 +) + +1249 * +__ý +++ = '\0'; + +1252 ++ +__ý +; + +1254 * +__s + = +__ý +; + +1256 +__»tv® +; + +1257 + } +} + +1259 +__STRING_INLINE + * +__¡r£p_3c + (** +__s +, +__»jeù1 +, +__»jeù2 +, + +1260 +__»jeù3 +); + +1261 +__STRING_INLINE + * + +1262 + $__¡r£p_3c + (** +__s +, +__»jeù1 +, +__»jeù2 +, +__»jeù3 +) + +1264 * +__»tv® + = * +__s +; + +1265 ià( +__»tv® + !ð +NULL +) + +1267 * +__ý + = +__»tv® +; + +1270 ià(* +__ý + == '\0') + +1272 +__ý + = +NULL +; + +1275 ià(* +__ý + =ð +__»jeù1 + || *__ý =ð +__»jeù2 + || *__ý =ð +__»jeù3 +) + +1277 * +__ý +++ = '\0'; + +1280 ++ +__ý +; + +1282 * +__s + = +__ý +; + +1284 +__»tv® +; + +1285 + } +} + +1286 #ifdeà +__USE_BSD + + +1287 + #¡r£p +( +s +, +»jeù +è + `__¡r£p + (s,„ejeù) + + ) + +1294 #ifdeà +__USE_MISC + + +1296 #ià! +defšed + +_HAVE_STRING_ARCH_¡rdup + || !defšed +_HAVE_STRING_ARCH_¡ºdup + + +1297 + #__Ãed_m®loc_ªd_ÿÎoc + + + ) + +1298 + ~<¡dlib.h +> + +1301 #iâdeà +_HAVE_STRING_ARCH_¡rdup + + +1303
* + $__¡rdup + ( +__cÚ¡ + * +__¡ršg +è +__THROW + +__©Œibu‹_m®loc__ +; + +1304 + #__¡rdup +( +s +) \ + +1305 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +s +è&& + `__¡ršg2_1b±r_p + (s) \ + +1306 ? ((( +__cÚ¡ + *è( +s +))[0] == '\0' \ + +1307 ? (*è + `ÿÎoc + (( +size_t +) 1, (size_t) 1) \ + +1308 : ({ +size_t + +__Ën + = + `¡¾’ + ( +s +) + 1; \ + +1309 * +__»tv® + = (*è + `m®loc + ( +__Ën +); \ + +1310 ià( +__»tv® + !ð +NULL +) \ + +1311 +__»tv® + = (*è + `memýy + (__»tv®, +s +, +__Ën +); \ + +1312 +__»tv® +; + } +})) \ + +1313 : + `__¡rdup + ( +s +))) + + ) + +1315 #ià +defšed + +__USE_SVID + || defšed +__USE_BSD + || defšed +__USE_XOPEN_EXTENDED + + +1316 + #¡rdup +( +s +è + `__¡rdup + (s) + + ) + +1320 #iâdeà +_HAVE_STRING_ARCH_¡ºdup + + +1322
* + $__¡ºdup + ( +__cÚ¡ + * +__¡ršg +, +size_t + +__n +) + +1323 +__THROW + +__©Œibu‹_m®loc__ +; + +1324 + #__¡ºdup +( +s +, +n +) \ + +1325 ( + `__ex‹nsiÚ__ + ( + `__bužtš_cÚ¡ªt_p + ( +s +è&& + `__¡ršg2_1b±r_p + (s) \ + +1326 ? ((( +__cÚ¡ + *è( +s +))[0] == '\0' \ + +1327 ? (*è + `ÿÎoc + (( +size_t +) 1, (size_t) 1) \ + +1328 : ({ +size_t + +__Ën + = + `¡¾’ + ( +s +) + 1; \ + +1329 +size_t + +__n + = ( +n +); \ + +1330 * +__»tv® +; \ + +1331 ià( +__n + < +__Ën +) \ + +1332 +__Ën + = +__n + + 1; \ + +1333 +__»tv® + = (*è + `m®loc + ( +__Ën +); \ + +1334 ià( +__»tv® + !ð +NULL +) \ + +1336 +__»tv® +[ +__Ën + - 1] = '\0'; \ + +1337 +__»tv® + = (*è + `memýy + (__»tv®, +s +, \ + +1338 +__Ën + - 1); \ + +1340 +__»tv® +; + } +})) \ + +1341 : + `__¡ºdup + ( +s +, +n +))) + + ) + +1343 #ifdeà +__USE_GNU + + +1344 + #¡ºdup +( +s +, +n +è + `__¡ºdup + (s,‚) + + ) + +1350 #iâdeà +_FORCE_INLINES + + +1351 #undeà +__STRING_INLINE + + + @/usr/include/bits/string3.h + +19 #iâdeà +_STRING_H + + +23 +__w¬ndeþ + ( +__w¬n_mem£t_z”o_Ën +, + +26 #iâdeà +__ýlu¥lus + + +30 #undeà +memýy + + +31 #undeà +memmove + + +32 #undeà +mem£t + + +33 #undeà +¡rÿt + + +34 #undeà +¡rýy + + +35 #undeà +¡ºÿt + + +36 #undeà +¡ºýy + + +37 #ifdeà +__USE_GNU + + +38 #undeà +mempýy + + +39 #undeà +¡pýy + + +41 #ifdeà +__USE_BSD + + +42 #undeà +bcÝy + + +43 #undeà +bz”o + + +48 +__ex‹º_®ways_šlše + * + +49 +__NTH + ( + $memýy + ( * +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +, + +50 +size_t + +__Ën +)) + +52 + `__bužtš___memýy_chk + ( +__de¡ +, +__¤c +, +__Ën +, + `__bos0 + (__dest)); + +53 + } +} + +55 +__ex‹º_®ways_šlše + * + +56 +__NTH + ( + $memmove + ( * +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +, + +57 +size_t + +__Ën +)) + +59 + `__bužtš___memmove_chk + ( +__de¡ +, +__¤c +, +__Ën +, + `__bos0 + (__dest)); + +60 + } +} + +62 #ifdeà +__USE_GNU + + +63 +__ex‹º_®ways_šlše + * + +64 +__NTH + ( + $mempýy + ( * +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +, + +65 +size_t + +__Ën +)) + +67 + `__bužtš___mempýy_chk + ( +__de¡ +, +__¤c +, +__Ën +, + `__bos0 + (__dest)); + +68 + } +} + +77 +__ex‹º_®ways_šlše + * + +78 +__NTH + ( + $mem£t + ( * +__de¡ +, +__ch +, +size_t + +__Ën +)) + +80 ià( + `__bužtš_cÚ¡ªt_p + ( +__Ën +) && __len == 0 + +81 && (! + `__bužtš_cÚ¡ªt_p + ( +__ch +) || __ch != 0)) + +83 + `__w¬n_mem£t_z”o_Ën + (); + +84 +__de¡ +; + +86 + `__bužtš___mem£t_chk + ( +__de¡ +, +__ch +, +__Ën +, + `__bos0 + (__dest)); + +87 + } +} + +89 #ifdeà +__USE_BSD + + +90 +__ex‹º_®ways_šlše + + +91 +__NTH + ( + $bcÝy + ( +__cÚ¡ + * +__»¡riù + +__¤c +, *__»¡riù +__de¡ +, + +92 +size_t + +__Ën +)) + +94 ( è + `__bužtš___memmove_chk + ( +__de¡ +, +__¤c +, +__Ën +, + `__bos0 + (__dest)); + +95 + } +} + +97 +__ex‹º_®ways_šlše + + +98 +__NTH + ( + $bz”o + ( * +__de¡ +, +size_t + +__Ën +)) + +100 ( è + `__bužtš___mem£t_chk + ( +__de¡ +, '\0', +__Ën +, + `__bos0 + (__dest)); + +101 + } +} + +104 +__ex‹º_®ways_šlše + * + +105 +__NTH + ( + $¡rýy + (* +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +)) + +107 + `__bužtš___¡rýy_chk + ( +__de¡ +, +__¤c +, + `__bos + (__dest)); + +108 + } +} + +110 #ifdeà +__USE_GNU + + +111 +__ex‹º_®ways_šlše + * + +112 +__NTH + ( + $¡pýy + (* +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +)) + +114 + `__bužtš___¡pýy_chk + ( +__de¡ +, +__¤c +, + `__bos + (__dest)); + +115 + } +} + +119 +__ex‹º_®ways_šlše + * + +120 +__NTH + ( + $¡ºýy + (* +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +, + +121 +size_t + +__Ën +)) + +123 + `__bužtš___¡ºýy_chk + ( +__de¡ +, +__¤c +, +__Ën +, + `__bos + (__dest)); + +124 + } +} + +127
* + $__¡²ýy_chk + (* +__de¡ +, +__cÚ¡ + * +__¤c +, +size_t + +__n +, + +128 +size_t + +__de¡Ën +è +__THROW +; + +129
* + `__REDIRECT_NTH + ( +__¡²ýy_®Ÿs +, (* +__de¡ +, + +130 +__cÚ¡ + * +__¤c +, + +131 +size_t + +__n +), +¡²ýy +); + +133 +__ex‹º_®ways_šlše + * + +134 + `__NTH + ( + $¡²ýy + (* +__de¡ +, +__cÚ¡ + * +__¤c +, +size_t + +__n +)) + +136 ià( + `__bos + ( +__de¡ +è!ð( +size_t +) -1 + +137 && (! + `__bužtš_cÚ¡ªt_p + ( +__n +è|| __À<ð + `__bos + ( +__de¡ +))) + +138 + `__¡²ýy_chk + ( +__de¡ +, +__¤c +, +__n +, + `__bos + (__dest)); + +139 + `__¡²ýy_®Ÿs + ( +__de¡ +, +__¤c +, +__n +); + +140 + } +} + +143 +__ex‹º_®ways_šlše + * + +144 +__NTH + ( + $¡rÿt + (* +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +)) + +146 + `__bužtš___¡rÿt_chk + ( +__de¡ +, +__¤c +, + `__bos + (__dest)); + +147 + } +} + +150 +__ex‹º_®ways_šlše + * + +151 +__NTH + ( + $¡ºÿt + (* +__»¡riù + +__de¡ +, +__cÚ¡ + *__»¡riù +__¤c +, + +152 +size_t + +__Ën +)) + +154 + `__bužtš___¡ºÿt_chk + ( +__de¡ +, +__¤c +, +__Ën +, + `__bos + (__dest)); + +155 + } +} + + @/usr/include/bits/sys_errlist.h + +20 #iâdeà +_STDIO_H + + +26 #ifdeà +__USE_BSD + + +27
+sys_ü +; + +28
+__cÚ¡ + *__cÚ¡ +sys_”¾i¡ +[]; + +30 #ifdeà +__USE_GNU + + +31
+_sys_ü +; + +32
+__cÚ¡ + *__cÚ¡ +_sys_”¾i¡ +[]; + + @/usr/include/bits/types.h + +24 #iâdef +_BITS_TYPES_H + + +25 + #_BITS_TYPES_H + 1 + + ) + +27 + ~<ã©u»s.h +> + +28 + ~<b™s/wÜdsize.h +> + +31 + t__u_ch¬ +; + +32 + t__u_shÜt +; + +33 + t__u_št +; + +34 + t__u_lÚg +; + +37 sigÃd + t__št8_t +; + +38 + t__ušt8_t +; + +39 sigÃd + t__št16_t +; + +40 + t__ušt16_t +; + +41 sigÃd + t__št32_t +; + +42 + t__ušt32_t +; + +43 #ià +__WORDSIZE + == 64 + +44 sigÃd + t__št64_t +; + +45 + t__ušt64_t +; + +46 #–ià +defšed + +__GLIBC_HAVE_LONG_LONG + + +47 +__ex‹nsiÚ__ + sigÃd + t__št64_t +; + +48 +__ex‹nsiÚ__ + + t__ušt64_t +; + +52 #ià +__WORDSIZE + == 64 + +53 + t__quad_t +; + +54 + t__u_quad_t +; + +55 #–ià +defšed + +__GLIBC_HAVE_LONG_LONG + + +56 +__ex‹nsiÚ__ + + t__quad_t +; + +57 +__ex‹nsiÚ__ + + t__u_quad_t +; + +61 + m__v® +[2]; + +62 } + t__quad_t +; + +65 +__u_lÚg + + m__v® +[2]; + +66 } + t__u_quad_t +; + +99 + #__S16_TYPE + + + ) + +100 + #__U16_TYPE + + + ) + +101 + #__S32_TYPE + + + ) + +102 + #__U32_TYPE + + + ) + +103 + #__SLONGWORD_TYPE + + + ) + +104 + #__ULONGWORD_TYPE + + + ) + +105 #ià +__WORDSIZE + == 32 + +106 + #__SQUAD_TYPE + +__quad_t + + + ) + +107 + #__UQUAD_TYPE + +__u_quad_t + + + ) + +108 + #__SWORD_TYPE + + + ) + +109 + #__UWORD_TYPE + + + ) + +110 + #__SLONG32_TYPE + + + ) + +111 + #__ULONG32_TYPE + + + ) + +112 + #__S64_TYPE + +__quad_t + + + ) + +113 + #__U64_TYPE + +__u_quad_t + + + ) + +116 + #__STD_TYPE + +__ex‹nsiÚ__ + + + ) + +117 #–ià +__WORDSIZE + == 64 + +118 + t__SQUAD_TYPE + + + ) + +119 + t__UQUAD_TYPE + + + ) + +120 + t__SWORD_TYPE + + + ) + +121 + t__UWORD_TYPE + + + ) + +122 + t__SLONG32_TYPE + + + ) + +123 + t__ULONG32_TYPE + + + ) + +124 + t__S64_TYPE + + + ) + +125 + t__U64_TYPE + + + ) + +127 + t__STD_TYPE + + + ) + +131 + ~<b™s/ty³sizes.h +> + +134 +__STD_TYPE + + t__DEV_T_TYPE + + t__dev_t +; + +135 +__STD_TYPE + +__UID_T_TYPE + + g__uid_t +; + +136 +__STD_TYPE + +__GID_T_TYPE + + g__gid_t +; + +137 +__STD_TYPE + +__INO_T_TYPE + + g__šo_t +; + +138 +__STD_TYPE + +__INO64_T_TYPE + + g__šo64_t +; + +139 +__STD_TYPE + +__MODE_T_TYPE + + g__mode_t +; + +140 +__STD_TYPE + +__NLINK_T_TYPE + + g__Æšk_t +; + +141 +__STD_TYPE + +__OFF_T_TYPE + + g__off_t +; + +142 +__STD_TYPE + +__OFF64_T_TYPE + + g__off64_t +; + +143 +__STD_TYPE + +__PID_T_TYPE + + g__pid_t +; + +144 +__STD_TYPE + +__FSID_T_TYPE + + g__fsid_t +; + +145 +__STD_TYPE + +__CLOCK_T_TYPE + + g__þock_t +; + +146 +__STD_TYPE + +__RLIM_T_TYPE + + g__¾im_t +; + +147 +__STD_TYPE + +__RLIM64_T_TYPE + + g__¾im64_t +; + +148 +__STD_TYPE + +__ID_T_TYPE + + g__id_t +; + +149 +__STD_TYPE + +__TIME_T_TYPE + + g__time_t +; + +150 +__STD_TYPE + +__USECONDS_T_TYPE + + g__u£cÚds_t +; + +151 +__STD_TYPE + +__SUSECONDS_T_TYPE + + g__su£cÚds_t +; + +153 +__STD_TYPE + +__DADDR_T_TYPE + + g__daddr_t +; + +154 +__STD_TYPE + +__SWBLK_T_TYPE + + g__swblk_t +; + +155 +__STD_TYPE + +__KEY_T_TYPE + + g__key_t +; + +158 +__STD_TYPE + +__CLOCKID_T_TYPE + + g__þockid_t +; + +161 +__STD_TYPE + +__TIMER_T_TYPE + + g__tim”_t +; + +164 +__STD_TYPE + +__BLKSIZE_T_TYPE + + g__blksize_t +; + +169 +__STD_TYPE + +__BLKCNT_T_TYPE + + g__blkút_t +; + +170 +__STD_TYPE + +__BLKCNT64_T_TYPE + + g__blkút64_t +; + +173 +__STD_TYPE + +__FSBLKCNT_T_TYPE + + g__fsblkút_t +; + +174 +__STD_TYPE + +__FSBLKCNT64_T_TYPE + + g__fsblkút64_t +; + +177 +__STD_TYPE + +__FSFILCNT_T_TYPE + + g__fsfžút_t +; + +178 +__STD_TYPE + +__FSFILCNT64_T_TYPE + + g__fsfžút64_t +; + +180 +__STD_TYPE + +__SSIZE_T_TYPE + + g__ssize_t +; + +184 +__off64_t + + t__loff_t +; + +185 +__quad_t + * + t__qaddr_t +; + +186 * + t__ÿddr_t +; + +189 +__STD_TYPE + +__SWORD_TYPE + + g__šŒ_t +; + +192 +__STD_TYPE + +__U32_TYPE + + g__sockËn_t +; + +195 #undeà +__STD_TYPE + + + @/usr/include/features.h + +19 #iâdef +_FEATURES_H + + +20 + #_FEATURES_H + 1 + + ) + +95 #undeà +__USE_ISOC99 + + +96 #undeà +__USE_ISOC95 + + +97 #undeà +__USE_POSIX + + +98 #undeà +__USE_POSIX2 + + +99 #undeà +__USE_POSIX199309 + + +100 #undeà +__USE_POSIX199506 + + +101 #undeà +__USE_XOPEN + + +102 #undeà +__USE_XOPEN_EXTENDED + + +103 #undeà +__USE_UNIX98 + + +104 #undeà +__USE_XOPEN2K + + +105 #undeà +__USE_XOPEN2K8 + + +106 #undeà +__USE_LARGEFILE + + +107 #undeà +__USE_LARGEFILE64 + + +108 #undeà +__USE_FILE_OFFSET64 + + +109 #undeà +__USE_BSD + + +110 #undeà +__USE_SVID + + +111 #undeà +__USE_MISC + + +112 #undeà +__USE_ATFILE + + +113 #undeà +__USE_GNU + + +114 #undeà +__USE_REENTRANT + + +115 #undeà +__USE_FORTIFY_LEVEL + + +116 #undeà +__FAVOR_BSD + + +117 #undeà +__KERNEL_STRICT_NAMES + + +121 #iâdeà +_LOOSE_KERNEL_NAMES + + +122 + #__KERNEL_STRICT_NAMES + + + ) + +126 + #__USE_ANSI + 1 + + ) + +135 #ià +defšed + +__GNUC__ + && defšed +__GNUC_MINOR__ + + +136 + #__GNUC_PREREQ +( +maj +, +mš +) \ + +137 (( +__GNUC__ + << 16è+ +__GNUC_MINOR__ + >ð(( +maj +è<< 16è+ ( +mš +)) + + ) + +139 + #__GNUC_PREREQ +( +maj +, +mš +è0 + + ) + +144 #ià +defšed + +_BSD_SOURCE + && \ + +145 !( +defšed + + g_POSIX_SOURCE + || defšed + g_POSIX_C_SOURCE + || \ + +146 +defšed + + g_XOPEN_SOURCE + || defšed + g_XOPEN_SOURCE_EXTENDED + || \ + +147 +defšed + + g_GNU_SOURCE + || defšed + g_SVID_SOURCE +) + +148 + #__FAVOR_BSD + 1 + + ) + +152 #ifdeà +_GNU_SOURCE + + +153 #undeà +_ISOC99_SOURCE + + +154 + #_ISOC99_SOURCE + 1 + + ) + +155 #undeà +_POSIX_SOURCE + + +156 + #_POSIX_SOURCE + 1 + + ) + +157 #undeà +_POSIX_C_SOURCE + + +158 + #_POSIX_C_SOURCE + 200809L + + ) + +159 #undeà +_XOPEN_SOURCE + + +160 + #_XOPEN_SOURCE + 700 + + ) + +161 #undeà +_XOPEN_SOURCE_EXTENDED + + +162 + #_XOPEN_SOURCE_EXTENDED + 1 + + ) + +163 #undeà +_LARGEFILE64_SOURCE + + +164 + #_LARGEFILE64_SOURCE + 1 + + ) + +165 #undeà +_BSD_SOURCE + + +166 + #_BSD_SOURCE + 1 + + ) + +167 #undeà +_SVID_SOURCE + + +168 + #_SVID_SOURCE + 1 + + ) + +169 #undeà +_ATFILE_SOURCE + + +170 + #_ATFILE_SOURCE + 1 + + ) + +175 #ià(! +defšed + +__STRICT_ANSI__ + && !defšed +_ISOC99_SOURCE + && \ + +176 ! +defšed + + g_POSIX_SOURCE + && !defšed + g_POSIX_C_SOURCE + && \ + +177 ! +defšed + + g_XOPEN_SOURCE + && !defšed + g_XOPEN_SOURCE_EXTENDED + && \ + +178 ! +defšed + + g_BSD_SOURCE + && !defšed + g_SVID_SOURCE +) + +179 + #_BSD_SOURCE + 1 + + ) + +180 + #_SVID_SOURCE + 1 + + ) + +187 #ià( +defšed + +_ISOC99_SOURCE + || defšed +_ISOC9X_SOURCE + \ + +188 || ( +defšed + + g__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L)) + +189 + #__USE_ISOC99 + 1 + + ) + +193 #ià( +defšed + +_ISOC99_SOURCE + || defšed +_ISOC9X_SOURCE + \ + +194 || ( +defšed + +__STDC_VERSION__ + && __STDC_VERSION__ >= 199409L)) + +195 + #__USE_ISOC95 + 1 + + ) + +200 #ià((! +defšed + +__STRICT_ANSI__ + || ( +_XOPEN_SOURCE + - 0) >= 500) && \ + +201 ! +defšed + +_POSIX_SOURCE + && !defšed +_POSIX_C_SOURCE +) + +202 + #_POSIX_SOURCE + 1 + + ) + +203 #ià +defšed + +_XOPEN_SOURCE + && (_XOPEN_SOURCE - 0) < 500 + +204 + #_POSIX_C_SOURCE + 2 + + ) + +205 #–ià +defšed + +_XOPEN_SOURCE + && (_XOPEN_SOURCE - 0) < 600 + +206 + #_POSIX_C_SOURCE + 199506L + + ) + +207 #–ià +defšed + +_XOPEN_SOURCE + && (_XOPEN_SOURCE - 0) < 700 + +208 + #_POSIX_C_SOURCE + 200112L + + ) + +210 + #_POSIX_C_SOURCE + 200809L + + ) + +212 + #__USE_POSIX_IMPLICITLY + 1 + + ) + +215 #ià +defšed + +_POSIX_SOURCE + || +_POSIX_C_SOURCE + >ð1 || defšed +_XOPEN_SOURCE + + +216 + #__USE_POSIX + 1 + + ) + +219 #ià +defšed + +_POSIX_C_SOURCE + && _POSIX_C_SOURCE >ð2 || defšed +_XOPEN_SOURCE + + +220 + #__USE_POSIX2 + 1 + + ) + +223 #ià( +_POSIX_C_SOURCE + - 0) >= 199309L + +224 + #__USE_POSIX199309 + 1 + + ) + +227 #ià( +_POSIX_C_SOURCE + - 0) >= 199506L + +228 + #__USE_POSIX199506 + 1 + + ) + +231 #ià( +_POSIX_C_SOURCE + - 0) >= 200112L + +232 + #__USE_XOPEN2K + 1 + + ) + +233 #undeà +__USE_ISOC99 + + +234 + #__USE_ISOC99 + 1 + + ) + +237 #ià( +_POSIX_C_SOURCE + - 0) >= 200809L + +238 + #__USE_XOPEN2K8 + 1 + + ) + +239 #undeà +_ATFILE_SOURCE + + +240 + #_ATFILE_SOURCE + 1 + + ) + +243 #ifdef +_XOPEN_SOURCE + + +244 + #__USE_XOPEN + 1 + + ) + +245 #ià( +_XOPEN_SOURCE + - 0) >= 500 + +246 + #__USE_XOPEN_EXTENDED + 1 + + ) + +247 + #__USE_UNIX98 + 1 + + ) + +248 #undeà +_LARGEFILE_SOURCE + + +249 + #_LARGEFILE_SOURCE + 1 + + ) + +250 #ià( +_XOPEN_SOURCE + - 0) >= 600 + +251 #ià( +_XOPEN_SOURCE + - 0) >= 700 + +252 + #__USE_XOPEN2K8 + 1 + + ) + +254 + #__USE_XOPEN2K + 1 + + ) + +255 #undeà +__USE_ISOC99 + + +256 + #__USE_ISOC99 + 1 + + ) + +259 #ifdeà +_XOPEN_SOURCE_EXTENDED + + +260 + #__USE_XOPEN_EXTENDED + 1 + + ) + +265 #ifdeà +_LARGEFILE_SOURCE + + +266 + #__USE_LARGEFILE + 1 + + ) + +269 #ifdeà +_LARGEFILE64_SOURCE + + +270 + #__USE_LARGEFILE64 + 1 + + ) + +273 #ià +defšed + +_FILE_OFFSET_BITS + && _FILE_OFFSET_BITS == 64 + +274 + #__USE_FILE_OFFSET64 + 1 + + ) + +277 #ià +defšed + +_BSD_SOURCE + || defšed +_SVID_SOURCE + + +278 + #__USE_MISC + 1 + + ) + +281 #ifdef +_BSD_SOURCE + + +282 + #__USE_BSD + 1 + + ) + +285 #ifdef +_SVID_SOURCE + + +286 + #__USE_SVID + 1 + + ) + +289 #ifdef +_ATFILE_SOURCE + + +290 + #__USE_ATFILE + 1 + + ) + +293 #ifdef +_GNU_SOURCE + + +294 + #__USE_GNU + 1 + + ) + +297 #ià +defšed + +_REENTRANT + || defšed +_THREAD_SAFE + + +298 + #__USE_REENTRANT + 1 + + ) + +301 #ià +defšed + +_FORTIFY_SOURCE + && _FORTIFY_SOURCE > 0 \ + +302 && +__GNUC_PREREQ + (4, 1è&& +defšed + + g__OPTIMIZE__ + && __OPTIMIZE__ > 0 + +303 #ià +_FORTIFY_SOURCE + > 1 + +304 + #__USE_FORTIFY_LEVEL + 2 + + ) + +306 + #__USE_FORTIFY_LEVEL + 1 + + ) + +309 + #__USE_FORTIFY_LEVEL + 0 + + ) + +313 + ~<b™s/´edefs.h +> + +316 + #__STDC_ISO_10646__ + 200009L + + ) + +324 #undeà +__GNU_LIBRARY__ + + +325 + #__GNU_LIBRARY__ + 6 + + ) + +329 + #__GLIBC__ + 2 + + ) + +330 + #__GLIBC_MINOR__ + 11 + + ) + +332 + #__GLIBC_PREREQ +( +maj +, +mš +) \ + +333 (( +__GLIBC__ + << 16è+ +__GLIBC_MINOR__ + >ð(( +maj +è<< 16è+ ( +mš +)) + + ) + +336 #ià +defšed + +__GNUC__ + \ + +337 || ( +defšed + + g__PGI + && defšed + g__i386__ + ) \ + +338 || ( +defšed + + g__INTEL_COMPILER + && (defšed + g__i386__ + || defšed + g__Ÿ64__ +)) \ + +339 || ( +defšed + + g__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L) + +340 + #__GLIBC_HAVE_LONG_LONG + 1 + + ) + +344 #iâdeà +__ASSEMBLER__ + + +345 #iâdeà +_SYS_CDEFS_H + + +346 + ~<sys/cdefs.h +> + +351 #ià +defšed + +__USE_FILE_OFFSET64 + && !defšed +__REDIRECT + + +352 + #__USE_LARGEFILE + 1 + + ) + +353 + #__USE_LARGEFILE64 + 1 + + ) + +359 #ià +__GNUC_PREREQ + (2, 7è&& +defšed + +__OPTIMIZE__ + \ + +360 && ! +defšed + + g__OPTIMIZE_SIZE__ + && !defšed + g__NO_INLINE__ + \ + +361 && +defšed + + g__ex‹º_šlše + + +362 + #__USE_EXTERN_INLINES + 1 + + ) + +367 #ià +__GNUC_PREREQ + (2, 7è&& +defšed + +__OPTIMIZE__ + \ + +368 && ( +defšed + + g_LIBC + || !defšed + g__OPTIMIZE_SIZE__ +è&& !defšed + g__NO_INLINE__ + \ + +369 && +defšed + + g__ex‹º_šlše + + +370 + #__USE_EXTERN_INLINES_IN_LIBC + 1 + + ) + +378 + ~<gnu/¡ubs.h +> + + @/usr/include/getopt.h + +21 #iâdeà +_GETOPT_H + + +23 #iâdeà +__Ãed_g‘Ýt + + +24 + #_GETOPT_H + 1 + + ) + +34 #ià! +defšed + +__GNU_LIBRARY__ + + +35 + ~<ùy³.h +> + +38 #iâdeà +__THROW + + +39 #iâdeà +__GNUC_PREREQ + + +40 + #__GNUC_PREREQ +( +maj +, +mš +è(0) + + ) + +42 #ià +defšed + +__ýlu¥lus + && +__GNUC_PREREQ + (2,8) + +43 + #__THROW + + `throw + () + + ) + +45 + #__THROW + + + ) + +49 #ifdef +__ýlu¥lus + + +59
* +Ýrg +; + +73
+Ýtšd +; + +78
+Ý‹¼ +; + +82
+ÝtÝt +; + +84 #iâdeà +__Ãed_g‘Ýt + + +106 + sÝtiÚ + + +108 cÚ¡ * + gÇme +; + +111 + ghas_¬g +; + +112 * + gæag +; + +113 + gv® +; + +118 + #no_¬gum’t + 0 + + ) + +119 + #»quœed_¬gum’t + 1 + + ) + +120 + #ÝtiÚ®_¬gum’t + 2 + + ) + +148 #ifdeà +__GNU_LIBRARY__ + + +152
+g‘Ýt + ( +___¬gc +, *cÚ¡ * +___¬gv +, cÚ¡ * +__shÜtÝts +) + +153 +__THROW +; + +155 #ià +defšed + +__Ãed_g‘Ýt + && defšed +__USE_POSIX2 + \ + +156 && ! +defšed + + g__USE_POSIX_IMPLICITLY + && !defšed + g__USE_GNU + + +160 #ifdeà +__REDIRECT + + +161
+__REDIRECT + ( +g‘Ýt +, ( +___¬gc +, *cÚ¡ * +___¬gv +, + +162 cÚ¡ * +__shÜtÝts +), + +163 +__posix_g‘Ýt +è +__THROW +; + +165
+__posix_g‘Ýt + ( +___¬gc +, *cÚ¡ * +___¬gv +, + +166 cÚ¡ * +__shÜtÝts +è +__THROW +; + +167 + #g‘Ýt + +__posix_g‘Ýt + + + ) + +171
+g‘Ýt + (); + +174 #iâdeà +__Ãed_g‘Ýt + + +175
+g‘Ýt_lÚg + ( +___¬gc +, *cÚ¡ * +___¬gv +, + +176 cÚ¡ * +__shÜtÝts +, + +177 cÚ¡ +ÝtiÚ + * +__lÚgÝts +, * +__lÚgšd +) + +178 +__THROW +; + +179
+g‘Ýt_lÚg_Úly + ( +___¬gc +, *cÚ¡ * +___¬gv +, + +180 cÚ¡ * +__shÜtÝts +, + +181 cÚ¡ +ÝtiÚ + * +__lÚgÝts +, * +__lÚgšd +) + +182 +__THROW +; + +186 #ifdef +__ýlu¥lus + + +191 #undeà +__Ãed_g‘Ýt + + + @/usr/include/libio.h + +29 #iâdeà +_IO_STDIO_H + + +30 + #_IO_STDIO_H + + + ) + +32 + ~<_G_cÚfig.h +> + +34 + #_IO_pos_t + +_G_åos_t + + + ) + +35 + #_IO_åos_t + +_G_åos_t + + + ) + +36 + #_IO_åos64_t + +_G_åos64_t + + + ) + +37 + #_IO_size_t + +_G_size_t + + + ) + +38 + #_IO_ssize_t + +_G_ssize_t + + + ) + +39 + #_IO_off_t + +_G_off_t + + + ) + +40 + #_IO_off64_t + +_G_off64_t + + + ) + +41 + #_IO_pid_t + +_G_pid_t + + + ) + +42 + #_IO_uid_t + +_G_uid_t + + + ) + +43 + #_IO_icÚv_t + +_G_icÚv_t + + + ) + +44 + #_IO_HAVE_SYS_WAIT + +_G_HAVE_SYS_WAIT + + + ) + +45 + #_IO_HAVE_ST_BLKSIZE + +_G_HAVE_ST_BLKSIZE + + + ) + +46 + #_IO_BUFSIZ + +_G_BUFSIZ + + + ) + +47 + #_IO_va_li¡ + +_G_va_li¡ + + + ) + +48 + #_IO_wšt_t + +_G_wšt_t + + + ) + +50 #ifdeà +_G_NEED_STDARG_H + + +52 + #__Ãed___va_li¡ + + + ) + +53 + ~<¡d¬g.h +> + +54 #ifdeà +__GNUC_VA_LIST + + +55 #undeà +_IO_va_li¡ + + +56 + #_IO_va_li¡ + +__gnuc_va_li¡ + + + ) + +60 #iâdeà +__P + + +61 #ià +_G_HAVE_SYS_CDEFS + + +62 + ~<sys/cdefs.h +> + +64 #ifdeà +__STDC__ + + +65 + #__P +( +p +è + ) +p + +66 + #__PMT +( +p +è + ) +p + +68 + #__P +( +p +è() + + ) + +69 + #__PMT +( +p +è() + + ) + +75 #iâdeà +_PARAMS + + +76 + #_PARAMS +( +´Ùos +è + `__P +ÕrÙos) + + ) + +79 #iâdeà +__STDC__ + + +81 cÚ¡ + + ) + +84 + #_IO_UNIFIED_JUMPTABLES + 1 + + ) + +85 #iâdeà +_G_HAVE_PRINTF_FP + + +86 + #_IO_USE_DTOA + 1 + + ) + +89 #iâdeà +EOF + + +90 + #EOF + (-1) + + ) + +92 #iâdeà +NULL + + +93 #ià +defšed + +__GNUG__ + && \ + +94 ( + g__GNUC__ + > 2 || (__GNUC__ =ð2 && +__GNUC_MINOR__ + >= 8)) + +95 + #NULL + ( +__nuÎ +) + + ) + +97 #ià! +defšed +( +__ýlu¥lus +) + +98 + #NULL + (( *)0) + + ) + +100 + #NULL + (0) + + ) + +105 + #_IOS_INPUT + 1 + + ) + +106 + #_IOS_OUTPUT + 2 + + ) + +107 + #_IOS_ATEND + 4 + + ) + +108 + #_IOS_APPEND + 8 + + ) + +109 + #_IOS_TRUNC + 16 + + ) + +110 + #_IOS_NOCREATE + 32 + + ) + +111 + #_IOS_NOREPLACE + 64 + + ) + +112 + #_IOS_BIN + 128 + + ) + +120 + #_IO_MAGIC + 0xFBAD0000 + + ) + +121 + #_OLD_STDIO_MAGIC + 0xFABC0000 + + ) + +122 + #_IO_MAGIC_MASK + 0xFFFF0000 + + ) + +123 + #_IO_USER_BUF + 1 + + ) + +124 + #_IO_UNBUFFERED + 2 + + ) + +125 + #_IO_NO_READS + 4 + + ) + +126 + #_IO_NO_WRITES + 8 + + ) + +127 + #_IO_EOF_SEEN + 0x10 + + ) + +128 + #_IO_ERR_SEEN + 0x20 + + ) + +129 + #_IO_DELETE_DONT_CLOSE + 0x40 + + ) + +130 + #_IO_LINKED + 0x80 + + ) + +131 + #_IO_IN_BACKUP + 0x100 + + ) + +132 + #_IO_LINE_BUF + 0x200 + + ) + +133 + #_IO_TIED_PUT_GET + 0x400 + + ) + +134 + #_IO_CURRENTLY_PUTTING + 0x800 + + ) + +135 + #_IO_IS_APPENDING + 0x1000 + + ) + +136 + #_IO_IS_FILEBUF + 0x2000 + + ) + +137 + #_IO_BAD_SEEN + 0x4000 + + ) + +138 + #_IO_USER_LOCK + 0x8000 + + ) + +140 + #_IO_FLAGS2_MMAP + 1 + + ) + +141 + #_IO_FLAGS2_NOTCANCEL + 2 + + ) + +142 #ifdeà +_LIBC + + +143 + #_IO_FLAGS2_FORTIFY + 4 + + ) + +145 + #_IO_FLAGS2_USER_WBUF + 8 + + ) + +146 #ifdeà +_LIBC + + +147 + #_IO_FLAGS2_SCANF_STD + 16 + + ) + +151 + #_IO_SKIPWS + 01 + + ) + +152 + #_IO_LEFT + 02 + + ) + +153 + #_IO_RIGHT + 04 + + ) + +154 + #_IO_INTERNAL + 010 + + ) + +155 + #_IO_DEC + 020 + + ) + +156 + #_IO_OCT + 040 + + ) + +157 + #_IO_HEX + 0100 + + ) + +158 + #_IO_SHOWBASE + 0200 + + ) + +159 + #_IO_SHOWPOINT + 0400 + + ) + +160 + #_IO_UPPERCASE + 01000 + + ) + +161 + #_IO_SHOWPOS + 02000 + + ) + +162 + #_IO_SCIENTIFIC + 04000 + + ) + +163 + #_IO_FIXED + 010000 + + ) + +164 + #_IO_UNITBUF + 020000 + + ) + +165 + #_IO_STDIO + 040000 + + ) + +166 + #_IO_DONT_CLOSE + 0100000 + + ) + +167 + #_IO_BOOLALPHA + 0200000 + + ) + +170 +_IO_jump_t +; + g_IO_FILE +; + +173 #ifdeà +_IO_MTSAFE_IO + + +174 #ià +defšed + +__GLIBC__ + && __GLIBC__ >= 2 + +175 + ~<b™s/¡dio-lock.h +> + +180 + t_IO_lock_t +; + +186 + s_IO_m¬k” + { + +187 +_IO_m¬k” + * + m_Ãxt +; + +188 +_IO_FILE + * + m_sbuf +; + +192 + m_pos +; + +194 +£t_¡»ampos +( +¡»ampos + +¥ +è{ + m_¥os + = sp; } + +195 +£t_off£t +( +off£t +è{ + m_pos + = off£t; + m_¥os + = ( +¡»ampos +)(-2); } + +196 + mpublic +: + +197 +¡»amm¬k” +( +¡»ambuf + * +sb +); + +198 ~ +¡»amm¬k” +(); + +199 +§všg +(è{ + m_¥os + == -2; } + +200 +d– +( +¡»amm¬k” +&); + +201 +d– +(); + +206 + e__codecvt_»suÉ + + +208 + m__codecvt_ok +, + +209 + m__codecvt_·¹Ÿl +, + +210 + m__codecvt_”rÜ +, + +211 + m__codecvt_nocÚv + + +214 #ià +defšed + +_LIBC + || defšed +_GLIBCPP_USE_WCHAR_T + + +217 + s_IO_codecvt + + +219 (* + m__codecvt_de¡r +è( + m_IO_codecvt + *); + +220 +__codecvt_»suÉ + (* +__codecvt_do_out +è( + m_IO_codecvt + *, + +221 + m__mb¡©e_t + *, + +222 cÚ¡ + mwch¬_t + *, + +223 cÚ¡ + mwch¬_t + *, + +224 cÚ¡ + mwch¬_t + **, *, + +226 +__codecvt_»suÉ + (* +__codecvt_do_unshiá +è( + m_IO_codecvt + *, + +227 + m__mb¡©e_t + *, *, + +229 +__codecvt_»suÉ + (* +__codecvt_do_š +è( + m_IO_codecvt + *, + +230 + m__mb¡©e_t + *, + +232 cÚ¡ **, + mwch¬_t + *, + +233 + mwch¬_t + *, wchar_t **); + +234 (* + m__codecvt_do_’codšg +è( + m_IO_codecvt + *); + +235 (* + m__codecvt_do_®ways_nocÚv +è( + m_IO_codecvt + *); + +236 (* + m__codecvt_do_Ëngth +è( + m_IO_codecvt + *, + m__mb¡©e_t + *, + +237 cÚ¡ *, cÚ¡ *, + m_IO_size_t +); + +238 (* + m__codecvt_do_max_Ëngth +è( + m_IO_codecvt + *); + +240 +_IO_icÚv_t + + m__cd_š +; + +241 +_IO_icÚv_t + + m__cd_out +; + +245 + s_IO_wide_d©a + + +247 +wch¬_t + * + m_IO_»ad_±r +; + +248 +wch¬_t + * + m_IO_»ad_’d +; + +249 +wch¬_t + * + m_IO_»ad_ba£ +; + +250 +wch¬_t + * + m_IO_wr™e_ba£ +; + +251 +wch¬_t + * + m_IO_wr™e_±r +; + +252 +wch¬_t + * + m_IO_wr™e_’d +; + +253 +wch¬_t + * + m_IO_buf_ba£ +; + +254 +wch¬_t + * + m_IO_buf_’d +; + +256 +wch¬_t + * + m_IO_§ve_ba£ +; + +257 +wch¬_t + * + m_IO_backup_ba£ +; + +259 +wch¬_t + * + m_IO_§ve_’d +; + +261 +__mb¡©e_t + + m_IO_¡©e +; + +262 +__mb¡©e_t + + m_IO_Ï¡_¡©e +; + +263 +_IO_codecvt + + m_codecvt +; + +265 +wch¬_t + + m_shÜtbuf +[1]; + +267 cÚ¡ +_IO_jump_t + * + m_wide_vbË +; + +271 + s_IO_FILE + { + +272 + m_æags +; + +273 + #_IO_fže_æags + +_æags + + + ) + +277 * + m_IO_»ad_±r +; + +278 * + m_IO_»ad_’d +; + +279 * + m_IO_»ad_ba£ +; + +280 * + m_IO_wr™e_ba£ +; + +281 * + m_IO_wr™e_±r +; + +282 * + m_IO_wr™e_’d +; + +283 * + m_IO_buf_ba£ +; + +284 * + m_IO_buf_’d +; + +286 * + m_IO_§ve_ba£ +; + +287 * + m_IO_backup_ba£ +; + +288 * + m_IO_§ve_’d +; + +290 +_IO_m¬k” + * + m_m¬k”s +; + +292 +_IO_FILE + * + m_chaš +; + +294 + m_fž’o +; + +296 + m_blksize +; + +298 + m_æags2 +; + +300 +_IO_off_t + + m_Þd_off£t +; + +302 + #__HAVE_COLUMN + + + ) + +304 + m_cur_cÞumn +; + +305 sigÃd + m_vbË_off£t +; + +306 + m_shÜtbuf +[1]; + +310 +_IO_lock_t + * + m_lock +; + +311 #ifdeà +_IO_USE_OLD_IO_FILE + + +314 + s_IO_FILE_com¶‘e + + +316 +_IO_FILE + + m_fže +; + +318 #ià +defšed + +_G_IO_IO_FILE_VERSION + && _G_IO_IO_FILE_VERSION == 0x20001 + +319 +_IO_off64_t + + m_off£t +; + +320 #ià +defšed + +_LIBC + || defšed +_GLIBCPP_USE_WCHAR_T + + +322 +_IO_codecvt + * + m_codecvt +; + +323 +_IO_wide_d©a + * + m_wide_d©a +; + +324 +_IO_FILE + * + m_ä“»s_li¡ +; + +325 * + m_ä“»s_buf +; + +326 +size_t + + m_ä“»s_size +; + +328 * + m__·d1 +; + +329 * + m__·d2 +; + +330 * + m__·d3 +; + +331 * + m__·d4 +; + +332 +size_t + + m__·d5 +; + +334 + m_mode +; + +336 + m_unu£d2 +[15 * (è- 4 * ( *è- ( +size_t +)]; + +340 #iâdeà +__ýlu¥lus + + +341 +_IO_FILE + + t_IO_FILE +; + +344 + g_IO_FILE_¶us +; + +346
+_IO_FILE_¶us + +_IO_2_1_¡dš_ +; + +347
+_IO_FILE_¶us + +_IO_2_1_¡dout_ +; + +348
+_IO_FILE_¶us + +_IO_2_1_¡d”r_ +; + +349 #iâdeà +_LIBC + + +350 + #_IO_¡dš + (( +_IO_FILE +*)(& +_IO_2_1_¡dš_ +)) + + ) + +351 + #_IO_¡dout + (( +_IO_FILE +*)(& +_IO_2_1_¡dout_ +)) + + ) + +352 + #_IO_¡d”r + (( +_IO_FILE +*)(& +_IO_2_1_¡d”r_ +)) + + ) + +354
+_IO_FILE + * +_IO_¡dš + +©Œibu‹_hidd’ +; + +355
+_IO_FILE + * +_IO_¡dout + +©Œibu‹_hidd’ +; + +356
+_IO_FILE + * +_IO_¡d”r + +©Œibu‹_hidd’ +; + +364 +__ssize_t + + t__io_»ad_â + ( * + t__cook› +, * + t__buf +, + tsize_t + + t__nby‹s +); + +372 +__ssize_t + + t__io_wr™e_â + ( * + t__cook› +, + t__cÚ¡ + * + t__buf +, + +373 + tsize_t + + t__n +); + +381 + t__io_£ek_â + ( * + t__cook› +, + t_IO_off64_t + * + t__pos +, + t__w +); + +384 + t__io_þo£_â + ( * + t__cook› +); + +387 #ifdeà +_GNU_SOURCE + + +389 +__io_»ad_â + + tcook›_»ad_funùiÚ_t +; + +390 +__io_wr™e_â + + tcook›_wr™e_funùiÚ_t +; + +391 +__io_£ek_â + + tcook›_£ek_funùiÚ_t +; + +392 +__io_þo£_â + + tcook›_þo£_funùiÚ_t +; + +397 +__io_»ad_â + * + m»ad +; + +398 +__io_wr™e_â + * + mwr™e +; + +399 +__io_£ek_â + * + m£ek +; + +400 +__io_þo£_â + * + mþo£ +; + +401 } + t_IO_cook›_io_funùiÚs_t +; + +402 +_IO_cook›_io_funùiÚs_t + + tcook›_io_funùiÚs_t +; + +404 + g_IO_cook›_fže +; + +407
+_IO_cook›_š™ + ( +_IO_cook›_fže + * +__cfže +, +__»ad_wr™e +, + +408 * +__cook› +, +_IO_cook›_io_funùiÚs_t + +__âs +); + +412 #ifdeà +__ýlu¥lus + + +416
+__undӾow + ( +_IO_FILE + *); + +417
+__uæow + ( +_IO_FILE + *); + +418
+__ov”æow + ( +_IO_FILE + *, ); + +419 #ià +defšed + +_LIBC + || defšed +_GLIBCPP_USE_WCHAR_T + + +420
+_IO_wšt_t + +__wund”æow + ( +_IO_FILE + *); + +421
+_IO_wšt_t + +__wuæow + ( +_IO_FILE + *); + +422
+_IO_wšt_t + +__wov”æow + ( +_IO_FILE + *, _IO_wint_t); + +425 #ià +__GNUC__ + >= 3 + +426 + #_IO_BE +( +ex´ +, +»s +è + `__bužtš_ex³ù + (Óx´),„es) + + ) + +428 + #_IO_BE +( +ex´ +, +»s +èÓx´) + + ) + +431 + #_IO_g‘c_uÆocked +( +_å +) \ + +432 ( + `_IO_BE + (( +_å +)-> +_IO_»ad_±r + >ð(_å)-> +_IO_»ad_’d +, 0) \ + +433 ? + `__uæow + ( +_å +è: *( *è(_å)-> +_IO_»ad_±r +++) + + ) + +434 + #_IO_³ekc_uÆocked +( +_å +) \ + +435 ( + `_IO_BE + (( +_å +)-> +_IO_»ad_±r + >ð(_å)-> +_IO_»ad_’d +, 0) \ + +436 && + `__und”æow + ( +_å +è=ð +EOF + ? EOF \ + +437 : *( *è( +_å +)-> +_IO_»ad_±r +) + + ) + +438 + #_IO_putc_uÆocked +( +_ch +, +_å +) \ + +439 ( + `_IO_BE + (( +_å +)-> +_IO_wr™e_±r + >ð(_å)-> +_IO_wr™e_’d +, 0) \ + +440 ? + `__ov”æow + ( +_å +, ( è( +_ch +)) \ + +441 : ( è(*( +_å +)-> +_IO_wr™e_±r +++ = ( +_ch +))) + + ) + +443 #ià +defšed + +_LIBC + || defšed +_GLIBCPP_USE_WCHAR_T + + +444 + #_IO_g‘wc_uÆocked +( +_å +) \ + +445 ( + `_IO_BE + (( +_å +)-> +_wide_d©a + =ð +NULL + \ + +446 || (( +_å +)-> +_wide_d©a +-> +_IO_»ad_±r + \ + +447 >ð( +_å +)-> +_wide_d©a +-> +_IO_»ad_’d +), 0) \ + +448 ? + `__wuæow + ( +_å +è: ( +_IO_wšt_t +è*(_å)-> +_wide_d©a +-> +_IO_»ad_±r +++) + + ) + +449 + #_IO_putwc_uÆocked +( +_wch +, +_å +) \ + +450 ( + `_IO_BE + (( +_å +)-> +_wide_d©a + =ð +NULL + \ + +451 || (( +_å +)-> +_wide_d©a +-> +_IO_wr™e_±r + \ + +452 >ð( +_å +)-> +_wide_d©a +-> +_IO_wr™e_’d +), 0) \ + +453 ? + `__wov”æow + ( +_å +, +_wch +) \ + +454 : ( +_IO_wšt_t +è(*( +_å +)-> +_wide_d©a +-> +_IO_wr™e_±r +++ = ( +_wch +))) + + ) + +457 + #_IO_ãof_uÆocked +( +__å +è(((__å)-> +_æags + & +_IO_EOF_SEEN +è!ð0) + + ) + +458 + #_IO_ã¼Ü_uÆocked +( +__å +è(((__å)-> +_æags + & +_IO_ERR_SEEN +è!ð0) + + ) + +460
+_IO_g‘c + ( +_IO_FILE + * +__å +); + +461
+_IO_putc + ( +__c +, +_IO_FILE + * +__å +); + +462
+_IO_ãof + ( +_IO_FILE + * +__å +è +__THROW +; + +463
+_IO_ã¼Ü + ( +_IO_FILE + * +__å +è +__THROW +; + +465
+_IO_³ekc_locked + ( +_IO_FILE + * +__å +); + +468 + #_IO_PENDING_OUTPUT_COUNT +( +_å +) \ + +469 (( +_å +)-> +_IO_wr™e_±r + - (_å)-> +_IO_wr™e_ba£ +) + + ) + +471
+_IO_æockfže + ( +_IO_FILE + *è +__THROW +; + +472
+_IO_fuÆockfže + ( +_IO_FILE + *è +__THROW +; + +473
+_IO_árylockfže + ( +_IO_FILE + *è +__THROW +; + +475 #ifdeà +_IO_MTSAFE_IO + + +476 + #_IO_³ekc +( +_å +è + `_IO_³ekc_locked + (_å) + + ) + +477 + #_IO_æockfže +( +_å +) \ + +478 ià((( +_å +)-> +_æags + & +_IO_USER_LOCK +è=ð0è + `_IO_æockfže + (_å) + + ) + +479 + #_IO_fuÆockfže +( +_å +) \ + +480 ià((( +_å +)-> +_æags + & +_IO_USER_LOCK +è=ð0è + `_IO_fuÆockfže + (_å) + + ) + +482 + #_IO_³ekc +( +_å +è + `_IO_³ekc_uÆocked + (_å) + + ) + +483 + #_IO_æockfže +( +_å +è + + ) + +484 + #_IO_fuÆockfže +( +_å +è + + ) + +485 + #_IO_árylockfže +( +_å +è + + ) + +486 + #_IO_þ—nup_»giÚ_¡¬t +( +_fù +, +_å +è + + ) + +487 + #_IO_þ—nup_»giÚ_’d +( +_Do™ +è + + ) + +490
+_IO_vfsÿnf + ( +_IO_FILE + * +__»¡riù +, const * __restrict, + +491 +_IO_va_li¡ +, * +__»¡riù +); + +492
+_IO_vårštf + ( +_IO_FILE + * +__»¡riù +, const *__restrict, + +493 +_IO_va_li¡ +); + +494
+_IO_ssize_t + +_IO_·dn + ( +_IO_FILE + *, , _IO_ssize_t); + +495
+_IO_size_t + +_IO_sg‘n + ( +_IO_FILE + *, *, _IO_size_t); + +497
+_IO_off64_t + +_IO_£ekoff + ( +_IO_FILE + *, _IO_off64_t, , ); + +498
+_IO_off64_t + +_IO_£ekpos + ( +_IO_FILE + *, _IO_off64_t, ); + +500
+_IO_ä“_backup_¬— + ( +_IO_FILE + *è +__THROW +; + +502 #ià +defšed + +_LIBC + || defšed +_GLIBCPP_USE_WCHAR_T + + +503
+_IO_wšt_t + +_IO_g‘wc + ( +_IO_FILE + * +__å +); + +504
+_IO_wšt_t + +_IO_putwc + ( +wch¬_t + +__wc +, +_IO_FILE + * +__å +); + +505
+_IO_fwide + ( +_IO_FILE + * +__å +, +__mode +è +__THROW +; + +506 #ià +__GNUC__ + >= 2 + +509 #ià +defšed + +_LIBC + && defšed +SHARED + + +510 + ~<shlib-com·t.h +> + +511 #ià +SHLIB_COMPAT + ( +libc +, +GLIBC_2_0 +, +GLIBC_2_1 +) + +512 + #_IO_fwide_maybe_šcom·tibË + \ + +513 ( + `__bužtš_ex³ù + (& +_IO_¡dš_u£d + =ð +NULL +, 0)) + + ) + +514
cÚ¡ +_IO_¡dš_u£d +; + +515 +w—k_ex‹º + ( +_IO_¡dš_u£d +); + +518 #iâdeà +_IO_fwide_maybe_šcom·tibË + + +519 + #_IO_fwide_maybe_šcom·tibË + (0) + + ) + +523 + #_IO_fwide +( +__å +, +__mode +) \ + +524 ({ +__»suÉ + = ( +__mode +); \ + +525 ià( +__»suÉ + < 0 && ! +_IO_fwide_maybe_šcom·tibË +) \ + +527 ià(( +__å +)-> +_mode + == 0) \ + +529 ( +__å +)-> +_mode + = -1; \ + +530 +__»suÉ + = ( +__å +)-> +_mode +; \ + +532 ià( + `__bužtš_cÚ¡ªt_p + ( +__mode +) && (__mode) == 0) \ + +533 +__»suÉ + = +_IO_fwide_maybe_šcom·tibË + ? -1 : ( +__å +)-> +_mode +; \ + +535 +__»suÉ + = + `_IO_fwide + ( +__å +, __result); \ + +536 +__»suÉ +; }) + + ) + +539
+_IO_vfwsÿnf + ( +_IO_FILE + * +__»¡riù +, cÚ¡ +wch¬_t + * __restrict, + +540 +_IO_va_li¡ +, * +__»¡riù +); + +541
+_IO_vfw´štf + ( +_IO_FILE + * +__»¡riù +, cÚ¡ +wch¬_t + *__restrict, + +542 +_IO_va_li¡ +); + +543
+_IO_ssize_t + +_IO_w·dn + ( +_IO_FILE + *, +wšt_t +, _IO_ssize_t); + +544
+_IO_ä“_wbackup_¬— + ( +_IO_FILE + *è +__THROW +; + +547 #ifdeà +__LDBL_COMPAT + + +548 + ~<b™s/libio-ldbl.h +> + +551 #ifdeà +__ýlu¥lus + + + @/usr/include/xlocale.h + +21 #iâdeà +_XLOCALE_H + + +22 + #_XLOCALE_H + 1 + + ) + +28 + s__loÿË_¡ruù + + +31 +loÿË_d©a + * + m__loÿËs +[13]; + +34 cÚ¡ * + m__ùy³_b +; + +35 cÚ¡ * + m__ùy³_tÞow” +; + +36 cÚ¡ * + m__ùy³_touµ” +; + +39 cÚ¡ * + m__Çmes +[13]; + +40 } * + t__loÿË_t +; + +43 +__loÿË_t + + tloÿË_t +; + + @/usr/include/_G_config.h + +4 #iâdeà +_G_cÚfig_h + + +5 + #_G_cÚfig_h + 1 + + ) + +9 + ~<b™s/ty³s.h +> + +10 + #__Ãed_size_t + + + ) + +11 #ià +defšed + +_LIBC + || defšed +_GLIBCPP_USE_WCHAR_T + + +12 + #__Ãed_wch¬_t + + + ) + +14 + #__Ãed_NULL + + + ) + +15 + ~<¡ddef.h +> + +16 + #__Ãed_mb¡©e_t + + + ) + +17 #ià +defšed + +_LIBC + || defšed +_GLIBCPP_USE_WCHAR_T + + +18 + #__Ãed_wšt_t + + + ) + +20 + ~<wch¬.h +> + +21 + #_G_size_t + +size_t + + + ) + +24 +__off_t + + m__pos +; + +25 +__mb¡©e_t + + m__¡©e +; + +26 } + t_G_åos_t +; + +29 +__off64_t + + m__pos +; + +30 +__mb¡©e_t + + m__¡©e +; + +31 } + t_G_åos64_t +; + +32 + #_G_ssize_t + +__ssize_t + + + ) + +33 + #_G_off_t + +__off_t + + + ) + +34 + #_G_off64_t + +__off64_t + + + ) + +35 + #_G_pid_t + +__pid_t + + + ) + +36 + #_G_uid_t + +__uid_t + + + ) + +37 + #_G_wch¬_t + +wch¬_t + + + ) + +38 + #_G_wšt_t + +wšt_t + + + ) + +39 + #_G_¡©64 + +¡©64 + + + ) + +40 #ià +defšed + +_LIBC + || defšed +_GLIBCPP_USE_WCHAR_T + + +41 + ~<gcÚv.h +> + +44 +__gcÚv_šfo + + m__cd +; + +47 +__gcÚv_šfo + + m__cd +; + +48 +__gcÚv_¡•_d©a + + m__d©a +; + +49 } + m__combšed +; + +50 } + t_G_icÚv_t +; + +53 + t_G_št16_t + + t__©Œibu‹__ + (( + t__mode__ + ( + t__HI__ +))); + +54 + t_G_št32_t + + t__©Œibu‹__ + (( + t__mode__ + ( + t__SI__ +))); + +55 + t_G_ušt16_t + + t__©Œibu‹__ + (( + t__mode__ + ( + t__HI__ +))); + +56 + t_G_ušt32_t + + t__©Œibu‹__ + (( + t__mode__ + ( + t__SI__ +))); + +58 + #_G_HAVE_BOOL + 1 + + ) + +62 + #_G_HAVE_ATEXIT + 1 + + ) + +63 + #_G_HAVE_SYS_CDEFS + 1 + + ) + +64 + #_G_HAVE_SYS_WAIT + 1 + + ) + +65 + #_G_NEED_STDARG_H + 1 + + ) + +66 + #_G_va_li¡ + +__gnuc_va_li¡ + + + ) + +68 + #_G_HAVE_PRINTF_FP + 1 + + ) + +69 + #_G_HAVE_MMAP + 1 + + ) + +70 + #_G_HAVE_MREMAP + 1 + + ) + +71 + #_G_HAVE_LONG_DOUBLE_IO + 1 + + ) + +72 + #_G_HAVE_IO_FILE_OPEN + 1 + + ) + +73 + #_G_HAVE_IO_GETLINE_INFO + 1 + + ) + +75 + #_G_IO_IO_FILE_VERSION + 0x20001 + + ) + +77 + #_G_OPEN64 + +__Ý’64 + + + ) + +78 + #_G_LSEEK64 + +__l£ek64 + + + ) + +79 + #_G_MMAP64 + +__mm64 + + + ) + +80 + #_G_FSTAT64 +( +fd +, +buf +è + `__fx¡©64 + ( +_STAT_VER +, fd, buf) + + ) + +83 + #_G_HAVE_ST_BLKSIZE + + `defšed + ( +_STATBUF_ST_BLKSIZE +) + + ) + +85 + #_G_BUFSIZ + 8192 + + ) + +88 + #_G_NAMES_HAVE_UNDERSCORE + 0 + + ) + +89 + #_G_VTABLE_LABEL_HAS_LENGTH + 1 + + ) + +90 + #_G_USING_THUNKS + 1 + + ) + +91 + #_G_VTABLE_LABEL_PREFIX + "__vt_" + + ) + +92 + #_G_VTABLE_LABEL_PREFIX_ID + +__vt_ + + + ) + +95 #ià +defšed + +__ýlu¥lus + || defšed +__STDC__ + + +96 + #_G_ARGS +( +ARGLIST +è + ) +ARGLIST + +98 + #_G_ARGS +( +ARGLIST +è() + + ) + + @/usr/include/bits/libio-ldbl.h + +20 #iâdeà +_IO_STDIO_H + + +24 + $__LDBL_REDIR_DECL + ( +_IO_vfsÿnf +) + +25 + `__LDBL_REDIR_DECL + ( +_IO_vårštf +) + + @/usr/include/bits/predefs.h + +19 #iâdeà +_FEATURES_H + + +23 #iâdeà +_PREDEFS_H + + +24 + #_PREDEFS_H + + + ) + +27 + #__STDC_IEC_559__ + 1 + + ) + +28 + #__STDC_IEC_559_COMPLEX__ + 1 + + ) + + @/usr/include/bits/stdio-lock.h + +20 #iâdeà +_BITS_STDIO_LOCK_H + + +21 + #_BITS_STDIO_LOCK_H + 1 + + ) + +23 + ~<b™s/libc-lock.h +> + +24 + ~<lowËv–lock.h +> + +28 + #_IO_lock_šex³nsive + 1 + + ) + +30 ¡ruù { + mlock +; + mút +; * + mowÃr +; } + t_IO_lock_t +; + +32 + #_IO_lock_š™Ÿliz” + { +LLL_LOCK_INITIALIZER +, 0, +NULL + } + + ) + +34 + #_IO_lock_š™ +( +_Çme +) \ + +35 (( +_Çme +èð( +_IO_lock_t +è +_IO_lock_š™Ÿliz” + , 0) + + ) + +37 + #_IO_lock_fši +( +_Çme +) \ + +38 (( è0) + + ) + +40 + #_IO_lock_lock +( +_Çme +) \ + +42 * +__£lf + = +THREAD_SELF +; \ + +43 ià(( +_Çme +). +owÃr + !ð +__£lf +) \ + +45 + `Îl_lock + (( +_Çme +). +lock +, +LLL_PRIVATE +); \ + +46 ( +_Çme +). +owÃr + = +__£lf +; \ + +48 ++( +_Çme +). +út +; \ + +49 } 0) + + ) + +51 + #_IO_lock_Œylock +( +_Çme +) \ + +53 +__»suÉ + = 0; \ + +54 * +__£lf + = +THREAD_SELF +; \ + +55 ià(( +_Çme +). +owÃr + !ð +__£lf +) \ + +57 ià( + `Îl_Œylock + (( +_Çme +). +lock +) == 0) \ + +59 ( +_Çme +). +owÃr + = +__£lf +; \ + +60 ( +_Çme +). +út + = 1; \ + +63 +__»suÉ + = +EBUSY +; \ + +66 ++( +_Çme +). +út +; \ + +67 +__»suÉ +; \ + +68 }) + + ) + +70 + #_IO_lock_uÆock +( +_Çme +) \ + +72 ià(--( +_Çme +). +út + == 0) \ + +74 ( +_Çme +). +owÃr + = +NULL +; \ + +75 + `Îl_uÆock + (( +_Çme +). +lock +, +LLL_PRIVATE +); \ + +77 } 0) + + ) + +81 + #_IO_þ—nup_»giÚ_¡¬t +( +_fù +, +_å +) \ + +82 + `__libc_þ—nup_»giÚ_¡¬t + ((( +_å +)-> +_æags + & +_IO_USER_LOCK +è=ð0, +_fù +, _å) + + ) + +83 + #_IO_þ—nup_»giÚ_¡¬t_nßrg +( +_fù +) \ + +84 + `__libc_þ—nup_»giÚ_¡¬t + (1, +_fù +, +NULL +) + + ) + +85 + #_IO_þ—nup_»giÚ_’d +( +_do™ +) \ + +86 + `__libc_þ—nup_»giÚ_’d + ( +_do™ +) + + ) + +88 #ià +defšed + +_LIBC + && !defšed +NOT_IN_libc + + +90 #ifdeà +__EXCEPTIONS + + +91 + #_IO_acquœe_lock +( +_å +) \ + +93 +_IO_FILE + * +_IO_acquœe_lock_fže + \ + +94 + `__©Œibu‹__ +(( + `þ—nup + ( +_IO_acquœe_lock_fù +))) \ + +95 ð( +_å +); \ + +96 + `_IO_æockfže + ( +_IO_acquœe_lock_fže +); + + ) + +97 + #_IO_acquœe_lock_þ—r_æags2 +( +_å +) \ + +99 +_IO_FILE + * +_IO_acquœe_lock_fže + \ + +100 + `__©Œibu‹__ +(( + `þ—nup + ( +_IO_acquœe_lock_þ—r_æags2_fù +))) \ + +101 ð( +_å +); \ + +102 + `_IO_æockfže + ( +_IO_acquœe_lock_fže +); + + ) + +104 + #_IO_acquœe_lock +( +_å +è +_IO_acquœe_lock_Ãeds_exû±iÚs_’abËd + + + ) + +105 + #_IO_acquœe_lock_þ—r_æags2 +( +_å +è + `_IO_acquœe_lock + (_å) + + ) + +107 + #_IO_»Ëa£_lock +( +_å +è; } 0) + + ) + + @/usr/include/bits/typesizes.h + +20 #iâdeà +_BITS_TYPES_H + + +24 #iâdef +_BITS_TYPESIZES_H + + +25 + #_BITS_TYPESIZES_H + 1 + + ) + +30 + #__DEV_T_TYPE + +__UQUAD_TYPE + + + ) + +31 + #__UID_T_TYPE + +__U32_TYPE + + + ) + +32 + #__GID_T_TYPE + +__U32_TYPE + + + ) + +33 + #__INO_T_TYPE + +__ULONGWORD_TYPE + + + ) + +34 + #__INO64_T_TYPE + +__UQUAD_TYPE + + + ) + +35 + #__MODE_T_TYPE + +__U32_TYPE + + + ) + +36 + #__NLINK_T_TYPE + +__UWORD_TYPE + + + ) + +37 + #__OFF_T_TYPE + +__SLONGWORD_TYPE + + + ) + +38 + #__OFF64_T_TYPE + +__SQUAD_TYPE + + + ) + +39 + #__PID_T_TYPE + +__S32_TYPE + + + ) + +40 + #__RLIM_T_TYPE + +__ULONGWORD_TYPE + + + ) + +41 + #__RLIM64_T_TYPE + +__UQUAD_TYPE + + + ) + +42 + #__BLKCNT_T_TYPE + +__SLONGWORD_TYPE + + + ) + +43 + #__BLKCNT64_T_TYPE + +__SQUAD_TYPE + + + ) + +44 + #__FSBLKCNT_T_TYPE + +__ULONGWORD_TYPE + + + ) + +45 + #__FSBLKCNT64_T_TYPE + +__UQUAD_TYPE + + + ) + +46 + #__FSFILCNT_T_TYPE + +__ULONGWORD_TYPE + + + ) + +47 + #__FSFILCNT64_T_TYPE + +__UQUAD_TYPE + + + ) + +48 + #__ID_T_TYPE + +__U32_TYPE + + + ) + +49 + #__CLOCK_T_TYPE + +__SLONGWORD_TYPE + + + ) + +50 + #__TIME_T_TYPE + +__SLONGWORD_TYPE + + + ) + +51 + #__USECONDS_T_TYPE + +__U32_TYPE + + + ) + +52 + #__SUSECONDS_T_TYPE + +__SLONGWORD_TYPE + + + ) + +53 + #__DADDR_T_TYPE + +__S32_TYPE + + + ) + +54 + #__SWBLK_T_TYPE + +__SLONGWORD_TYPE + + + ) + +55 + #__KEY_T_TYPE + +__S32_TYPE + + + ) + +56 + #__CLOCKID_T_TYPE + +__S32_TYPE + + + ) + +57 + #__TIMER_T_TYPE + * + + ) + +58 + #__BLKSIZE_T_TYPE + +__SLONGWORD_TYPE + + + ) + +59 + #__FSID_T_TYPE + sŒuù { +__v® +[2]; } + + ) + +60 + #__SSIZE_T_TYPE + +__SWORD_TYPE + + + ) + +63 + #__FD_SETSIZE + 1024 + + ) + + @/usr/include/bits/wordsize.h + +3 #ià +defšed + +__x86_64__ + + +4 + #__WORDSIZE + 64 + + ) + +5 + #__WORDSIZE_COMPAT32 + 1 + + ) + +7 + #__WORDSIZE + 32 + + ) + + @/usr/include/ctype.h + +24 #iâdef +_CTYPE_H + + +25 + #_CTYPE_H + 1 + + ) + +27 + ~<ã©u»s.h +> + +28 + ~<b™s/ty³s.h +> + +30 + g__BEGIN_DECLS + + +32 #iâdeà +_ISb™ + + +41 + ~<’dŸn.h +> + +42 #ià +__BYTE_ORDER + =ð +__BIG_ENDIAN + + +43 + #_ISb™ +( +b™ +è(1 << (b™)) + + ) + +45 + #_ISb™ +( +b™ +è((b™è< 8 ? ((1 << (b™)è<< 8è: ((1 << (b™)è>> 8)) + + ) + +50 + m_ISuµ” + = +_ISb™ + (0), + +51 + m_ISlow” + = +_ISb™ + (1), + +52 + m_IS®pha + = +_ISb™ + (2), + +53 + m_ISdig™ + = +_ISb™ + (3), + +54 + m_ISxdig™ + = +_ISb™ + (4), + +55 + m_IS¥aû + = +_ISb™ + (5), + +56 + m_IS´št + = +_ISb™ + (6), + +57 + m_ISg¿ph + = +_ISb™ + (7), + +58 + m_ISbÏnk + = +_ISb™ + (8), + +59 + m_ISúŒl + = +_ISb™ + (9), + +60 + m_ISpunù + = +_ISb™ + (10), + +61 + m_IS®num + = +_ISb™ + (11) + +81
+__cÚ¡ + ** + $__ùy³_b_loc + ( ) + +82 +__THROW + + `__©Œibu‹__ + (( +__cÚ¡ +)); + +83
+__cÚ¡ + +__št32_t + ** + $__ùy³_tÞow”_loc + ( ) + +84 +__THROW + + `__©Œibu‹__ + (( +__cÚ¡ +)); + +85
+__cÚ¡ + +__št32_t + ** + $__ùy³_touµ”_loc + ( ) + +86 +__THROW + + `__©Œibu‹__ + (( +__cÚ¡ +)); + +88 + #__isùy³ +( +c +, +ty³ +) \ + +89 ((* + `__ùy³_b_loc + ())[(è( +c +)] & ( è +ty³ +) + + ) + +91 + #__i§scii +( +c +è(((cè& ~0x7fè=ð0è + + ) + +92 + #__tßscii +( +c +è((cè& 0x7fè + + ) + +94 + #__exùy³ +( +Çme +è
+ `Çme + (è +__THROW + + + ) + +96 +__BEGIN_NAMESPACE_STD + + +102 + `__exùy³ + ( +i§Êum +); + +103 + `__exùy³ + ( +i§Íha +); + +104 + `__exùy³ + ( +isúŒl +); + +105 + `__exùy³ + ( +isdig™ +); + +106 + `__exùy³ + ( +i¦ow” +); + +107 + `__exùy³ + ( +isg¿ph +); + +108 + `__exùy³ + ( +i¥ršt +); + +109 + `__exùy³ + ( +i¥unù +); + +110 + `__exùy³ + ( +is¥aû +); + +111 + `__exùy³ + ( +isuµ” +); + +112 + `__exùy³ + ( +isxdig™ +); + +116
+ $tÞow” + ( +__c +è +__THROW +; + +119
+ $touµ” + ( +__c +è +__THROW +; + +121 +__END_NAMESPACE_STD + + +125 #ifdef +__USE_ISOC99 + + +126 +__BEGIN_NAMESPACE_C99 + + +128 + `__exùy³ + ( +isbÏnk +); + +130 +__END_NAMESPACE_C99 + + +133 #ifdeà +__USE_GNU + + +135
+ $isùy³ + ( +__c +, +__mask +è +__THROW +; + +138 #ià +defšed + +__USE_SVID + || defšed +__USE_MISC + || defšed +__USE_XOPEN + + +142
+ $i§scii + ( +__c +è +__THROW +; + +146
+ $tßscii + ( +__c +è +__THROW +; + +150 + `__exùy³ + ( +_touµ” +); + +151 + `__exùy³ + ( +_tÞow” +); + +155 + #__tobody +( +c +, +f +, +a +, +¬gs +) \ + +156 ( +__ex‹nsiÚ__ + \ + +157 ({ +__»s +; \ + +158 ià( ( +c +) > 1) \ + +160 ià( + `__bužtš_cÚ¡ªt_p + ( +c +)) \ + +162 +__c + = ( +c +); \ + +163 +__»s + = +__c + < -128 || __ø> 255 ? __ø: ( +a +)[__c]; \ + +166 +__»s + = +f + +¬gs +; \ + +169 +__»s + = ( +a +)[(è( +c +)]; \ + +170 +__»s +; + } +})) + + ) + +172 #ià! +defšed + +__NO_CTYPE + && !defšed +__ýlu¥lus + + +173 + #i§Êum +( +c +è + `__isùy³ +((c), +_IS®num +) + + ) + +174 + #i§Íha +( +c +è + `__isùy³ +((c), +_IS®pha +) + + ) + +175 + #isúŒl +( +c +è + `__isùy³ +((c), +_ISúŒl +) + + ) + +176 + #isdig™ +( +c +è + `__isùy³ +((c), +_ISdig™ +) + + ) + +177 + #i¦ow” +( +c +è + `__isùy³ +((c), +_ISlow” +) + + ) + +178 + #isg¿ph +( +c +è + `__isùy³ +((c), +_ISg¿ph +) + + ) + +179 + #i¥ršt +( +c +è + `__isùy³ +((c), +_IS´št +) + + ) + +180 + #i¥unù +( +c +è + `__isùy³ +((c), +_ISpunù +) + + ) + +181 + #is¥aû +( +c +è + `__isùy³ +((c), +_IS¥aû +) + + ) + +182 + #isuµ” +( +c +è + `__isùy³ +((c), +_ISuµ” +) + + ) + +183 + #isxdig™ +( +c +è + `__isùy³ +((c), +_ISxdig™ +) + + ) + +185 #ifdeà +__USE_ISOC99 + + +186 + #isbÏnk +( +c +è + `__isùy³ +((c), +_ISbÏnk +) + + ) + +189 #ifdeà +__USE_EXTERN_INLINES + + +190 +__ex‹º_šlše + + +191 +__NTH + ( + $tÞow” + ( +__c +)) + +193 +__c + >ð-128 && __ø< 256 ? (* + `__ùy³_tÞow”_loc + ())[__c] : __c; + +194 + } +} + +196 +__ex‹º_šlše + + +197 +__NTH + ( + $touµ” + ( +__c +)) + +199 +__c + >ð-128 && __ø< 256 ? (* + `__ùy³_touµ”_loc + ())[__c] : __c; + +200 + } +} + +203 #ià +__GNUC__ + >ð2 && +defšed + +__OPTIMIZE__ + && !defšed +__ýlu¥lus + + +204 + #tÞow” +( +c +è + `__tobody + (c, +tÞow” +, * + `__ùy³_tÞow”_loc + (), (c)) + + ) + +205 + #touµ” +( +c +è + `__tobody + (c, +touµ” +, * + `__ùy³_touµ”_loc + (), (c)) + + ) + +208 #ià +defšed + +__USE_SVID + || defšed +__USE_MISC + || defšed +__USE_XOPEN + + +209 + #i§scii +( +c +è + `__i§scii + (c) + + ) + +210 + #tßscii +( +c +è + `__tßscii + (c) + + ) + +212 + #_tÞow” +( +c +è((è(* + `__ùy³_tÞow”_loc + ())[(è(c)]) + + ) + +213 + #_touµ” +( +c +è((è(* + `__ùy³_touµ”_loc + ())[(è(c)]) + + ) + +219 #ifdeà +__USE_XOPEN2K8 + + +233 + ~<xloÿË.h +> + +237 + #__isùy³_l +( +c +, +ty³ +, +loÿË +) \ + +238 (( +loÿË +)-> +__ùy³_b +[(è( +c +)] & ( è +ty³ +) + + ) + +240 + #__exùy³_l +( +Çme +) \ + +241
+ `Çme + (, +__loÿË_t +è +__THROW + + + ) + +247 +__exùy³_l + ( +i§Êum_l +); + +248 +__exùy³_l + ( +i§Íha_l +); + +249 +__exùy³_l + ( +isúŒl_l +); + +250 +__exùy³_l + ( +isdig™_l +); + +251 +__exùy³_l + ( +i¦ow”_l +); + +252 +__exùy³_l + ( +isg¿ph_l +); + +253 +__exùy³_l + ( +i¥ršt_l +); + +254 +__exùy³_l + ( +i¥unù_l +); + +255 +__exùy³_l + ( +is¥aû_l +); + +256 +__exùy³_l + ( +isuµ”_l +); + +257 +__exùy³_l + ( +isxdig™_l +); + +259 +__exùy³_l + ( +isbÏnk_l +); + +263
+ $__tÞow”_l + ( +__c +, +__loÿË_t + +__l +è +__THROW +; + +264
+ $tÞow”_l + ( +__c +, +__loÿË_t + +__l +è +__THROW +; + +267
+ $__touµ”_l + ( +__c +, +__loÿË_t + +__l +è +__THROW +; + +268
+ $touµ”_l + ( +__c +, +__loÿË_t + +__l +è +__THROW +; + +270 #ià +__GNUC__ + >ð2 && +defšed + +__OPTIMIZE__ + && !defšed +__ýlu¥lus + + +271 + #__tÞow”_l +( +c +, +loÿË +) \ + +272 + `__tobody + ( +c +, +__tÞow”_l +, ( +loÿË +)-> +__ùy³_tÞow” +, (c,†oÿË)) + + ) + +273 + #__touµ”_l +( +c +, +loÿË +) \ + +274 + `__tobody + ( +c +, +__touµ”_l +, ( +loÿË +)-> +__ùy³_touµ” +, (c,†oÿË)) + + ) + +275 + #tÞow”_l +( +c +, +loÿË +è + `__tÞow”_l + ((c), (loÿË)) + + ) + +276 + #touµ”_l +( +c +, +loÿË +è + `__touµ”_l + ((c), (loÿË)) + + ) + +280 #iâdeà +__NO_CTYPE + + +281 + #__i§Êum_l +( +c +, +l +è + `__isùy³_l +((c), +_IS®num +, (l)) + + ) + +282 + #__i§Íha_l +( +c +, +l +è + `__isùy³_l +((c), +_IS®pha +, (l)) + + ) + +283 + #__isúŒl_l +( +c +, +l +è + `__isùy³_l +((c), +_ISúŒl +, (l)) + + ) + +284 + #__isdig™_l +( +c +, +l +è + `__isùy³_l +((c), +_ISdig™ +, (l)) + + ) + +285 + #__i¦ow”_l +( +c +, +l +è + `__isùy³_l +((c), +_ISlow” +, (l)) + + ) + +286 + #__isg¿ph_l +( +c +, +l +è + `__isùy³_l +((c), +_ISg¿ph +, (l)) + + ) + +287 + #__i¥ršt_l +( +c +, +l +è + `__isùy³_l +((c), +_IS´št +, (l)) + + ) + +288 + #__i¥unù_l +( +c +, +l +è + `__isùy³_l +((c), +_ISpunù +, (l)) + + ) + +289 + #__is¥aû_l +( +c +, +l +è + `__isùy³_l +((c), +_IS¥aû +, (l)) + + ) + +290 + #__isuµ”_l +( +c +, +l +è + `__isùy³_l +((c), +_ISuµ” +, (l)) + + ) + +291 + #__isxdig™_l +( +c +, +l +è + `__isùy³_l +((c), +_ISxdig™ +, (l)) + + ) + +293 + #__isbÏnk_l +( +c +, +l +è + `__isùy³_l +((c), +_ISbÏnk +, (l)) + + ) + +295 #ià +defšed + +__USE_SVID + || defšed +__USE_MISC + + +296 + #__i§scii_l +( +c +, +l +è(Ö), + `__i§scii + (c)) + + ) + +297 + #__tßscii_l +( +c +, +l +è(Ö), + `__tßscii + (c)) + + ) + +300 + #i§Êum_l +( +c +, +l +è + `__i§Êum_l + ((c), (l)) + + ) + +301 + #i§Íha_l +( +c +, +l +è + `__i§Íha_l + ((c), (l)) + + ) + +302 + #isúŒl_l +( +c +, +l +è + `__isúŒl_l + ((c), (l)) + + ) + +303 + #isdig™_l +( +c +, +l +è + `__isdig™_l + ((c), (l)) + + ) + +304 + #i¦ow”_l +( +c +, +l +è + `__i¦ow”_l + ((c), (l)) + + ) + +305 + #isg¿ph_l +( +c +, +l +è + `__isg¿ph_l + ((c), (l)) + + ) + +306 + #i¥ršt_l +( +c +, +l +è + `__i¥ršt_l + ((c), (l)) + + ) + +307 + #i¥unù_l +( +c +, +l +è + `__i¥unù_l + ((c), (l)) + + ) + +308 + #is¥aû_l +( +c +, +l +è + `__is¥aû_l + ((c), (l)) + + ) + +309 + #isuµ”_l +( +c +, +l +è + `__isuµ”_l + ((c), (l)) + + ) + +310 + #isxdig™_l +( +c +, +l +è + `__isxdig™_l + ((c), (l)) + + ) + +312 + #isbÏnk_l +( +c +, +l +è + `__isbÏnk_l + ((c), (l)) + + ) + +314 #ià +defšed + +__USE_SVID + || defšed +__USE_MISC + + +315 + #i§scii_l +( +c +, +l +è + `__i§scii_l + ((c), (l)) + + ) + +316 + #tßscii_l +( +c +, +l +è + `__tßscii_l + ((c), (l)) + + ) + +323 +__END_DECLS + + + @/usr/include/endian.h + +19 #iâdef +_ENDIAN_H + + +20 + #_ENDIAN_H + 1 + + ) + +22 + ~<ã©u»s.h +> + +32 + #__LITTLE_ENDIAN + 1234 + + ) + +33 + #__BIG_ENDIAN + 4321 + + ) + +34 + #__PDP_ENDIAN + 3412 + + ) + +37 + ~<b™s/’dŸn.h +> + +41 #iâdeà +__FLOAT_WORD_ORDER + + +42 + #__FLOAT_WORD_ORDER + +__BYTE_ORDER + + + ) + +45 #ifdef +__USE_BSD + + +46 + #LITTLE_ENDIAN + +__LITTLE_ENDIAN + + + ) + +47 + #BIG_ENDIAN + +__BIG_ENDIAN + + + ) + +48 + #PDP_ENDIAN + +__PDP_ENDIAN + + + ) + +49 + #BYTE_ORDER + +__BYTE_ORDER + + + ) + +52 #ià +__BYTE_ORDER + =ð +__LITTLE_ENDIAN + + +53 + #__LONG_LONG_PAIR +( +HI +, +LO +èLO, + ) +HI + +54 #–ià +__BYTE_ORDER + =ð +__BIG_ENDIAN + + +55 + #__LONG_LONG_PAIR +( +HI +, +LO +èHI, + ) +LO + +59 #ifdeà +__USE_BSD + + +61 + ~<b™s/by‹sw.h +> + +63 #ià +__BYTE_ORDER + =ð +__LITTLE_ENDIAN + + +64 + #htobe16 +( +x +è + `__bsw_16 + (x) + + ) + +65 + #htÞe16 +( +x +è(x) + + ) + +66 + #be16toh +( +x +è + `__bsw_16 + (x) + + ) + +67 + #Ë16toh +( +x +è(x) + + ) + +69 + #htobe32 +( +x +è + `__bsw_32 + (x) + + ) + +70 + #htÞe32 +( +x +è(x) + + ) + +71 + #be32toh +( +x +è + `__bsw_32 + (x) + + ) + +72 + #Ë32toh +( +x +è(x) + + ) + +74 + #htobe64 +( +x +è + `__bsw_64 + (x) + + ) + +75 + #htÞe64 +( +x +è(x) + + ) + +76 + #be64toh +( +x +è + `__bsw_64 + (x) + + ) + +77 + #Ë64toh +( +x +è(x) + + ) + +79 + #htobe16 +( +x +è(x) + + ) + +80 + #htÞe16 +( +x +è + `__bsw_16 + (x) + + ) + +81 + #be16toh +( +x +è(x) + + ) + +82 + #Ë16toh +( +x +è + `__bsw_16 + (x) + + ) + +84 + #htobe32 +( +x +è(x) + + ) + +85 + #htÞe32 +( +x +è + `__bsw_32 + (x) + + ) + +86 + #be32toh +( +x +è(x) + + ) + +87 + #Ë32toh +( +x +è + `__bsw_32 + (x) + + ) + +89 + #htobe64 +( +x +è(x) + + ) + +90 + #htÞe64 +( +x +è + `__bsw_64 + (x) + + ) + +91 + #be64toh +( +x +è(x) + + ) + +92 + #Ë64toh +( +x +è + `__bsw_64 + (x) + + ) + + @/usr/include/gnu/stubs.h + +4 + ~<b™s/wÜdsize.h +> + +6 #ià +__WORDSIZE + == 32 + +7 + ~<gnu/¡ubs-32.h +> + +8 #–ià +__WORDSIZE + == 64 + +9 + ~<gnu/¡ubs-64.h +> + + @/usr/include/stdlib.h + +23 #iâdef +_STDLIB_H + + +25 + ~<ã©u»s.h +> + +28 + #__Ãed_size_t + + + ) + +29 #iâdeà +__Ãed_m®loc_ªd_ÿÎoc + + +30 + #__Ãed_wch¬_t + + + ) + +31 + #__Ãed_NULL + + + ) + +33 + ~<¡ddef.h +> + +35 + g__BEGIN_DECLS + + +37 #iâdeà +__Ãed_m®loc_ªd_ÿÎoc + + +38 + #_STDLIB_H + 1 + + ) + +40 #ià +defšed + +__USE_XOPEN + && !defšed +_SYS_WAIT_H + + +42 + ~<b™s/wa™æags.h +> + +43 + ~<b™s/wa™¡©us.h +> + +45 #ifdeà +__USE_BSD + + +50 #ià +defšed + +__GNUC__ + && !defšed +__ýlu¥lus + + +51 + #__WAIT_INT +( +¡©us +) \ + +52 ( + `__ex‹nsiÚ__ + (((uniÚ { + `__ty³of +( +¡©us +è +__š +; +__i +; }) \ + +53 { . +__š + = ( +¡©us +è}). +__i +)) + + ) + +55 + #__WAIT_INT +( +¡©us +è(*(*è&(¡©us)) + + ) + +63 #ià! +defšed + +__GNUC__ + || __GNUC__ < 2 || defšed +__ýlu¥lus + + +64 + #__WAIT_STATUS + * + + ) + +65 + #__WAIT_STATUS_DEFN + * + + ) + +70 +wa™ + * + m__u±r +; + +71 * + m__Œ +; + +72 } + t__WAIT_STATUS + + t__©Œibu‹__ + (( + t__Œª¥¬’t_uniÚ__ +)); + +73 + #__WAIT_STATUS_DEFN + * + + ) + +78 + #__WAIT_INT +( +¡©us +è(¡©us) + + ) + +79 + #__WAIT_STATUS + * + + ) + +80 + #__WAIT_STATUS_DEFN + * + + ) + +85 + #WEXITSTATUS +( +¡©us +è + `__WEXITSTATUS + ( + `__WAIT_INT + (¡©us)) + + ) + +86 + #WTERMSIG +( +¡©us +è + `__WTERMSIG + ( + `__WAIT_INT + (¡©us)) + + ) + +87 + #WSTOPSIG +( +¡©us +è + `__WSTOPSIG + ( + `__WAIT_INT + (¡©us)) + + ) + +88 + #WIFEXITED +( +¡©us +è + `__WIFEXITED + ( + `__WAIT_INT + (¡©us)) + + ) + +89 + #WIFSIGNALED +( +¡©us +è + `__WIFSIGNALED + ( + `__WAIT_INT + (¡©us)) + + ) + +90 + #WIFSTOPPED +( +¡©us +è + `__WIFSTOPPED + ( + `__WAIT_INT + (¡©us)) + + ) + +91 #ifdeà +__WIFCONTINUED + + +92 + #WIFCONTINUED +( +¡©us +è + `__WIFCONTINUED + ( + `__WAIT_INT + (¡©us)) + + ) + +96 +__BEGIN_NAMESPACE_STD + + +100 + mquÙ +; + +101 + m»m +; + +102 } + tdiv_t +; + +105 #iâdeà +__ldiv_t_defšed + + +108 + mquÙ +; + +109 + m»m +; + +110 } + tldiv_t +; + +111 + #__ldiv_t_defšed + 1 + + ) + +113 + g__END_NAMESPACE_STD + + +115 #ià +defšed + +__USE_ISOC99 + && !defšed +__Îdiv_t_defšed + + +116 +__BEGIN_NAMESPACE_C99 + + +118 +__ex‹nsiÚ__ + struct + +120 + mquÙ +; + +121 + m»m +; + +122 } + tÎdiv_t +; + +123 + #__Îdiv_t_defšed + 1 + + ) + +124 + g__END_NAMESPACE_C99 + + +129 + #RAND_MAX + 2147483647 + + ) + +134 + #EXIT_FAILURE + 1 + + ) + +135 + #EXIT_SUCCESS + 0 + + ) + +139 + #MB_CUR_MAX + ( + `__ùy³_g‘_mb_cur_max + ()) + + ) + +140
+size_t + + $__ùy³_g‘_mb_cur_max + ( è +__THROW + +__wur +; + +143 +__BEGIN_NAMESPACE_STD + + +145
+ $©of + ( +__cÚ¡ + * +__ÅŒ +) + +146 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)è +__wur +; + +148
+ $©oi + ( +__cÚ¡ + * +__ÅŒ +) + +149 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)è +__wur +; + +151
+ $©Þ + ( +__cÚ¡ + * +__ÅŒ +) + +152 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)è +__wur +; + +153 +__END_NAMESPACE_STD + + +155 #ià +defšed + +__USE_ISOC99 + || (defšed +__GLIBC_HAVE_LONG_LONG + && defšed +__USE_MISC +) + +156 +__BEGIN_NAMESPACE_C99 + + +158 +__ex‹nsiÚ__ +
+ $©Þl + ( +__cÚ¡ + * +__ÅŒ +) + +159 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)è +__wur +; + +160 +__END_NAMESPACE_C99 + + +163 +__BEGIN_NAMESPACE_STD + + +165
+ $¡¹od + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +166 ** +__»¡riù + +__’d±r +) + +167 +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +168 +__END_NAMESPACE_STD + + +170 #ifdef +__USE_ISOC99 + + +171 +__BEGIN_NAMESPACE_C99 + + +173
+ $¡¹of + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +174 ** +__»¡riù + +__’d±r +è +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +176
+ $¡¹Þd + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +177 ** +__»¡riù + +__’d±r +) + +178 +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +179 +__END_NAMESPACE_C99 + + +182 +__BEGIN_NAMESPACE_STD + + +184
+ $¡¹Þ + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +185 ** +__»¡riù + +__’d±r +, +__ba£ +) + +186 +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +188
+ $¡¹oul + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +189 ** +__»¡riù + +__’d±r +, +__ba£ +) + +190 +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +191 +__END_NAMESPACE_STD + + +193 #ià +defšed + +__GLIBC_HAVE_LONG_LONG + && defšed +__USE_BSD + + +195 +__ex‹nsiÚ__ + + +196
+ $¡¹oq + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +197 ** +__»¡riù + +__’d±r +, +__ba£ +) + +198 +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +200 +__ex‹nsiÚ__ + + +201
+ $¡¹ouq + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +202 ** +__»¡riù + +__’d±r +, +__ba£ +) + +203 +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +206 #ià +defšed + +__USE_ISOC99 + || (defšed +__GLIBC_HAVE_LONG_LONG + && defšed +__USE_MISC +) + +207 +__BEGIN_NAMESPACE_C99 + + +209 +__ex‹nsiÚ__ + + +210
+ $¡¹Þl + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +211 ** +__»¡riù + +__’d±r +, +__ba£ +) + +212 +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +214 +__ex‹nsiÚ__ + + +215
+ $¡¹ouÎ + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +216 ** +__»¡riù + +__’d±r +, +__ba£ +) + +217 +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +218 +__END_NAMESPACE_C99 + + +222 #ifdeà +__USE_GNU + + +236 + ~<xloÿË.h +> + +240
+ $¡¹Þ_l + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +241 ** +__»¡riù + +__’d±r +, +__ba£ +, + +242 +__loÿË_t + +__loc +è +__THROW + + `__nÚnuÎ + ((1, 4)è +__wur +; + +244
+ $¡¹oul_l + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +245 ** +__»¡riù + +__’d±r +, + +246 +__ba£ +, +__loÿË_t + +__loc +) + +247 +__THROW + + `__nÚnuÎ + ((1, 4)è +__wur +; + +249 +__ex‹nsiÚ__ + + +250
+ $¡¹Þl_l + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +251 ** +__»¡riù + +__’d±r +, +__ba£ +, + +252 +__loÿË_t + +__loc +) + +253 +__THROW + + `__nÚnuÎ + ((1, 4)è +__wur +; + +255 +__ex‹nsiÚ__ + + +256
+ $¡¹ouÎ_l + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +257 ** +__»¡riù + +__’d±r +, + +258 +__ba£ +, +__loÿË_t + +__loc +) + +259 +__THROW + + `__nÚnuÎ + ((1, 4)è +__wur +; + +261
+ $¡¹od_l + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +262 ** +__»¡riù + +__’d±r +, +__loÿË_t + +__loc +) + +263 +__THROW + + `__nÚnuÎ + ((1, 3)è +__wur +; + +265
+ $¡¹of_l + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +266 ** +__»¡riù + +__’d±r +, +__loÿË_t + +__loc +) + +267 +__THROW + + `__nÚnuÎ + ((1, 3)è +__wur +; + +269
+ $¡¹Þd_l + ( +__cÚ¡ + * +__»¡riù + +__ÅŒ +, + +270 ** +__»¡riù + +__’d±r +, + +271 +__loÿË_t + +__loc +) + +272 +__THROW + + `__nÚnuÎ + ((1, 3)è +__wur +; + +276 #ifdeà +__USE_EXTERN_INLINES + + +277 +__BEGIN_NAMESPACE_STD + + +278 +__ex‹º_šlše + + +279 + `__NTH + ( + $©of + ( +__cÚ¡ + * +__ÅŒ +)) + +281 + `¡¹od + ( +__ÅŒ +, (**è +NULL +); + +282 + } +} + +283 +__ex‹º_šlše + + +284 +__NTH + ( + $©oi + ( +__cÚ¡ + * +__ÅŒ +)) + +286 (è + `¡¹Þ + ( +__ÅŒ +, (**è +NULL +, 10); + +287 + } +} + +288 +__ex‹º_šlše + + +289 +__NTH + ( + $©Þ + ( +__cÚ¡ + * +__ÅŒ +)) + +291 + `¡¹Þ + ( +__ÅŒ +, (**è +NULL +, 10); + +292 + } +} + +293 + g__END_NAMESPACE_STD + + +295 #ià +defšed + +__USE_MISC + || defšed +__USE_ISOC99 + + +296 +__BEGIN_NAMESPACE_C99 + + +297 +__ex‹nsiÚ__ + +__ex‹º_šlše + + +298 +__NTH + ( + $©Þl + ( +__cÚ¡ + * +__ÅŒ +)) + +300 + `¡¹Þl + ( +__ÅŒ +, (**è +NULL +, 10); + +301 + } +} + +302 + g__END_NAMESPACE_C99 + + +307 #ià +defšed + +__USE_SVID + || defšed +__USE_XOPEN_EXTENDED + + +311
* + $l64a + ( +__n +è +__THROW + +__wur +; + +314
+ $a64l + ( +__cÚ¡ + * +__s +) + +315 +__THROW + +__©Œibu‹_pu»__ + + `__nÚnuÎ + ((1)è +__wur +; + +319 #ià +defšed + +__USE_SVID + || defšed +__USE_XOPEN_EXTENDED + || defšed +__USE_BSD + + +320 + ~<sys/ty³s.h +> + +327
+ $¿ndom + ( è +__THROW +; + +330
+ $¤ªdom + ( +__£ed +è +__THROW +; + +336
* + $š™¡©e + ( +__£ed +, * +__¡©ebuf +, + +337 +size_t + +__¡©–’ +è +__THROW + + `__nÚnuÎ + ((2)); + +341
* + $£t¡©e + (* +__¡©ebuf +è +__THROW + + `__nÚnuÎ + ((1)); + +344 #ifdeà +__USE_MISC + + +349 + s¿ndom_d©a + + +351 +št32_t + * +åŒ +; + +352 +št32_t + * +½Œ +; + +353 +št32_t + * +¡©e +; + +354 +¿nd_ty³ +; + +355 +¿nd_deg +; + +356 +¿nd_£p +; + +357 +št32_t + * +’d_±r +; + +360
+ $¿ndom_r + ( +¿ndom_d©a + * +__»¡riù + +__buf +, + +361 +št32_t + * +__»¡riù + +__»suÉ +è +__THROW + + `__nÚnuÎ + ((1, 2)); + +363
+ $¤ªdom_r + ( +__£ed +, +¿ndom_d©a + * +__buf +) + +364 +__THROW + + `__nÚnuÎ + ((2)); + +366
+ $š™¡©e_r + ( +__£ed +, * +__»¡riù + +__¡©ebuf +, + +367 +size_t + +__¡©–’ +, + +368 +¿ndom_d©a + * +__»¡riù + +__buf +) + +369 +__THROW + + `__nÚnuÎ + ((2, 4)); + +371
+ $£t¡©e_r + (* +__»¡riù + +__¡©ebuf +, + +372 +¿ndom_d©a + * +__»¡riù + +__buf +) + +373 +__THROW + + `__nÚnuÎ + ((1, 2)); + +378 +__BEGIN_NAMESPACE_STD + + +380
+ $¿nd + ( è +__THROW +; + +382
+ $¤ªd + ( +__£ed +è +__THROW +; + +383 +__END_NAMESPACE_STD + + +385 #ifdeà +__USE_POSIX + + +387
+ $¿nd_r + ( * +__£ed +è +__THROW +; + +391 #ià +defšed + +__USE_SVID + || defšed +__USE_XOPEN + + +395
+ $d¿nd48 + ( è +__THROW +; + +396
+ $”ªd48 + ( +__xsubi +[3]è +__THROW + + `__nÚnuÎ + ((1)); + +399
+ $̪d48 + ( è +__THROW +; + +400
+ $Īd48 + ( +__xsubi +[3]) + +401 +__THROW + + `__nÚnuÎ + ((1)); + +404
+ $m¿nd48 + ( è +__THROW +; + +405
+ $j¿nd48 + ( +__xsubi +[3]) + +406 +__THROW + + `__nÚnuÎ + ((1)); + +409
+ $¤ªd48 + ( +__£edv® +è +__THROW +; + +410
* + $£ed48 + ( +__£ed16v +[3]) + +411 +__THROW + + `__nÚnuÎ + ((1)); + +412
+ $lcÚg48 + ( +__·¿m +[7]è +__THROW + + `__nÚnuÎ + ((1)); + +414 #ifdeà +__USE_MISC + + +418 + sd¿nd48_d©a + + +420 +__x +[3]; + +421 +__Þd_x +[3]; + +422 +__c +; + +423 +__š™ +; + +424 +__a +; + +428
+ $d¿nd48_r + ( +d¿nd48_d©a + * +__»¡riù + +__bufãr +, + +429 * +__»¡riù + +__»suÉ +è +__THROW + + `__nÚnuÎ + ((1, 2)); + +430
+ $”ªd48_r + ( +__xsubi +[3], + +431 +d¿nd48_d©a + * +__»¡riù + +__bufãr +, + +432 * +__»¡riù + +__»suÉ +è +__THROW + + `__nÚnuÎ + ((1, 2)); + +435
+ $̪d48_r + ( +d¿nd48_d©a + * +__»¡riù + +__bufãr +, + +436 * +__»¡riù + +__»suÉ +) + +437 +__THROW + + `__nÚnuÎ + ((1, 2)); + +438
+ $Īd48_r + ( +__xsubi +[3], + +439 +d¿nd48_d©a + * +__»¡riù + +__bufãr +, + +440 * +__»¡riù + +__»suÉ +) + +441 +__THROW + + `__nÚnuÎ + ((1, 2)); + +444
+ $m¿nd48_r + ( +d¿nd48_d©a + * +__»¡riù + +__bufãr +, + +445 * +__»¡riù + +__»suÉ +) + +446 +__THROW + + `__nÚnuÎ + ((1, 2)); + +447
+ $j¿nd48_r + ( +__xsubi +[3], + +448 +d¿nd48_d©a + * +__»¡riù + +__bufãr +, + +449 * +__»¡riù + +__»suÉ +) + +450 +__THROW + + `__nÚnuÎ + ((1, 2)); + +453
+ $¤ªd48_r + ( +__£edv® +, +d¿nd48_d©a + * +__bufãr +) + +454 +__THROW + + `__nÚnuÎ + ((2)); + +456
+ $£ed48_r + ( +__£ed16v +[3], + +457 +d¿nd48_d©a + * +__bufãr +è +__THROW + + `__nÚnuÎ + ((1, 2)); + +459
+ $lcÚg48_r + ( +__·¿m +[7], + +460 +d¿nd48_d©a + * +__bufãr +) + +461 +__THROW + + `__nÚnuÎ + ((1, 2)); + +467 #iâdeà +__m®loc_ªd_ÿÎoc_defšed + + +468 + #__m®loc_ªd_ÿÎoc_defšed + + + ) + +469 +__BEGIN_NAMESPACE_STD + + +471
* + $m®loc + ( +size_t + +__size +è +__THROW + +__©Œibu‹_m®loc__ + +__wur +; + +473
* + $ÿÎoc + ( +size_t + +__nmemb +, size_ˆ +__size +) + +474 +__THROW + +__©Œibu‹_m®loc__ + +__wur +; + +475 +__END_NAMESPACE_STD + + +478 #iâdeà +__Ãed_m®loc_ªd_ÿÎoc + + +479 +__BEGIN_NAMESPACE_STD + + +485
* + $»®loc + ( * +__±r +, +size_t + +__size +) + +486 +__THROW + +__©Œibu‹_w¬n_unu£d_»suÉ__ +; + +488
+ $ä“ + ( * +__±r +è +__THROW +; + +489 +__END_NAMESPACE_STD + + +491 #ifdef +__USE_MISC + + +493
+ $cä“ + ( * +__±r +è +__THROW +; + +496 #ià +defšed + +__USE_GNU + || defšed +__USE_BSD + || defšed +__USE_MISC + + +497 + ~<®loÿ.h +> + +500 #ià +defšed + +__USE_BSD + || defšed +__USE_XOPEN_EXTENDED + + +502
* + $v®loc + ( +size_t + +__size +è +__THROW + +__©Œibu‹_m®loc__ + +__wur +; + +505 #ifdeà +__USE_XOPEN2K + + +507
+ $posix_mem®ign + ( ** +__mem±r +, +size_t + +__®ignm’t +, size_ˆ +__size +) + +508 +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +511 +__BEGIN_NAMESPACE_STD + + +513
+ $abÜt + ( è +__THROW + + `__©Œibu‹__ + (( +__nÜ‘uº__ +)); + +517
+ `©ex™ + ( (* +__func +è( )è +__THROW + + `__nÚnuÎ + ((1)); + +519 #ifdeà +__USE_GNU + + +523 #ifdeà +__ýlu¥lus + + +524
"C++" + `©_quick_ex™ + ( (* +__func +) ( )) + +525 +__THROW + + `__asm + ("©_quick_ex™"è + `__nÚnuÎ + ((1)); + +527
+ `©_quick_ex™ + ( (* +__func +è( )è +__THROW + + `__nÚnuÎ + ((1)); + +530 +__END_NAMESPACE_STD + + +532 #ifdef +__USE_MISC + + +535
+ `Ú_ex™ + ( (* +__func +è( +__¡©us +, * +__¬g +), *__arg) + +536 +__THROW + + `__nÚnuÎ + ((1)); + +539 +__BEGIN_NAMESPACE_STD + + +543
+ $ex™ + ( +__¡©us +è +__THROW + + `__©Œibu‹__ + (( +__nÜ‘uº__ +)); + +545 #ifdeà +__USE_GNU + + +551
+ $quick_ex™ + ( +__¡©us +è +__THROW + + `__©Œibu‹__ + (( +__nÜ‘uº__ +)); + +553 +__END_NAMESPACE_STD + + +555 #ifdeà +__USE_ISOC99 + + +556 +__BEGIN_NAMESPACE_C99 + + +559
+ $_Ex™ + ( +__¡©us +è +__THROW + + `__©Œibu‹__ + (( +__nÜ‘uº__ +)); + +560 +__END_NAMESPACE_C99 + + +564 +__BEGIN_NAMESPACE_STD + + +566
* + $g‘’v + ( +__cÚ¡ + * +__Çme +è +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +567 +__END_NAMESPACE_STD + + +571
* + $__£cu»_g‘’v + ( +__cÚ¡ + * +__Çme +) + +572 +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +574 #ià +defšed + +__USE_SVID + || defšed +__USE_XOPEN + + +578
+ $pu‹nv + (* +__¡ršg +è +__THROW + + `__nÚnuÎ + ((1)); + +581 #ià +defšed + +__USE_BSD + || defšed +__USE_XOPEN2K + + +584
+ $£‹nv + ( +__cÚ¡ + * +__Çme +, __cÚ¡ * +__v®ue +, +__»¶aû +) + +585 +__THROW + + `__nÚnuÎ + ((2)); + +588
+ $un£‹nv + ( +__cÚ¡ + * +__Çme +è +__THROW +; + +591 #ifdef +__USE_MISC + + +595
+ $þ—»nv + ( è +__THROW +; + +599 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN_EXTENDED + + +604
* + $mk‹mp + (* +__‹m¶©e +è +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +614 #iâdeà +__USE_FILE_OFFSET64 + + +615
+ $mk¡emp + (* +__‹m¶©e +è + `__nÚnuÎ + ((1)è +__wur +; + +617 #ifdeà +__REDIRECT + + +618
+ `__REDIRECT + ( +mk¡emp +, (* +__‹m¶©e +), +mk¡emp64 +) + +619 + `__nÚnuÎ + ((1)è +__wur +; + +621 + #mk¡emp + +mk¡emp64 + + + ) + +624 #ifdeà +__USE_LARGEFILE64 + + +625
+ $mk¡emp64 + (* +__‹m¶©e +è + `__nÚnuÎ + ((1)è +__wur +; + +629 #ifdeà +__USE_MISC + + +636 #iâdeà +__USE_FILE_OFFSET64 + + +637
+ $mk¡emps + (* +__‹m¶©e +, +__suffixËn +è + `__nÚnuÎ + ((1)è +__wur +; + +639 #ifdeà +__REDIRECT + + +640
+ `__REDIRECT + ( +mk¡emps +, (* +__‹m¶©e +, +__suffixËn +), + +641 +mk¡emps64 +è + `__nÚnuÎ + ((1)è +__wur +; + +643 + #mk¡emps + +mk¡emps64 + + + ) + +646 #ifdeà +__USE_LARGEFILE64 + + +647
+ $mk¡emps64 + (* +__‹m¶©e +, +__suffixËn +) + +648 + `__nÚnuÎ + ((1)è +__wur +; + +652 #ià +defšed + +__USE_BSD + || defšed +__USE_XOPEN2K8 + + +658
* + $mkd‹mp + (* +__‹m¶©e +è +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +661 #ifdeà +__USE_GNU + + +668 #iâdeà +__USE_FILE_OFFSET64 + + +669
+ $mko¡emp + (* +__‹m¶©e +, +__æags +è + `__nÚnuÎ + ((1)è +__wur +; + +671 #ifdeà +__REDIRECT + + +672
+ `__REDIRECT + ( +mko¡emp +, (* +__‹m¶©e +, +__æags +), +mko¡emp64 +) + +673 + `__nÚnuÎ + ((1)è +__wur +; + +675 + #mko¡emp + +mko¡emp64 + + + ) + +678 #ifdeà +__USE_LARGEFILE64 + + +679
+ $mko¡emp64 + (* +__‹m¶©e +, +__æags +è + `__nÚnuÎ + ((1)è +__wur +; + +688 #iâdeà +__USE_FILE_OFFSET64 + + +689
+ $mko¡emps + (* +__‹m¶©e +, +__suffixËn +, +__æags +) + +690 + `__nÚnuÎ + ((1)è +__wur +; + +692 #ifdeà +__REDIRECT + + +693
+ `__REDIRECT + ( +mko¡emps +, (* +__‹m¶©e +, +__suffixËn +, + +694 +__æags +), +mko¡emps64 +) + +695 + `__nÚnuÎ + ((1)è +__wur +; + +697 + #mko¡emps + +mko¡emps64 + + + ) + +700 #ifdeà +__USE_LARGEFILE64 + + +701
+ $mko¡emps64 + (* +__‹m¶©e +, +__suffixËn +, +__æags +) + +702 + `__nÚnuÎ + ((1)è +__wur +; + +707 +__BEGIN_NAMESPACE_STD + + +712
+ $sy¡em + ( +__cÚ¡ + * +__commªd +è +__wur +; + +713 +__END_NAMESPACE_STD + + +716 #ifdef +__USE_GNU + + +719
* + $ÿnÚiÿlize_fže_Çme + ( +__cÚ¡ + * +__Çme +) + +720 +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +723 #ià +defšed + +__USE_BSD + || defšed +__USE_XOPEN_EXTENDED + + +729
* + $»®·th + ( +__cÚ¡ + * +__»¡riù + +__Çme +, + +730 * +__»¡riù + +__»sÞved +è +__THROW + +__wur +; + +735 #iâdeà +__COMPAR_FN_T + + +736 + #__COMPAR_FN_T + + + ) + +737 (* + t__com·r_â_t +è( + t__cÚ¡ + *, __const *); + +739 #ifdef +__USE_GNU + + +740 +__com·r_â_t + + tcom·risÚ_â_t +; + +743 #ifdeà +__USE_GNU + + +744 (* + t__com·r_d_â_t +è( + t__cÚ¡ + *, __const *, *); + +747 +__BEGIN_NAMESPACE_STD + + +750
* + $b£¬ch + ( +__cÚ¡ + * +__key +, __cÚ¡ * +__ba£ +, + +751 +size_t + +__nmemb +, size_ˆ +__size +, +__com·r_â_t + +__com·r +) + +752 + `__nÚnuÎ + ((1, 2, 5)è +__wur +; + +756
+ $qsÜt + ( * +__ba£ +, +size_t + +__nmemb +, size_ˆ +__size +, + +757 +__com·r_â_t + +__com·r +è + `__nÚnuÎ + ((1, 4)); + +758 #ifdeà +__USE_GNU + + +759
+ $qsÜt_r + ( * +__ba£ +, +size_t + +__nmemb +, size_ˆ +__size +, + +760 +__com·r_d_â_t + +__com·r +, * +__¬g +) + +761 + `__nÚnuÎ + ((1, 4)); + +766
+ $abs + ( +__x +è +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)è +__wur +; + +767
+ $Ïbs + ( +__x +è +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)è +__wur +; + +768 +__END_NAMESPACE_STD + + +770 #ifdeà +__USE_ISOC99 + + +771 +__ex‹nsiÚ__ +
+ $Îabs + ( +__x +) + +772 +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)è +__wur +; + +776 +__BEGIN_NAMESPACE_STD + + +780
+div_t + + $div + ( +__num” +, +__d’om +) + +781 +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)è +__wur +; + +782
+ldiv_t + + $ldiv + ( +__num” +, +__d’om +) + +783 +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)è +__wur +; + +784 +__END_NAMESPACE_STD + + +786 #ifdeà +__USE_ISOC99 + + +787 +__BEGIN_NAMESPACE_C99 + + +788 +__ex‹nsiÚ__ +
+Îdiv_t + + $Îdiv + ( +__num” +, + +789 +__d’om +) + +790 +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)è +__wur +; + +791 +__END_NAMESPACE_C99 + + +795 #ià +defšed + +__USE_SVID + || defšed +__USE_XOPEN_EXTENDED + + +802
* + $ecvt + ( +__v®ue +, +__ndig™ +, * +__»¡riù + +__deýt +, + +803 * +__»¡riù + +__sign +è +__THROW + + `__nÚnuÎ + ((3, 4)è +__wur +; + +808
* + $fcvt + ( +__v®ue +, +__ndig™ +, * +__»¡riù + +__deýt +, + +809 * +__»¡riù + +__sign +è +__THROW + + `__nÚnuÎ + ((3, 4)è +__wur +; + +814
* + $gcvt + ( +__v®ue +, +__ndig™ +, * +__buf +) + +815 +__THROW + + `__nÚnuÎ + ((3)è +__wur +; + +818 #ifdeà +__USE_MISC + + +820
* + $qecvt + ( +__v®ue +, +__ndig™ +, + +821 * +__»¡riù + +__deýt +, *__»¡riù +__sign +) + +822 +__THROW + + `__nÚnuÎ + ((3, 4)è +__wur +; + +823
* + $qfcvt + ( +__v®ue +, +__ndig™ +, + +824 * +__»¡riù + +__deýt +, *__»¡riù +__sign +) + +825 +__THROW + + `__nÚnuÎ + ((3, 4)è +__wur +; + +826
* + $qgcvt + ( +__v®ue +, +__ndig™ +, * +__buf +) + +827 +__THROW + + `__nÚnuÎ + ((3)è +__wur +; + +832
+ $ecvt_r + ( +__v®ue +, +__ndig™ +, * +__»¡riù + +__deýt +, + +833 * +__»¡riù + +__sign +, *__»¡riù +__buf +, + +834 +size_t + +__Ën +è +__THROW + + `__nÚnuÎ + ((3, 4, 5)); + +835
+ $fcvt_r + ( +__v®ue +, +__ndig™ +, * +__»¡riù + +__deýt +, + +836 * +__»¡riù + +__sign +, *__»¡riù +__buf +, + +837 +size_t + +__Ën +è +__THROW + + `__nÚnuÎ + ((3, 4, 5)); + +839
+ $qecvt_r + ( +__v®ue +, +__ndig™ +, + +840 * +__»¡riù + +__deýt +, *__»¡riù +__sign +, + +841 * +__»¡riù + +__buf +, +size_t + +__Ën +) + +842 +__THROW + + `__nÚnuÎ + ((3, 4, 5)); + +843
+ $qfcvt_r + ( +__v®ue +, +__ndig™ +, + +844 * +__»¡riù + +__deýt +, *__»¡riù +__sign +, + +845 * +__»¡riù + +__buf +, +size_t + +__Ën +) + +846 +__THROW + + `__nÚnuÎ + ((3, 4, 5)); + +851 +__BEGIN_NAMESPACE_STD + + +854
+ $mbËn + ( +__cÚ¡ + * +__s +, +size_t + +__n +è +__THROW + +__wur +; + +857
+ $mbtowc + ( +wch¬_t + * +__»¡riù + +__pwc +, + +858 +__cÚ¡ + * +__»¡riù + +__s +, +size_t + +__n +è +__THROW + +__wur +; + +861
+ $wùomb + (* +__s +, +wch¬_t + +__wch¬ +è +__THROW + +__wur +; + +865
+size_t + + $mb¡owcs + ( +wch¬_t + * +__»¡riù + +__pwcs +, + +866 +__cÚ¡ + * +__»¡riù + +__s +, +size_t + +__n +è +__THROW +; + +868
+size_t + + $wc¡ombs + (* +__»¡riù + +__s +, + +869 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__pwcs +, +size_t + +__n +) + +870 +__THROW +; + +871 +__END_NAMESPACE_STD + + +874 #ifdeà +__USE_SVID + + +879
+ $½m©ch + ( +__cÚ¡ + * +__»¥Ú£ +è +__THROW + + `__nÚnuÎ + ((1)è +__wur +; + +883 #ifdeà +__USE_XOPEN_EXTENDED + + +890
+ $g‘subÝt + (** +__»¡riù + +__ÝtiÚp +, + +891 * +__cÚ¡ + * +__»¡riù + +__tok’s +, + +892 ** +__»¡riù + +__v®u• +) + +893 +__THROW + + `__nÚnuÎ + ((1, 2, 3)è +__wur +; + +897 #ifdeà +__USE_XOPEN + + +899
+ $£tkey + ( +__cÚ¡ + * +__key +è +__THROW + + `__nÚnuÎ + ((1)); + +905 #ifdeà +__USE_XOPEN2K + + +907
+ $posix_Ý’± + ( +__oæag +è +__wur +; + +910 #ifdeà +__USE_XOPEN + + +915
+ $g¿Á± + ( +__fd +è +__THROW +; + +919
+ $uÆock± + ( +__fd +è +__THROW +; + +924
* + $±¢ame + ( +__fd +è +__THROW + +__wur +; + +927 #ifdeà +__USE_GNU + + +931
+ $±¢ame_r + ( +__fd +, * +__buf +, +size_t + +__buæ’ +) + +932 +__THROW + + `__nÚnuÎ + ((2)); + +935
+ `g‘± + ( ); + +938 #ifdeà +__USE_BSD + + +942
+ $g‘lßdavg + ( +__lßdavg +[], +__ÃËm +) + +943 +__THROW + + `__nÚnuÎ + ((1)); + +948 #ià +__USE_FORTIFY_LEVEL + > 0 && +defšed + +__ex‹º_®ways_šlše + + +949 + ~<b™s/¡dlib.h +> + +951 #ifdeà +__LDBL_COMPAT + + +952 + ~<b™s/¡dlib-ldbl.h +> + +956 #undeà +__Ãed_m®loc_ªd_ÿÎoc + + +958 +__END_DECLS + + + @/usr/include/sys/cdefs.h + +20 #iâdef +_SYS_CDEFS_H + + +21 + #_SYS_CDEFS_H + 1 + + ) + +24 #iâdeà +_FEATURES_H + + +25 + ~<ã©u»s.h +> + +31 #ià +defšed + +__GNUC__ + && !defšed +__STDC__ + + +36 #undeà +__P + + +37 #undeà +__PMT + + +39 #ifdeà +__GNUC__ + + +46 #ià! +defšed + +__ýlu¥lus + && +__GNUC_PREREQ + (3, 3) + +47 + #__THROW + + `__©Œibu‹__ + (( +__nÙhrow__ +)) + + ) + +48 + #__NTH +( +fù +è + `__©Œibu‹__ + (( +__nÙhrow__ +)è + ) +fct + +50 #ià +defšed + +__ýlu¥lus + && +__GNUC_PREREQ + (2,8) + +51 + #__THROW + + `throw + () + + ) + +52 + #__NTH +( +fù +èfù + `throw + () + + ) + +54 + #__THROW + + + ) + +55 + #__NTH +( +fù +è + ) +fct + +61 + #__šlše + + + ) + +63 + #__THROW + + + ) + +64 + #__NTH +( +fù +è + ) +fct + +66 + #__cÚ¡ + cÚ¡ + + ) + +67 + #__sigÃd + sigÃd + + ) + +68 + #__vÞ©že + vÞ©že + + ) + +74 + #__P +( +¬gs +è + ) +args + +75 + #__PMT +( +¬gs +è + ) +args + +80 + #__CONCAT +( +x +, +y +èx ## + ) +y + +81 + #__STRING +( +x +è#x + + ) + +84 + #__±r_t + * + + ) + +85 + #__lÚg_doubË_t + + + ) + +89 #ifdef +__ýlu¥lus + + +90 + #__BEGIN_DECLS +
"C" { + + ) + +91 + #__END_DECLS + } + + ) + +93 + #__BEGIN_DECLS + + + ) + +94 + #__END_DECLS + + + ) + +103 #ià +defšed + +__ýlu¥lus + && defšed +_GLIBCPP_USE_NAMESPACES + + +104 + #__BEGIN_NAMESPACE_STD + +Çme¥aû + +¡d + { + + ) + +105 + #__END_NAMESPACE_STD + } + + ) + +106 + #__USING_NAMESPACE_STD +( +Çme +è +usšg + +¡d +::Çme; + + ) + +107 + #__BEGIN_NAMESPACE_C99 + +Çme¥aû + +__c99 + { + + ) + +108 + #__END_NAMESPACE_C99 + } + + ) + +109 + #__USING_NAMESPACE_C99 +( +Çme +è +usšg + +__c99 +::Çme; + + ) + +114 + #__BEGIN_NAMESPACE_STD + + + ) + +115 + #__END_NAMESPACE_STD + + + ) + +116 + #__USING_NAMESPACE_STD +( +Çme +) + + ) + +117 + #__BEGIN_NAMESPACE_C99 + + + ) + +118 + #__END_NAMESPACE_C99 + + + ) + +119 + #__USING_NAMESPACE_C99 +( +Çme +) + + ) + +124 #iâdeà +__BOUNDED_POINTERS__ + + +125 + #__bounded + + + ) + +126 + #__unbounded + + + ) + +127 + #__±rv®ue + + + ) + +132 + #__bos +( +±r +è + `__bužtš_objeù_size + (±r, +__USE_FORTIFY_LEVEL + > 1) + + ) + +133 + #__bos0 +( +±r +è + `__bužtš_objeù_size + (±r, 0) + + ) + +135 #ià +__GNUC_PREREQ + (4,3) + +136 + #__w¬ndeþ +( +Çme +, +msg +) \ + +137
+ `Çme + ( è + `__©Œibu‹__ +(( + `__w¬nšg__ + ( +msg +))) + + ) + +138 + #__w¬Ç‰r +( +msg +è + `__©Œibu‹__ +(( + `__w¬nšg__ + (msg))) + + ) + +139 + #__”rÜdeþ +( +Çme +, +msg +) \ + +140
+ `Çme + ( è + `__©Œibu‹__ +(( + `__”rÜ__ + ( +msg +))) + + ) + +142 + #__w¬ndeþ +( +Çme +, +msg +è
+ `Çme + ( ) + + ) + +143 + #__w¬Ç‰r +( +msg +) + + ) + +144 + #__”rÜdeþ +( +Çme +, +msg +è
+ `Çme + ( ) + + ) + +148 #ià +__GNUC_PREREQ + (2,97) + +150 + #__æex¬r + [] + + ) + +152 #ifdeà +__GNUC__ + + +153 + #__æex¬r + [0] + + ) + +155 #ià +defšed + +__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L + +156 + #__æex¬r + [] + + ) + +159 + #__æex¬r + [1] + + ) + +175 #ià +defšed + +__GNUC__ + && __GNUC__ >= 2 + +177 + #__REDIRECT +( +Çme +, +´Ùo +, +®Ÿs +èÇm´ÙØ + `__asm__ + ( + `__ASMNAME + (#®Ÿs)) + + ) + +178 #ifdeà +__ýlu¥lus + + +179 + #__REDIRECT_NTH +( +Çme +, +´Ùo +, +®Ÿs +) \ + +180 +Çme + +´Ùo + +__THROW + + `__asm__ + ( + `__ASMNAME + (#®Ÿs)) + + ) + +182 + #__REDIRECT_NTH +( +Çme +, +´Ùo +, +®Ÿs +) \ + +183 +Çme + +´Ùo + + `__asm__ + ( + `__ASMNAME + (#®Ÿs)è +__THROW + + + ) + +185 + #__ASMNAME +( +úame +è + `__ASMNAME2 + ( +__USER_LABEL_PREFIX__ +, cÇme) + + ) + +186 + #__ASMNAME2 +( +´efix +, +úame +è + `__STRING + (´efixè + ) +cname + +199 #ià! +defšed + +__GNUC__ + || __GNUC__ < 2 + +200 + #__©Œibu‹__ +( +xyz +è + + ) + +206 #ià +__GNUC_PREREQ + (2,96) + +207 + #__©Œibu‹_m®loc__ + + `__©Œibu‹__ + (( +__m®loc__ +)) + + ) + +209 + #__©Œibu‹_m®loc__ + + + ) + +215 #ià +__GNUC_PREREQ + (2,96) + +216 + #__©Œibu‹_pu»__ + + `__©Œibu‹__ + (( +__pu»__ +)) + + ) + +218 + #__©Œibu‹_pu»__ + + + ) + +224 #ià +__GNUC_PREREQ + (3,1) + +225 + #__©Œibu‹_u£d__ + + `__©Œibu‹__ + (( +__u£d__ +)) + + ) + +226 + #__©Œibu‹_nošlše__ + + `__©Œibu‹__ + (( +__nošlše__ +)) + + ) + +228 + #__©Œibu‹_u£d__ + + `__©Œibu‹__ + (( +__unu£d__ +)) + + ) + +229 + #__©Œibu‹_nošlše__ + + + ) + +233 #ià +__GNUC_PREREQ + (3,2) + +234 + #__©Œibu‹_d•»ÿ‹d__ + + `__©Œibu‹__ + (( +__d•»ÿ‹d__ +)) + + ) + +236 + #__©Œibu‹_d•»ÿ‹d__ + + + ) + +245 #ià +__GNUC_PREREQ + (2,8) + +246 + #__©Œibu‹_fÜm©_¬g__ +( +x +è + `__©Œibu‹__ + (( + `__fÜm©_¬g__ + (x))) + + ) + +248 + #__©Œibu‹_fÜm©_¬g__ +( +x +è + + ) + +255 #ià +__GNUC_PREREQ + (2,97) + +256 + #__©Œibu‹_fÜm©_¡rfmÚ__ +( +a +, +b +) \ + +257 + `__©Œibu‹__ + (( + `__fÜm©__ + ( +__¡rfmÚ__ +, +a +, +b +))) + + ) + +259 + #__©Œibu‹_fÜm©_¡rfmÚ__ +( +a +, +b +è + + ) + +264 #ià +__GNUC_PREREQ + (3,3) + +265 + #__nÚnuÎ +( +·¿ms +è + `__©Œibu‹__ + (( +__nÚnuÎ__ +…¬ams)) + + ) + +267 + #__nÚnuÎ +( +·¿ms +) + + ) + +272 #ià +__GNUC_PREREQ + (3,4) + +273 + #__©Œibu‹_w¬n_unu£d_»suÉ__ + \ + +274 + `__©Œibu‹__ + (( +__w¬n_unu£d_»suÉ__ +)) + + ) + +275 #ià +__USE_FORTIFY_LEVEL + > 0 + +276 + #__wur + +__©Œibu‹_w¬n_unu£d_»suÉ__ + + + ) + +279 + #__©Œibu‹_w¬n_unu£d_»suÉ__ + + + ) + +281 #iâdeà +__wur + + +282 + #__wur + + + ) + +286 #ià +__GNUC_PREREQ + (3,2) + +287 + #__®ways_šlše + +__šlše + + `__©Œibu‹__ + (( +__®ways_šlše__ +)) + + ) + +289 + #__®ways_šlše + +__šlše + + + ) + +294 #ià! +defšed + +__ýlu¥lus + || +__GNUC_PREREQ + (4,3) + +295 #ià +defšed + +__GNUC_STDC_INLINE__ + || defšed +__ýlu¥lus + + +296 + #__ex‹º_šlše +
+__šlše + + `__©Œibu‹__ + (( +__gnu_šlše__ +)) + + ) + +297 #ià +__GNUC_PREREQ + (4,3) + +298 + #__ex‹º_®ways_šlše + \ + +299
+__®ways_šlše + + `__©Œibu‹__ + (( +__gnu_šlše__ +, +__¬tificŸl__ +)) + + ) + +301 + #__ex‹º_®ways_šlše + \ + +302
+__®ways_šlše + + `__©Œibu‹__ + (( +__gnu_šlše__ +)) + + ) + +305 + #__ex‹º_šlše +
+__šlše + + + ) + +306 #ià +__GNUC_PREREQ + (4,3) + +307 + #__ex‹º_®ways_šlše + \ + +308
+__®ways_šlše + + `__©Œibu‹__ + (( +__¬tificŸl__ +)) + + ) + +310 + #__ex‹º_®ways_šlše +
+__®ways_šlše + + + ) + +317 #ià +__GNUC_PREREQ + (4,3) + +318 + #__va_¬g_·ck +(è + `__bužtš_va_¬g_·ck + () + + ) + +319 + #__va_¬g_·ck_Ën +(è + `__bužtš_va_¬g_·ck_Ën + () + + ) + +326 #ià! +__GNUC_PREREQ + (2,8) + +327 + #__ex‹nsiÚ__ + + + ) + +331 #ià! +__GNUC_PREREQ + (2,92) + +332 + #__»¡riù + + + ) + +338 #ià +__GNUC_PREREQ + (3,1è&& ! +defšed + +__GNUG__ + + +339 + #__»¡riù_¬r + +__»¡riù + + + ) + +341 #ifdeà +__GNUC__ + + +342 + #__»¡riù_¬r + + + ) + +344 #ià +defšed + +__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L + +345 + #__»¡riù_¬r + +»¡riù + + + ) + +348 + #__»¡riù_¬r + + + ) + +353 + ~<b™s/wÜdsize.h +> + +355 #ià +defšed + +__LONG_DOUBLE_MATH_OPTIONAL + && defšed +__NO_LONG_DOUBLE_MATH + + +356 + #__LDBL_COMPAT + 1 + + ) + +357 #ifdeà +__REDIRECT + + +358 + #__LDBL_REDIR1 +( +Çme +, +´Ùo +, +®Ÿs +è + `__REDIRECT + (Çme,…rÙo,‡lŸs) + + ) + +359 + #__LDBL_REDIR +( +Çme +, +´Ùo +) \ + +360 + `__LDBL_REDIR1 + ( +Çme +, +´Ùo +, +__Ædbl_ +##Çme) + + ) + +361 + #__LDBL_REDIR1_NTH +( +Çme +, +´Ùo +, +®Ÿs +è + `__REDIRECT_NTH + (Çme,…rÙo,‡lŸs) + + ) + +362 + #__LDBL_REDIR_NTH +( +Çme +, +´Ùo +) \ + +363 + `__LDBL_REDIR1_NTH + ( +Çme +, +´Ùo +, +__Ædbl_ +##Çme) + + ) + +364 + #__LDBL_REDIR1_DECL +( +Çme +, +®Ÿs +) \ + +365
+ `__ty³of + ( +Çme +èÇm + `__asm + ( + `__ASMNAME + (#®Ÿs)); + + ) + +366 + #__LDBL_REDIR_DECL +( +Çme +) \ + +367
+ `__ty³of + ( +Çme +èÇm + `__asm + ( + `__ASMNAME + ("__Ædbl_" #Çme)); + + ) + +368 + #__REDIRECT_LDBL +( +Çme +, +´Ùo +, +®Ÿs +) \ + +369 + `__LDBL_REDIR1 + ( +Çme +, +´Ùo +, +__Ædbl_ +## +®Ÿs +) + + ) + +370 + #__REDIRECT_NTH_LDBL +( +Çme +, +´Ùo +, +®Ÿs +) \ + +371 + `__LDBL_REDIR1_NTH + ( +Çme +, +´Ùo +, +__Ædbl_ +## +®Ÿs +) + + ) + +374 #ià! +defšed + +__LDBL_COMPAT + || !defšed +__REDIRECT + + +375 + #__LDBL_REDIR1 +( +Çme +, +´Ùo +, +®Ÿs +èÇm + ) +proto + +376 + #__LDBL_REDIR +( +Çme +, +´Ùo +èÇm + ) +proto + +377 + #__LDBL_REDIR1_NTH +( +Çme +, +´Ùo +, +®Ÿs +èÇm´ÙØ +__THROW + + + ) + +378 + #__LDBL_REDIR_NTH +( +Çme +, +´Ùo +èÇm´ÙØ +__THROW + + + ) + +379 + #__LDBL_REDIR_DECL +( +Çme +) + + ) + +380 #ifdeà +__REDIRECT + + +381 + #__REDIRECT_LDBL +( +Çme +, +´Ùo +, +®Ÿs +è + `__REDIRECT + (Çme,…rÙo,‡lŸs) + + ) + +382 + #__REDIRECT_NTH_LDBL +( +Çme +, +´Ùo +, +®Ÿs +) \ + +383 + `__REDIRECT_NTH + ( +Çme +, +´Ùo +, +®Ÿs +) + + ) + + @/usr/include/alloca.h + +19 #iâdef +_ALLOCA_H + + +20 + #_ALLOCA_H + 1 + + ) + +22 + ~<ã©u»s.h +> + +24 + #__Ãed_size_t + + + ) + +25 + ~<¡ddef.h +> + +27 + g__BEGIN_DECLS + + +30 #undeà +®loÿ + + +33
* + $®loÿ + ( +size_t + +__size +è +__THROW +; + +35 #ifdef +__GNUC__ + + +36 + #®loÿ +( +size +è + `__bužtš_®loÿ + (size) + + ) + +39 +__END_DECLS + + + @/usr/include/bits/byteswap.h + +21 #ià! +defšed + +_BYTESWAP_H + && !defšed +_NETINET_IN_H + && !defšed +_ENDIAN_H + + +25 #iâdeà +_BITS_BYTESWAP_H + + +26 + #_BITS_BYTESWAP_H + 1 + + ) + +28 + ~<b™s/wÜdsize.h +> + +31 + #__bsw_cÚ¡ªt_16 +( +x +) \ + +32 (((( +x +è>> 8è& 0xffè| (((xè& 0xffè<< 8)) + + ) + +34 #ià +defšed + +__GNUC__ + && __GNUC__ >= 2 + +35 + #__bsw_16 +( +x +) \ + +36 ( +__ex‹nsiÚ__ + \ + +37 ({ +__v +, +__x + = ( +x +); \ + +38 ià( + `__bužtš_cÚ¡ªt_p + ( +__x +)) \ + +39 +__v + = + `__bsw_cÚ¡ªt_16 + ( +__x +); \ + +41 + `__asm__ + ("rorw $8, %w0" \ + +42 : "ô" ( +__v +) \ + +43 : "0" ( +__x +) \ + +45 +__v +; })) + + ) + +48 + #__bsw_16 +( +x +) \ + +49 ( +__ex‹nsiÚ__ + \ + +50 ({ +__x + = ( +x +); + `__bsw_cÚ¡ªt_16 + (__x); })) + + ) + +55 + #__bsw_cÚ¡ªt_32 +( +x +) \ + +56 (((( +x +) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ + +57 ((( +x +è& 0x0000ff00è<< 8è| (((xè& 0x000000ffè<< 24)) + + ) + +59 #ià +defšed + +__GNUC__ + && __GNUC__ >= 2 + +60 #ià +__WORDSIZE + =ð64 || ( +defšed + +__i486__ + || defšed +__³Áium__ + \ + +61 || +defšed + + g__³Áium´o__ + || defšed + g__³Áium4__ + \ + +62 || +defšed + + g__k8__ + || defšed + g__©hlÚ__ + \ + +63 || +defšed + + g__k6__ + || defšed + g__nocÚa__ + \ + +64 || +defšed + + g__cÜe2__ + || defšed + g__geode__ + \ + +65 || +defšed + + g__amdçm10__ +) + +68 + #__bsw_32 +( +x +) \ + +69 ( +__ex‹nsiÚ__ + \ + +70 ({ +__v +, +__x + = ( +x +); \ + +71 ià( + `__bužtš_cÚ¡ªt_p + ( +__x +)) \ + +72 +__v + = + `__bsw_cÚ¡ªt_32 + ( +__x +); \ + +74 + `__asm__ + ("bsw %0" : "ô" ( +__v +è: "0" ( +__x +)); \ + +75 +__v +; })) + + ) + +77 + #__bsw_32 +( +x +) \ + +78 ( +__ex‹nsiÚ__ + \ + +79 ({ +__v +, +__x + = ( +x +); \ + +80 ià( + `__bužtš_cÚ¡ªt_p + ( +__x +)) \ + +81 +__v + = + `__bsw_cÚ¡ªt_32 + ( +__x +); \ + +83 + `__asm__ + ("rorw $8, %w0;" \ + +86 : "ô" ( +__v +) \ + +87 : "0" ( +__x +) \ + +89 +__v +; })) + + ) + +92 + #__bsw_32 +( +x +) \ + +93 ( +__ex‹nsiÚ__ + \ + +94 ({ +__x + = ( +x +); + `__bsw_cÚ¡ªt_32 + (__x); })) + + ) + +98 #ià +defšed + +__GNUC__ + && __GNUC__ >= 2 + +100 + #__bsw_cÚ¡ªt_64 +( +x +) \ + +101 (((( +x +) & 0xff00000000000000ull) >> 56) \ + +102 | ((( +x +) & 0x00ff000000000000ull) >> 40) \ + +103 | ((( +x +) & 0x0000ff0000000000ull) >> 24) \ + +104 | ((( +x +) & 0x000000ff00000000ull) >> 8) \ + +105 | ((( +x +) & 0x00000000ff000000ull) << 8) \ + +106 | ((( +x +) & 0x0000000000ff0000ull) << 24) \ + +107 | ((( +x +) & 0x000000000000ff00ull) << 40) \ + +108 | ((( +x +è& 0x00000000000000ffuÎè<< 56)) + + ) + +110 #ià +__WORDSIZE + == 64 + +111 + #__bsw_64 +( +x +) \ + +112 ( +__ex‹nsiÚ__ + \ + +113 ({ +__v +, +__x + = ( +x +); \ + +114 ià( + `__bužtš_cÚ¡ªt_p + ( +__x +)) \ + +115 +__v + = + `__bsw_cÚ¡ªt_64 + ( +__x +); \ + +117 + `__asm__ + ("bsw %q0" : "ô" ( +__v +è: "0" ( +__x +)); \ + +118 +__v +; })) + + ) + +120 + #__bsw_64 +( +x +) \ + +121 ( +__ex‹nsiÚ__ + \ + +122 ({ uniÚ { +__ex‹nsiÚ__ + +__Î +; \ + +123 +__l +[2]; } +__w +, +__r +; \ + +124 ià( + `__bužtš_cÚ¡ªt_p + ( +x +)) \ + +125 +__r +. +__Î + = + `__bsw_cÚ¡ªt_64 + ( +x +); \ + +128 +__w +. +__Î + = ( +x +); \ + +129 +__r +. +__l +[0] = + `__bsw_32 + ( +__w +.__l[1]); \ + +130 +__r +. +__l +[1] = + `__bsw_32 + ( +__w +.__l[0]); \ + +132 +__r +. +__Î +; })) + + ) + + @/usr/include/bits/endian.h + +3 #iâdeà +_ENDIAN_H + + +7 + #__BYTE_ORDER + +__LITTLE_ENDIAN + + + ) + + @/usr/include/bits/libc-lock.h + +20 #iâdeà +_BITS_LIBC_LOCK_H + + +21 + #_BITS_LIBC_LOCK_H + 1 + + ) + +23 + ~<±h»ad.h +> + +24 + #__Ãed_NULL + + + ) + +25 + ~<¡ddef.h +> + +34 #ifdeà +_LIBC + + +35 + ~<lowËv–lock.h +> + +36 + ~<Žs.h +> + +37 + ~<±h»ad-funùiÚs.h +> + +38 + ~<”ºo.h +> + +39 + ~<gnu/ÝtiÚ-groups.h +> + +43 #ià +defšed + +_LIBC + || defšed +_IO_MTSAFE_IO + + +44 #ià( +defšed + +NOT_IN_libc + && !defšed +IS_IN_lib±h»ad +è|| !defšed +_LIBC + + +45 +±h»ad_mu‹x_t + + t__libc_lock_t +; + +46 ¡ruù { +±h»ad_mu‹x_t + + mmu‹x +; } + t__libc_lock_»cursive_t +; + +48 + t__libc_lock_t +; + +49 ¡ruù { + mlock +; + mút +; * + mowÃr +; } + t__libc_lock_»cursive_t +; + +51 ¡ruù { +±h»ad_mu‹x_t + + mmu‹x +; } + t__¹ld_lock_»cursive_t +; + +52 #ifdeà +__USE_UNIX98 + + +53 +±h»ad_rwlock_t + + t__libc_rwlock_t +; + +55 +__libc_rwlock_Ýaque__ + + t__libc_rwlock_t +; + +58 +__libc_lock_Ýaque__ + + t__libc_lock_t +; + +59 +__libc_lock_»cursive_Ýaque__ + + t__libc_lock_»cursive_t +; + +60 +__libc_rwlock_Ýaque__ + + t__libc_rwlock_t +; + +64 +±h»ad_key_t + + t__libc_key_t +; + +73 + #__libc_lock_defše +( +CLASS +, +NAME +) \ + +74 +CLASS + +__libc_lock_t + +NAME +; + + ) + +75 + #__libc_rwlock_defše +( +CLASS +, +NAME +) \ + +76 +CLASS + +__libc_rwlock_t + +NAME +; + + ) + +77 + #__libc_lock_defše_»cursive +( +CLASS +, +NAME +) \ + +78 +CLASS + +__libc_lock_»cursive_t + +NAME +; + + ) + +79 + #__¹ld_lock_defše_»cursive +( +CLASS +, +NAME +) \ + +80 +CLASS + +__¹ld_lock_»cursive_t + +NAME +; + + ) + +91 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +92 #ià +LLL_LOCK_INITIALIZER + == 0 + +93 + #__libc_lock_defše_š™Ÿlized +( +CLASS +, +NAME +) \ + +94 +CLASS + +__libc_lock_t + +NAME +; + + ) + +96 + #__libc_lock_defše_š™Ÿlized +( +CLASS +, +NAME +) \ + +97 +CLASS + +__libc_lock_t + +NAME + = +LLL_LOCK_INITIALIZER +; + + ) + +100 #ià +__LT_SPINLOCK_INIT + == 0 + +101 + #__libc_lock_defše_š™Ÿlized +( +CLASS +, +NAME +) \ + +102 +CLASS + +__libc_lock_t + +NAME +; + + ) + +104 + #__libc_lock_defše_š™Ÿlized +( +CLASS +, +NAME +) \ + +105 +CLASS + +__libc_lock_t + +NAME + = +PTHREAD_MUTEX_INITIALIZER +; + + ) + +109 + #__libc_rwlock_defše_š™Ÿlized +( +CLASS +, +NAME +) \ + +110 +CLASS + +__libc_rwlock_t + +NAME + = +PTHREAD_RWLOCK_INITIALIZER +; + + ) + +114 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +115 #ià +LLL_LOCK_INITIALIZER + == 0 + +116 + #__libc_lock_defše_š™Ÿlized_»cursive +( +CLASS +, +NAME +) \ + +117 +CLASS + +__libc_lock_»cursive_t + +NAME +; + + ) + +119 + #__libc_lock_defše_š™Ÿlized_»cursive +( +CLASS +, +NAME +) \ + +120 +CLASS + +__libc_lock_»cursive_t + +NAME + = +_LIBC_LOCK_RECURSIVE_INITIALIZER +; + + ) + +122 + #_LIBC_LOCK_RECURSIVE_INITIALIZER + \ + +123 { +LLL_LOCK_INITIALIZER +, 0, +NULL + } + + ) + +125 + #__libc_lock_defše_š™Ÿlized_»cursive +( +CLASS +, +NAME +) \ + +126 +CLASS + +__libc_lock_»cursive_t + +NAME + = +_LIBC_LOCK_RECURSIVE_INITIALIZER +; + + ) + +127 + #_LIBC_LOCK_RECURSIVE_INITIALIZER + \ + +128 { +PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP +} + + ) + +131 + #__¹ld_lock_defše_š™Ÿlized_»cursive +( +CLASS +, +NAME +) \ + +132 +CLASS + +__¹ld_lock_»cursive_t + +NAME + = +_RTLD_LOCK_RECURSIVE_INITIALIZER +; + + ) + +133 + #_RTLD_LOCK_RECURSIVE_INITIALIZER + \ + +134 { +PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP +} + + ) + +136 + #__¹ld_lock_š™Ÿlize +( +NAME +) \ + +137 ( è(( +NAME +èð( +__¹ld_lock_»cursive_t +è +_RTLD_LOCK_RECURSIVE_INITIALIZER +) + + ) + +144 #ifdeà +__PIC__ + + +145 + #__libc_maybe_ÿÎ +( +FUNC +, +ARGS +, +ELSE +) \ + +146 ( + `__ex‹nsiÚ__ + ({ + `__ty³of + ( +FUNC +è* +_â + = (FUNC); \ + +147 +_â + !ð +NULL + ? (*_âè +ARGS + : +ELSE +; })) + + ) + +149 + #__libc_maybe_ÿÎ +( +FUNC +, +ARGS +, +ELSE +) \ + +150 ( +FUNC + !ð +NULL + ? FUNC +ARGS + : +ELSE +) + + ) + +154 #ià +defšed + +SHARED + && !defšed +NOT_IN_libc + + +155 + #PTFAVAIL +( +NAME +è +__libc_±h»ad_funùiÚs_š™ + + + ) + +156 + #__libc_±f_ÿÎ +( +FUNC +, +ARGS +, +ELSE +) \ + +157 ( +__libc_±h»ad_funùiÚs_š™ + ? + `PTHFCT_CALL + ( +±r_ +## +FUNC +, +ARGS +è: +ELSE +) + + ) + +158 + #__libc_±f_ÿÎ_®ways +( +FUNC +, +ARGS +) \ + +159 + `PTHFCT_CALL + ( +±r_ +## +FUNC +, +ARGS +) + + ) + +161 + #PTFAVAIL +( +NAME +è(NAME !ð +NULL +) + + ) + +162 + #__libc_±f_ÿÎ +( +FUNC +, +ARGS +, +ELSE +) \ + +163 + `__libc_maybe_ÿÎ + ( +FUNC +, +ARGS +, +ELSE +) + + ) + +164 + #__libc_±f_ÿÎ_®ways +( +FUNC +, +ARGS +) \ + +165 +FUNC + +ARGS + + + ) + +171 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +172 + #__libc_lock_š™ +( +NAME +è((NAMEèð +LLL_LOCK_INITIALIZER +, 0) + + ) + +174 + #__libc_lock_š™ +( +NAME +) \ + +175 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_š™ +, (&( +NAME +), +NULL +), 0) + + ) + +177 #ià +defšed + +SHARED + && !defšed +NOT_IN_libc + + +180 + #__libc_rwlock_š™ +( +NAME +) \ + +181 ( + `__bužtš_mem£t + (&( +NAME +), '\0', (NAME)), 0) + + ) + +183 + #__libc_rwlock_š™ +( +NAME +) \ + +184 + `__libc_maybe_ÿÎ + ( +__±h»ad_rwlock_š™ +, (&( +NAME +), +NULL +), 0) + + ) + +188 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +189 + #__libc_lock_š™_»cursive +( +NAME +) \ + +190 (( +NAME +èð( +__libc_lock_»cursive_t +è +_LIBC_LOCK_RECURSIVE_INITIALIZER +, 0) + + ) + +192 + #__libc_lock_š™_»cursive +( +NAME +) \ + +194 ià( +__±h»ad_mu‹x_š™ + !ð +NULL +) \ + +196 +±h»ad_mu‹x©Œ_t + +__©Œ +; \ + +197 + `__±h»ad_mu‹x©Œ_š™ + (& +__©Œ +); \ + +198 + `__±h»ad_mu‹x©Œ_£‰y³ + (& +__©Œ +, +PTHREAD_MUTEX_RECURSIVE_NP +); \ + +199 + `__±h»ad_mu‹x_š™ + (&( +NAME +). +mu‹x +, & +__©Œ +); \ + +200 + `__±h»ad_mu‹x©Œ_de¡roy + (& +__©Œ +); \ + +202 } 0) + + ) + +205 + #__¹ld_lock_š™_»cursive +( +NAME +) \ + +207 ià( +__±h»ad_mu‹x_š™ + !ð +NULL +) \ + +209 +±h»ad_mu‹x©Œ_t + +__©Œ +; \ + +210 + `__±h»ad_mu‹x©Œ_š™ + (& +__©Œ +); \ + +211 + `__±h»ad_mu‹x©Œ_£‰y³ + (& +__©Œ +, +PTHREAD_MUTEX_RECURSIVE_NP +); \ + +212 + `__±h»ad_mu‹x_š™ + (&( +NAME +). +mu‹x +, & +__©Œ +); \ + +213 + `__±h»ad_mu‹x©Œ_de¡roy + (& +__©Œ +); \ + +215 } 0) + + ) + +220 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +221 + #__libc_lock_fši +( +NAME +è(( è0) + + ) + +223 + #__libc_lock_fši +( +NAME +) \ + +224 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_de¡roy +, (&( +NAME +)), 0) + + ) + +226 #ià +defšed + +SHARED + && !defšed +NOT_IN_libc + + +227 + #__libc_rwlock_fši +( +NAME +è(( è0) + + ) + +229 + #__libc_rwlock_fši +( +NAME +) \ + +230 + `__libc_maybe_ÿÎ + ( +__±h»ad_rwlock_de¡roy +, (&( +NAME +)), 0) + + ) + +234 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +235 + #__libc_lock_fši_»cursive +( +NAME +è(( è0) + + ) + +237 + #__libc_lock_fši_»cursive +( +NAME +) \ + +238 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_de¡roy +, (&( +NAME +)), 0) + + ) + +242 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +243 #ià +__OPTION_EGLIBC_BIG_MACROS + != 1 + +247
+__libc_lock_lock_â + ( +__libc_lock_t + *); + +248 +libc_hidd’_´Ùo + ( +__libc_lock_lock_â +); + +250 #ià +__OPTION_EGLIBC_BIG_MACROS + + +251 + #__libc_lock_lock +( +NAME +) \ + +252 ({ + `Îl_lock + ( +NAME +, +LLL_PRIVATE +); 0; }) + + ) + +254 + #__libc_lock_lock +( +NAME +) \ + +255 + `__libc_lock_lock_â + (&( +NAME +)) + + ) + +258 + #__libc_lock_lock +( +NAME +) \ + +259 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_lock +, (&( +NAME +)), 0) + + ) + +261 + #__libc_rwlock_rdlock +( +NAME +) \ + +262 + `__libc_±f_ÿÎ + ( +__±h»ad_rwlock_rdlock +, (&( +NAME +)), 0) + + ) + +263 + #__libc_rwlock_w¾ock +( +NAME +) \ + +264 + `__libc_±f_ÿÎ + ( +__±h»ad_rwlock_w¾ock +, (&( +NAME +)), 0) + + ) + +267 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +268 #ià +__OPTION_EGLIBC_BIG_MACROS + != 1 + +272
+__libc_lock_lock_»cursive_â + ( +__libc_lock_»cursive_t + *); + +273 +libc_hidd’_´Ùo + ( +__libc_lock_lock_»cursive_â +); + +275 #ià +__OPTION_EGLIBC_BIG_MACROS + + +276 + #__libc_lock_lock_»cursive +( +NAME +) \ + +278 * +£lf + = +THREAD_SELF +; \ + +279 ià(( +NAME +). +owÃr + !ð +£lf +) \ + +281 + `Îl_lock + (( +NAME +). +lock +, +LLL_PRIVATE +); \ + +282 ( +NAME +). +owÃr + = +£lf +; \ + +284 ++( +NAME +). +út +; \ + +285 } 0) + + ) + +287 + #__libc_lock_lock_»cursive +( +NAME +) \ + +288 + `__libc_lock_lock_»cursive_â + (&( +NAME +)) + + ) + +291 + #__libc_lock_lock_»cursive +( +NAME +) \ + +292 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_lock +, (&( +NAME +). +mu‹x +), 0) + + ) + +296 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +297 #ià +__OPTION_EGLIBC_BIG_MACROS + != 1 + +301
+__libc_lock_Œylock_â + ( +__libc_lock_t + *); + +302 +libc_hidd’_´Ùo + ( +__libc_lock_Œylock_â +); + +304 #ià +__OPTION_EGLIBC_BIG_MACROS + + +305 + #__libc_lock_Œylock +( +NAME +) \ + +306 + `Îl_Œylock + ( +NAME +) + + ) + +308 + #__libc_lock_Œylock +( +NAME +) \ + +309 + `__libc_lock_Œylock_â + (&( +NAME +)) + + ) + +312 + #__libc_lock_Œylock +( +NAME +) \ + +313 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_Œylock +, (&( +NAME +)), 0) + + ) + +315 + #__libc_rwlock_Œyrdlock +( +NAME +) \ + +316 + `__libc_maybe_ÿÎ + ( +__±h»ad_rwlock_Œyrdlock +, (&( +NAME +)), 0) + + ) + +317 + #__libc_rwlock_Œyw¾ock +( +NAME +) \ + +318 + `__libc_maybe_ÿÎ + ( +__±h»ad_rwlock_Œyw¾ock +, (&( +NAME +)), 0) + + ) + +321 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +322 #ià +__OPTION_EGLIBC_BIG_MACROS + != 1 + +326
+__libc_lock_Œylock_»cursive_â + ( +__libc_lock_»cursive_t + *); + +327 +libc_hidd’_´Ùo + ( +__libc_lock_Œylock_»cursive_â +); + +329 #ià +__OPTION_EGLIBC_BIG_MACROS + + +330 + #__libc_lock_Œylock_»cursive +( +NAME +) \ + +332 +»suÉ + = 0; \ + +333 * +£lf + = +THREAD_SELF +; \ + +334 ià(( +NAME +). +owÃr + !ð +£lf +) \ + +336 ià( + `Îl_Œylock + (( +NAME +). +lock +) == 0) \ + +338 ( +NAME +). +owÃr + = +£lf +; \ + +339 ( +NAME +). +út + = 1; \ + +342 +»suÉ + = +EBUSY +; \ + +345 ++( +NAME +). +út +; \ + +346 +»suÉ +; \ + +347 }) + + ) + +349 + #__libc_lock_Œylock_»cursive +( +NAME +) \ + +350 + `__libc_lock_Œylock_»cursive_â + (&( +NAME +)) + + ) + +353 + #__libc_lock_Œylock_»cursive +( +NAME +) \ + +354 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_Œylock +, (&( +NAME +)), 0) + + ) + +357 + #__¹ld_lock_Œylock_»cursive +( +NAME +) \ + +358 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_Œylock +, (&( +NAME +). +mu‹x +), 0) + + ) + +361 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +362 #ià +__OPTION_EGLIBC_BIG_MACROS + != 1 + +366
+__libc_lock_uÆock_â + ( +__libc_lock_t + *); + +367 +libc_hidd’_´Ùo + ( +__libc_lock_uÆock_â +); + +369 #ià +__OPTION_EGLIBC_BIG_MACROS + + +370 + #__libc_lock_uÆock +( +NAME +) \ + +371 + `Îl_uÆock + ( +NAME +, +LLL_PRIVATE +) + + ) + +373 + #__libc_lock_uÆock +( +NAME +) \ + +374 + `__libc_lock_uÆock_â + (&( +NAME +)) + + ) + +377 + #__libc_lock_uÆock +( +NAME +) \ + +378 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_uÆock +, (&( +NAME +)), 0) + + ) + +380 + #__libc_rwlock_uÆock +( +NAME +) \ + +381 + `__libc_±f_ÿÎ + ( +__±h»ad_rwlock_uÆock +, (&( +NAME +)), 0) + + ) + +384 #ià +defšed + +_LIBC + && (!defšed +NOT_IN_libc + || defšed +IS_IN_lib±h»ad +) + +385 #ià +__OPTION_EGLIBC_BIG_MACROS + != 1 + +389
+__libc_lock_uÆock_»cursive_â + ( +__libc_lock_»cursive_t + *); + +390 +libc_hidd’_´Ùo + ( +__libc_lock_uÆock_»cursive_â +); + +392 #ià +__OPTION_EGLIBC_BIG_MACROS + + +394 + #__libc_lock_uÆock_»cursive +( +NAME +) \ + +396 ià(--( +NAME +). +út + == 0) \ + +398 ( +NAME +). +owÃr + = +NULL +; \ + +399 + `Îl_uÆock + (( +NAME +). +lock +, +LLL_PRIVATE +); \ + +401 } 0) + + ) + +403 + #__libc_lock_uÆock_»cursive +( +NAME +) \ + +404 + `__libc_lock_uÆock_»cursive_â + (&( +NAME +)) + + ) + +407 + #__libc_lock_uÆock_»cursive +( +NAME +) \ + +408 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_uÆock +, (&( +NAME +)), 0) + + ) + +411 #ià +defšed + +_LIBC + && defšed +SHARED + + +412 + #__¹ld_lock_deçuÉ_lock_»cursive +( +lock +) \ + +413 ++(( +±h»ad_mu‹x_t + *)( +lock +))-> +__d©a +. +__couÁ +; + + ) + +415 + #__¹ld_lock_deçuÉ_uÆock_»cursive +( +lock +) \ + +416 --(( +±h»ad_mu‹x_t + *)( +lock +))-> +__d©a +. +__couÁ +; + + ) + +418 + #__¹ld_lock_lock_»cursive +( +NAME +) \ + +419 + `GL +( +dl_¹ld_lock_»cursive +è(&( +NAME +). +mu‹x +) + + ) + +421 + #__¹ld_lock_uÆock_»cursive +( +NAME +) \ + +422 + `GL +( +dl_¹ld_uÆock_»cursive +è(&( +NAME +). +mu‹x +) + + ) + +424 + #__¹ld_lock_lock_»cursive +( +NAME +) \ + +425 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_lock +, (&( +NAME +). +mu‹x +), 0) + + ) + +427 + #__¹ld_lock_uÆock_»cursive +( +NAME +) \ + +428 + `__libc_maybe_ÿÎ + ( +__±h»ad_mu‹x_uÆock +, (&( +NAME +). +mu‹x +), 0) + + ) + +432 #ià +PTHREAD_ONCE_INIT + == 0 + +435 + #__libc_Úû_defše +( +CLASS +, +NAME +) \ + +436 +CLASS + +±h»ad_Úû_t + +NAME + + + ) + +438 + #__libc_Úû_defše +( +CLASS +, +NAME +) \ + +439 +CLASS + +±h»ad_Úû_t + +NAME + = +PTHREAD_ONCE_INIT + + + ) + +443 + #__libc_Úû +( +ONCE_CONTROL +, +INIT_FUNCTION +) \ + +445 ià( + `PTFAVAIL + ( +__±h»ad_Úû +)) \ + +446 + `__libc_±f_ÿÎ_®ways + ( +__±h»ad_Úû +, (&( +ONCE_CONTROL +), \ + +447 +INIT_FUNCTION +)); \ + +448 ià(( +ONCE_CONTROL +è=ð +PTHREAD_ONCE_INIT +) { \ + +449 + `INIT_FUNCTION + (); \ + +450 ( +ONCE_CONTROL +) |= 2; \ + +452 } 0) + + ) + +459
+_±h»ad_þ—nup_push + ( +_±h»ad_þ—nup_bufãr + * +bufãr +, + +460 (* +routše +è( *), * +¬g +); + +461
+ `_±h»ad_þ—nup_pÝ + ( +_±h»ad_þ—nup_bufãr + * +bufãr +, + +462 +execu‹ +); + +463
+ `_±h»ad_þ—nup_push_deãr + ( +_±h»ad_þ—nup_bufãr + * +bufãr +, + +464 (* +routše +è( *), * +¬g +); + +465
+ `_±h»ad_þ—nup_pÝ_»¡Üe + ( +_±h»ad_þ—nup_bufãr + * +bufãr +, + +466 +execu‹ +); + +469 + #__libc_þ—nup_»giÚ_¡¬t +( +DOIT +, +FCT +, +ARG +) \ + +470 { +_±h»ad_þ—nup_bufãr + +_bufãr +; \ + +471 +_avaž +; \ + +472 ià( +DOIT +) { \ + +473 +_avaž + = + `PTFAVAIL + ( +_±h»ad_þ—nup_push_deãr +); \ + +474 ià( +_avaž +) { \ + +475 + `__libc_±f_ÿÎ_®ways + ( +_±h»ad_þ—nup_push_deãr +, (& +_bufãr +, +FCT +, \ + +476 +ARG +)); \ + +478 +_bufãr +. +__routše + = ( +FCT +); \ + +479 +_bufãr +. +__¬g + = ( +ARG +); \ + +482 +_avaž + = 0; \ + +483 } + + ) + +486 + #__libc_þ—nup_»giÚ_’d +( +DOIT +) \ + +487 ià( +_avaž +) { \ + +488 + `__libc_±f_ÿÎ_®ways + ( +_±h»ad_þ—nup_pÝ_»¡Üe +, (& +_bufãr +, +DOIT +));\ + +489 } ià( +DOIT +) \ + +490 +_bufãr +. + `__routše + (_bufãr. +__¬g +); \ + +491 + } + + ) +} + +494 + #__libc_þ—nup_’d +( +DOIT +) \ + +495 ià( +_avaž +) { \ + +496 + `__libc_±f_ÿÎ_®ways + ( +_±h»ad_þ—nup_pÝ_»¡Üe +, (& +_bufãr +, +DOIT +));\ + +497 } ià( +DOIT +) \ + +498 +_bufãr +. + `__routše + (_bufãr. +__¬g +) + + ) + +502 +__ex‹º_šlše + + +503 + $__libc_þ—nup_routše + ( +__±h»ad_þ—nup_äame + * +f +) + +505 ià( +f +-> +__do_™ +) + +506 +f +-> + `__ÿnûl_routše + (f-> +__ÿnûl_¬g +); + +507 + } +} + +509 + #__libc_þ—nup_push +( +fù +, +¬g +) \ + +511 +__±h»ad_þ—nup_äame + +__þäame + \ + +512 + `__©Œibu‹__ + (( + `__þ—nup__ + ( +__libc_þ—nup_routše +))) \ + +513 ð{ . +__ÿnûl_routše + = ( +fù +), . +__ÿnûl_¬g + = ( +¬g +), \ + +514 . +__do_™ + = 1 }; + + ) + +516 + #__libc_þ—nup_pÝ +( +execu‹ +) \ + +517 +__þäame +. +__do_™ + = ( +execu‹ +); \ + +518 } 0) + + ) + +522 + #__libc_key_ü—‹ +( +KEY +, +DESTRUCTOR +) \ + +523 + `__libc_±f_ÿÎ + ( +__±h»ad_key_ü—‹ +, ( +KEY +, +DESTRUCTOR +), 1) + + ) + +526 + #__libc_g‘¥ecific +( +KEY +) \ + +527 + `__libc_±f_ÿÎ + ( +__±h»ad_g‘¥ecific +, ( +KEY +), +NULL +) + + ) + +530 + #__libc_£t¥ecific +( +KEY +, +VALUE +) \ + +531 + `__libc_±f_ÿÎ + ( +__±h»ad_£t¥ecific +, ( +KEY +, +VALUE +), 0) + + ) + +537 + #__libc_©fÜk +( +PREPARE +, +PARENT +, +CHILD +) \ + +538 + `__»gi¡”_©fÜk + ( +PREPARE +, +PARENT +, +CHILD +, +NULL +) + + ) + +539
+__»gi¡”_©fÜk + ( (* +__´•¬e +) ( ), + +540 (* +__·»Á +) ( ), + +541 (* +__chžd +) ( ), + +542 * +__dso_hªdË +); + +547
+ `__±h»ad_mu‹x_š™ + ( +±h»ad_mu‹x_t + * +__mu‹x +, + +548 +__cÚ¡ + +±h»ad_mu‹x©Œ_t + * +__mu‹x_©Œ +); + +550
+ `__±h»ad_mu‹x_de¡roy + ( +±h»ad_mu‹x_t + * +__mu‹x +); + +552
+ `__±h»ad_mu‹x_Œylock + ( +±h»ad_mu‹x_t + * +__mu‹x +); + +554
+ `__±h»ad_mu‹x_lock + ( +±h»ad_mu‹x_t + * +__mu‹x +); + +556
+ `__±h»ad_mu‹x_uÆock + ( +±h»ad_mu‹x_t + * +__mu‹x +); + +558
+ `__±h»ad_mu‹x©Œ_š™ + ( +±h»ad_mu‹x©Œ_t + * +__©Œ +); + +560
+ `__±h»ad_mu‹x©Œ_de¡roy + ( +±h»ad_mu‹x©Œ_t + * +__©Œ +); + +562
+ `__±h»ad_mu‹x©Œ_£‰y³ + ( +±h»ad_mu‹x©Œ_t + * +__©Œ +, + +563 +__kšd +); + +565 #ifdeà +__USE_UNIX98 + + +566
+ `__±h»ad_rwlock_š™ + ( +±h»ad_rwlock_t + * +__rwlock +, + +567 +__cÚ¡ + +±h»ad_rwlock©Œ_t + * +__©Œ +); + +569
+ `__±h»ad_rwlock_de¡roy + ( +±h»ad_rwlock_t + * +__rwlock +); + +571
+ `__±h»ad_rwlock_rdlock + ( +±h»ad_rwlock_t + * +__rwlock +); + +573
+ `__±h»ad_rwlock_Œyrdlock + ( +±h»ad_rwlock_t + * +__rwlock +); + +575
+ `__±h»ad_rwlock_w¾ock + ( +±h»ad_rwlock_t + * +__rwlock +); + +577
+ `__±h»ad_rwlock_Œyw¾ock + ( +±h»ad_rwlock_t + * +__rwlock +); + +579
+ `__±h»ad_rwlock_uÆock + ( +±h»ad_rwlock_t + * +__rwlock +); + +582
+ `__±h»ad_key_ü—‹ + ( +±h»ad_key_t + * +__key +, + +583 (* +__de¡r_funùiÚ +) ( *)); + +585
+ `__±h»ad_£t¥ecific + ( +±h»ad_key_t + +__key +, + +586 +__cÚ¡ + * +__poš‹r +); + +588
* + `__±h»ad_g‘¥ecific + ( +±h»ad_key_t + +__key +); + +590
+ `__±h»ad_Úû + ( +±h»ad_Úû_t + * +__Úû_cÚŒÞ +, + +591 (* +__š™_routše +) ( )); + +593
+ `__±h»ad_©fÜk + ( (* +__´•¬e +) ( ), + +594 (* +__·»Á +) ( ), + +595 (* +__chžd +) ( )); + +601 #iâdeà +__NO_WEAK_PTHREAD_ALIASES + + +602 #ifdeà +w—k_ex‹º + + +603 #ià +_LIBC + + +604 + ~<bp-sym.h +> + +606 + #BP_SYM +( +sym +è + ) +sym + +608 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_mu‹x_š™ +)) + +609 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_mu‹x_de¡roy +)) + +610 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_mu‹x_lock +)) + +611 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_mu‹x_Œylock +)) + +612 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_mu‹x_uÆock +)) + +613 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_mu‹x©Œ_š™ +)) + +614 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_mu‹x©Œ_de¡roy +)) + +615 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_mu‹x©Œ_£‰y³ +)) + +616 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_rwlock_š™ +)) + +617 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_rwlock_de¡roy +)) + +618 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_rwlock_rdlock +)) + +619 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_rwlock_Œyrdlock +)) + +620 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_rwlock_w¾ock +)) + +621 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_rwlock_Œyw¾ock +)) + +622 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_rwlock_uÆock +)) + +623 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_key_ü—‹ +)) + +624 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_£t¥ecific +)) + +625 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_g‘¥ecific +)) + +626 + `w—k_ex‹º + ( + $BP_SYM + ( +__±h»ad_Úû +)) + +627 + $w—k_ex‹º + ( +__±h»ad_š™Ÿlize +) + +628 + $w—k_ex‹º + ( +__±h»ad_©fÜk +) + +629 + `w—k_ex‹º + ( + $BP_SYM + ( +_±h»ad_þ—nup_push_deãr +)) + +630 + `w—k_ex‹º + ( + $BP_SYM + ( +_±h»ad_þ—nup_pÝ_»¡Üe +)) + +631 + `w—k_ex‹º + ( + $BP_SYM + ( +±h»ad_£tÿnûl¡©e +)) + +633 #´agm¨ +w—k + +__±h»ad_mu‹x_š™ + + +634 #´agm¨ +w—k + +__±h»ad_mu‹x_de¡roy + + +635 #´agm¨ +w—k + +__±h»ad_mu‹x_lock + + +636 #´agm¨ +w—k + +__±h»ad_mu‹x_Œylock + + +637 #´agm¨ +w—k + +__±h»ad_mu‹x_uÆock + + +638 #´agm¨ +w—k + +__±h»ad_mu‹x©Œ_š™ + + +639 #´agm¨ +w—k + +__±h»ad_mu‹x©Œ_de¡roy + + +640 #´agm¨ +w—k + +__±h»ad_mu‹x©Œ_£‰y³ + + +641 #´agm¨ +w—k + +__±h»ad_rwlock_de¡roy + + +642 #´agm¨ +w—k + +__±h»ad_rwlock_rdlock + + +643 #´agm¨ +w—k + +__±h»ad_rwlock_Œyrdlock + + +644 #´agm¨ +w—k + +__±h»ad_rwlock_w¾ock + + +645 #´agm¨ +w—k + +__±h»ad_rwlock_Œyw¾ock + + +646 #´agm¨ +w—k + +__±h»ad_rwlock_uÆock + + +647 #´agm¨ +w—k + +__±h»ad_key_ü—‹ + + +648 #´agm¨ +w—k + +__±h»ad_£t¥ecific + + +649 #´agm¨ +w—k + +__±h»ad_g‘¥ecific + + +650 #´agm¨ +w—k + +__±h»ad_Úû + + +651 #´agm¨ +w—k + +__±h»ad_š™Ÿlize + + +652 #´agm¨ +w—k + +__±h»ad_©fÜk + + +653 #´agm¨ +w—k + +_±h»ad_þ—nup_push_deãr + + +654 #´agm¨ +w—k + +_±h»ad_þ—nup_pÝ_»¡Üe + + +655 #´agm¨ +w—k + +±h»ad_£tÿnûl¡©e + + + @/usr/include/bits/stdlib-ldbl.h + +20 #iâdeà +_STDLIB_H + + +24 #ifdef +__USE_ISOC99 + + +25 +__BEGIN_NAMESPACE_C99 + + +26 + $__LDBL_REDIR1_DECL + ( +¡¹Þd +, +¡¹od +) + +27 +__END_NAMESPACE_C99 + + +30 #ifdeà +__USE_GNU + + +31 + $__LDBL_REDIR1_DECL + ( +¡¹Þd_l +, +¡¹od_l +) + +34 #ià +defšed + +__USE_SVID + || defšed +__USE_XOPEN_EXTENDED + + +35 #ifdeà +__USE_MISC + + +36 + $__LDBL_REDIR1_DECL + ( +qecvt +, +ecvt +) + +37 + $__LDBL_REDIR1_DECL + ( +qfcvt +, +fcvt +) + +38 + $__LDBL_REDIR1_DECL + ( +qgcvt +, +gcvt +) + +39 + $__LDBL_REDIR1_DECL + ( +qecvt_r +, +ecvt_r +) + +40 + $__LDBL_REDIR1_DECL + ( +qfcvt_r +, +fcvt_r +) + + @/usr/include/bits/stdlib.h + +20 #iâdeà +_STDLIB_H + + +24
* + $__»®·th_chk + ( +__cÚ¡ + * +__»¡riù + +__Çme +, + +25 * +__»¡riù + +__»sÞved +, + +26 +size_t + +__»sÞvedËn +è +__THROW + +__wur +; + +27
* + `__REDIRECT_NTH + ( +__»®·th_®Ÿs +, + +28 ( +__cÚ¡ + * +__»¡riù + +__Çme +, + +29 * +__»¡riù + +__»sÞved +), +»®·th +è +__wur +; + +30
* + `__REDIRECT_NTH + ( +__»®·th_chk_w¬n +, + +31 ( +__cÚ¡ + * +__»¡riù + +__Çme +, + +32 * +__»¡riù + +__»sÞved +, + +33 +size_t + +__»sÞvedËn +), +__»®·th_chk +è +__wur + + +34 + `__w¬Ç‰r + ("second‡rgument of„ealpath must beƒither NULL or‡t " + +37 +__ex‹º_®ways_šlše + +__wur + * + +38 + `__NTH + ( + $»®·th + ( +__cÚ¡ + * +__»¡riù + +__Çme +, *__»¡riù +__»sÞved +)) + +40 ià( + `__bos + ( +__»sÞved +è!ð( +size_t +) -1) + +42 #ià +defšed + +_LIBC_LIMITS_H_ + && defšed +PATH_MAX + + +43 ià( + `__bos + ( +__»sÞved +è< +PATH_MAX +) + +44 + `__»®·th_chk_w¬n + ( +__Çme +, +__»sÞved +, + `__bos + (__resolved)); + +46 + `__»®·th_chk + ( +__Çme +, +__»sÞved +, + `__bos + (__resolved)); + +49 + `__»®·th_®Ÿs + ( +__Çme +, +__»sÞved +); + +50 + } +} + +53
+ $__±¢ame_r_chk + ( +__fd +, * +__buf +, +size_t + +__buæ’ +, + +54 +size_t + +__Ä—l +è +__THROW + + `__nÚnuÎ + ((2)); + +55
+ `__REDIRECT_NTH + ( +__±¢ame_r_®Ÿs +, ( +__fd +, * +__buf +, + +56 +size_t + +__buæ’ +), +±¢ame_r +) + +57 + `__nÚnuÎ + ((2)); + +58
+ `__REDIRECT_NTH + ( +__±¢ame_r_chk_w¬n +, + +59 ( +__fd +, * +__buf +, +size_t + +__buæ’ +, + +60 +size_t + +__Ä—l +), +__±¢ame_r_chk +) + +61 + `__nÚnuÎ + ((2)è + `__w¬Ç‰r + ("ptsname_r called with buflen biggerhan " + +64 +__ex‹º_®ways_šlše + + +65 + `__NTH + ( + $±¢ame_r + ( +__fd +, * +__buf +, +size_t + +__buæ’ +)) + +67 ià( + `__bos + ( +__buf +è!ð( +size_t +) -1) + +69 ià(! + `__bužtš_cÚ¡ªt_p + ( +__buæ’ +)) + +70 + `__±¢ame_r_chk + ( +__fd +, +__buf +, +__buæ’ +, + `__bos + (__buf)); + +71 ià( +__buæ’ + > + `__bos + ( +__buf +)) + +72 + `__±¢ame_r_chk_w¬n + ( +__fd +, +__buf +, +__buæ’ +, + `__bos + (__buf)); + +74 + `__±¢ame_r_®Ÿs + ( +__fd +, +__buf +, +__buæ’ +); + +75 + } +} + +78
+ $__wùomb_chk + (* +__s +, +wch¬_t + +__wch¬ +, +size_t + +__buæ’ +) + +79 +__THROW + +__wur +; + +80
+ `__REDIRECT_NTH + ( +__wùomb_®Ÿs +, (* +__s +, +wch¬_t + +__wch¬ +), + +81 +wùomb +è +__wur +; + +83 +__ex‹º_®ways_šlše + +__wur + + +84 + `__NTH + ( + $wùomb + (* +__s +, +wch¬_t + +__wch¬ +)) + +89 + #__STDLIB_MB_LEN_MAX + 16 + + ) + +90 #ià +defšed + +MB_LEN_MAX + && MB_LEN_MAX !ð +__STDLIB_MB_LEN_MAX + + +93 ià( + `__bos + ( +__s +è!ð( +size_t +è-1 && +__STDLIB_MB_LEN_MAX + > __bos (__s)) + +94 + `__wùomb_chk + ( +__s +, +__wch¬ +, + `__bos + (__s)); + +95 + `__wùomb_®Ÿs + ( +__s +, +__wch¬ +); + +96 + } +} + +99
+size_t + + $__mb¡owcs_chk + ( +wch¬_t + * +__»¡riù + +__d¡ +, + +100 +__cÚ¡ + * +__»¡riù + +__¤c +, + +101 +size_t + +__Ën +, size_ˆ +__d¡Ën +è +__THROW +; + +102
+size_t + + `__REDIRECT_NTH + ( +__mb¡owcs_®Ÿs +, + +103 ( +wch¬_t + * +__»¡riù + +__d¡ +, + +104 +__cÚ¡ + * +__»¡riù + +__¤c +, + +105 +size_t + +__Ën +), +mb¡owcs +); + +106
+size_t + + `__REDIRECT_NTH + ( +__mb¡owcs_chk_w¬n +, + +107 ( +wch¬_t + * +__»¡riù + +__d¡ +, + +108 +__cÚ¡ + * +__»¡riù + +__¤c +, + +109 +size_t + +__Ën +, size_ˆ +__d¡Ën +), +__mb¡owcs_chk +) + +110 + `__w¬Ç‰r + ("mbstowcs called with dst buffer smallerhan†en " + +113 +__ex‹º_®ways_šlše + +size_t + + +114 + `__NTH + ( + $mb¡owcs + ( +wch¬_t + * +__»¡riù + +__d¡ +, +__cÚ¡ + *__»¡riù +__¤c +, + +115 +size_t + +__Ën +)) + +117 ià( + `__bos + ( +__d¡ +è!ð( +size_t +) -1) + +119 ià(! + `__bužtš_cÚ¡ªt_p + ( +__Ën +)) + +120 + `__mb¡owcs_chk + ( +__d¡ +, +__¤c +, +__Ën +, + +121 + `__bos + ( +__d¡ +è/ ( +wch¬_t +)); + +123 ià( +__Ën + > + `__bos + ( +__d¡ +è/ ( +wch¬_t +)) + +124 + `__mb¡owcs_chk_w¬n + ( +__d¡ +, +__¤c +, +__Ën +, + +125 + `__bos + ( +__d¡ +è/ ( +wch¬_t +)); + +127 + `__mb¡owcs_®Ÿs + ( +__d¡ +, +__¤c +, +__Ën +); + +128 + } +} + +131
+size_t + + $__wc¡ombs_chk + (* +__»¡riù + +__d¡ +, + +132 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, + +133 +size_t + +__Ën +, size_ˆ +__d¡Ën +è +__THROW +; + +134
+size_t + + `__REDIRECT_NTH + ( +__wc¡ombs_®Ÿs +, + +135 (* +__»¡riù + +__d¡ +, + +136 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, + +137 +size_t + +__Ën +), +wc¡ombs +); + +138
+size_t + + `__REDIRECT_NTH + ( +__wc¡ombs_chk_w¬n +, + +139 (* +__»¡riù + +__d¡ +, + +140 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, + +141 +size_t + +__Ën +, size_ˆ +__d¡Ën +), +__wc¡ombs_chk +) + +142 + `__w¬Ç‰r + ("wcstombs called with dst buffer smallerhan†en"); + +144 +__ex‹º_®ways_šlše + +size_t + + +145 + `__NTH + ( + $wc¡ombs + (* +__»¡riù + +__d¡ +, +__cÚ¡ + +wch¬_t + *__»¡riù +__¤c +, + +146 +size_t + +__Ën +)) + +148 ià( + `__bos + ( +__d¡ +è!ð( +size_t +) -1) + +150 ià(! + `__bužtš_cÚ¡ªt_p + ( +__Ën +)) + +151 + `__wc¡ombs_chk + ( +__d¡ +, +__¤c +, +__Ën +, + `__bos + (__dst)); + +152 ià( +__Ën + > + `__bos + ( +__d¡ +)) + +153 + `__wc¡ombs_chk_w¬n + ( +__d¡ +, +__¤c +, +__Ën +, + `__bos + (__dst)); + +155 + `__wc¡ombs_®Ÿs + ( +__d¡ +, +__¤c +, +__Ën +); + +156 + } +} + + @/usr/include/bits/waitflags.h + +20 #ià! +defšed + +_SYS_WAIT_H + && !defšed +_STDLIB_H + + +26 + #WNOHANG + 1 + + ) + +27 + #WUNTRACED + 2 + + ) + +30 + #WSTOPPED + 2 + + ) + +31 + #WEXITED + 4 + + ) + +32 + #WCONTINUED + 8 + + ) + +33 + #WNOWAIT + 0x01000000 + + ) + +35 + #__WNOTHREAD + 0x20000000 + + ) + +37 + #__WALL + 0x40000000 + + ) + +38 + #__WCLONE + 0x80000000 + + ) + + @/usr/include/bits/waitstatus.h + +20 #ià! +defšed + +_SYS_WAIT_H + && !defšed +_STDLIB_H + + +29 + #__WEXITSTATUS +( +¡©us +è(((¡©usè& 0xff00è>> 8) + + ) + +32 + #__WTERMSIG +( +¡©us +è((¡©usè& 0x7f) + + ) + +35 + #__WSTOPSIG +( +¡©us +è + `__WEXITSTATUS +(¡©us) + + ) + +38 + #__WIFEXITED +( +¡©us +è( + `__WTERMSIG +(¡©usè=ð0) + + ) + +41 + #__WIFSIGNALED +( +¡©us +) \ + +42 (((sigÃd è((( +¡©us +è& 0x7fè+ 1è>> 1è> 0) + + ) + +45 + #__WIFSTOPPED +( +¡©us +è(((¡©usè& 0xffè=ð0x7f) + + ) + +49 #ifdeà +WCONTINUED + + +50 + #__WIFCONTINUED +( +¡©us +è((¡©usè=ð +__W_CONTINUED +) + + ) + +54 + #__WCOREDUMP +( +¡©us +è((¡©usè& +__WCOREFLAG +) + + ) + +57 + #__W_EXITCODE +( +»t +, +sig +è(Ô‘è<< 8 | (sig)) + + ) + +58 + #__W_STOPCODE +( +sig +è((sigè<< 8 | 0x7f) + + ) + +59 + #__W_CONTINUED + 0xffff + + ) + +60 + #__WCOREFLAG + 0x80 + + ) + +63 #ifdef +__USE_BSD + + +65 + ~<’dŸn.h +> + +67 + uwa™ + + +69 + mw_¡©us +; + +72 #if +__BYTE_ORDER + =ð +__LITTLE_ENDIAN + + +73 + m__w_‹rmsig +:7; + +74 + m__w_cÜedump +:1; + +75 + m__w_»tcode +:8; + +78 #if +__BYTE_ORDER + =ð +__BIG_ENDIAN + + +80 + m__w_»tcode +:8; + +81 + m__w_cÜedump +:1; + +82 + m__w_‹rmsig +:7; + +84 } + m__wa™_‹rmš©ed +; + +87 #if +__BYTE_ORDER + =ð +__LITTLE_ENDIAN + + +88 + m__w_¡Ýv® +:8; + +89 + m__w_¡Ýsig +:8; + +92 #if +__BYTE_ORDER + =ð +__BIG_ENDIAN + + +94 + m__w_¡Ýsig +:8; + +95 + m__w_¡Ýv® +:8; + +97 } + m__wa™_¡Ý³d +; + +100 + #w_‹rmsig + +__wa™_‹rmš©ed +. +__w_‹rmsig + + + ) + +101 + #w_cÜedump + +__wa™_‹rmš©ed +. +__w_cÜedump + + + ) + +102 + #w_»tcode + +__wa™_‹rmš©ed +. +__w_»tcode + + + ) + +103 + #w_¡Ýsig + +__wa™_¡Ý³d +. +__w_¡Ýsig + + + ) + +104 + #w_¡Ýv® + +__wa™_¡Ý³d +. +__w_¡Ýv® + + + ) + + @/usr/include/gconv.h + +23 #iâdeà +_GCONV_H + + +24 + #_GCONV_H + 1 + + ) + +26 + ~<ã©u»s.h +> + +27 + #__Ãed_mb¡©e_t + + + ) + +28 + #__Ãed_wšt_t + + + ) + +29 + ~<wch¬.h +> + +30 + #__Ãed_size_t + + + ) + +31 + #__Ãed_wch¬_t + + + ) + +32 + ~<¡ddef.h +> + +35 + #__UNKNOWN_10646_CHAR + (( +wch¬_t +è0xfffd) + + ) + +40 + m__GCONV_OK + = 0, + +41 + m__GCONV_NOCONV +, + +42 + m__GCONV_NODB +, + +43 + m__GCONV_NOMEM +, + +45 + m__GCONV_EMPTY_INPUT +, + +46 + m__GCONV_FULL_OUTPUT +, + +47 + m__GCONV_ILLEGAL_INPUT +, + +48 + m__GCONV_INCOMPLETE_INPUT +, + +50 + m__GCONV_ILLEGAL_DESCRIPTOR +, + +51 + m__GCONV_INTERNAL_ERROR + + +58 + m__GCONV_IS_LAST + = 0x0001, + +59 + m__GCONV_IGNORE_ERRORS + = 0x0002 + +64 + g__gcÚv_¡• +; + +65 + g__gcÚv_¡•_d©a +; + +66 + g__gcÚv_lßded_objeù +; + +67 + g__gcÚv_Œªs_d©a +; + +71 (* + t__gcÚv_fù +è( + t__gcÚv_¡• + *, + t__gcÚv_¡•_d©a + *, + +72 + t__cÚ¡ + **, __const *, + +73 **, + tsize_t + *, , ); + +76 + $wšt_t + (* + t__gcÚv_btowc_fù +è( + t__gcÚv_¡• + *, ); + +79 (* + t__gcÚv_š™_fù +è( + t__gcÚv_¡• + *); + +80 (* + t__gcÚv_’d_fù +è( + t__gcÚv_¡• + *); + +84 (* + t__gcÚv_Œªs_fù +è( + t__gcÚv_¡• + *, + +85 + t__gcÚv_¡•_d©a + *, *, + +86 + t__cÚ¡ + *, + +87 + t__cÚ¡ + **, + +88 + t__cÚ¡ + *, **, + +89 + tsize_t + *); + +92 (* + t__gcÚv_Œªs_cÚ‹xt_fù +è( *, + t__cÚ¡ + *, + +93 + t__cÚ¡ + *, + +97 (* + t__gcÚv_Œªs_qu”y_fù +è( + t__cÚ¡ + *, __const ***, + +98 + tsize_t + *); + +101 (* + t__gcÚv_Œªs_š™_fù +) ( **, const *); + +102 (* + t__gcÚv_Œªs_’d_fù +) ( *); + +104 + s__gcÚv_Œªs_d©a + + +107 +__gcÚv_Œªs_fù + +__Œªs_fù +; + +108 +__gcÚv_Œªs_cÚ‹xt_fù + +__Œªs_cÚ‹xt_fù +; + +109 +__gcÚv_Œªs_’d_fù + +__Œªs_’d_fù +; + +110 * +__d©a +; + +111 +__gcÚv_Œªs_d©a + * +__Ãxt +; + +116 + s__gcÚv_¡• + + +118 +__gcÚv_lßded_objeù + * +__shlib_hªdË +; + +119 +__cÚ¡ + * +__modÇme +; + +121 +__couÁ” +; + +123 * +__äom_Çme +; + +124 * +__to_Çme +; + +126 +__gcÚv_fù + +__fù +; + +127 +__gcÚv_btowc_fù + +__btowc_fù +; + +128 +__gcÚv_š™_fù + +__š™_fù +; + +129 +__gcÚv_’d_fù + +__’d_fù +; + +133 +__mš_Ãeded_äom +; + +134 +__max_Ãeded_äom +; + +135 +__mš_Ãeded_to +; + +136 +__max_Ãeded_to +; + +139 +__¡©eful +; + +141 * +__d©a +; + +146 + s__gcÚv_¡•_d©a + + +148 * +__outbuf +; + +149 * +__outbuãnd +; + +153 +__æags +; + +157 +__švoÿtiÚ_couÁ” +; + +161 +__š‹º®_u£ +; + +163 +__mb¡©e_t + * +__¡©• +; + +164 +__mb¡©e_t + +__¡©e +; + +168 +__gcÚv_Œªs_d©a + * +__Œªs +; + +173 + s__gcÚv_šfo + + +175 +size_t + +__n¡•s +; + +176 +__gcÚv_¡• + * +__¡•s +; + +177 +__ex‹nsiÚ__ + +__gcÚv_¡•_d©a + +__d©a + +__æex¬r +; + +178 } * + t__gcÚv_t +; + + @/usr/include/gnu/stubs-32.h + +6 #ifdeà +_LIBC + + +7 #”rÜ +AµliÿtiÚs + +may + +nÙ + +defše + +the + +maüo + +_LIBC + + +10 + #__¡ub___k”Ãl_co¦ + + + ) + +11 + #__¡ub___k”Ãl_sšl + + + ) + +12 + #__¡ub___k”Ãl_Æ + + + ) + +13 + #__¡ub_chæags + + + ) + +14 + #__¡ub_ç‰ach + + + ) + +15 + #__¡ub_fchæags + + + ) + +16 + #__¡ub_fd‘ach + + + ) + +17 + #__¡ub_g‰y + + + ) + +18 + #__¡ub_lchmod + + + ) + +19 + #__¡ub_»voke + + + ) + +20 + #__¡ub_£Žogš + + + ) + +21 + #__¡ub_sig»tuº + + + ) + +22 + #__¡ub_s¡k + + + ) + +23 + #__¡ub_¡ty + + + ) + + @/usr/include/gnu/stubs-64.h + +6 #ifdeà +_LIBC + + +7 #”rÜ +AµliÿtiÚs + +may + +nÙ + +defše + +the + +maüo + +_LIBC + + +10 + #__¡ub_bdæush + + + ) + +11 + #__¡ub_chæags + + + ) + +12 + #__¡ub_ç‰ach + + + ) + +13 + #__¡ub_fchæags + + + ) + +14 + #__¡ub_fd‘ach + + + ) + +15 + #__¡ub_g‘msg + + + ) + +16 + #__¡ub_g‰y + + + ) + +17 + #__¡ub_lchmod + + + ) + +18 + #__¡ub_putmsg + + + ) + +19 + #__¡ub_»voke + + + ) + +20 + #__¡ub_£Žogš + + + ) + +21 + #__¡ub_sig»tuº + + + ) + +22 + #__¡ub_s¡k + + + ) + +23 + #__¡ub_¡ty + + + ) + + @/usr/include/sys/types.h + +24 #iâdef +_SYS_TYPES_H + + +25 + #_SYS_TYPES_H + 1 + + ) + +27 + ~<ã©u»s.h +> + +29 + g__BEGIN_DECLS + + +31 + ~<b™s/ty³s.h +> + +33 #ifdef +__USE_BSD + + +34 #iâdeà +__u_ch¬_defšed + + +35 +__u_ch¬ + + tu_ch¬ +; + +36 +__u_shÜt + + tu_shÜt +; + +37 +__u_št + + tu_št +; + +38 +__u_lÚg + + tu_lÚg +; + +39 +__quad_t + + tquad_t +; + +40 +__u_quad_t + + tu_quad_t +; + +41 +__fsid_t + + tfsid_t +; + +42 + #__u_ch¬_defšed + + + ) + +46 +__loff_t + + tloff_t +; + +48 #iâdeà +__šo_t_defšed + + +49 #iâdeà +__USE_FILE_OFFSET64 + + +50 +__šo_t + + tšo_t +; + +52 +__šo64_t + + tšo_t +; + +54 + #__šo_t_defšed + + + ) + +56 #ià +defšed + +__USE_LARGEFILE64 + && !defšed +__šo64_t_defšed + + +57 +__šo64_t + + tšo64_t +; + +58 + #__šo64_t_defšed + + + ) + +61 #iâdeà +__dev_t_defšed + + +62 +__dev_t + + tdev_t +; + +63 + #__dev_t_defšed + + + ) + +66 #iâdeà +__gid_t_defšed + + +67 +__gid_t + + tgid_t +; + +68 + #__gid_t_defšed + + + ) + +71 #iâdeà +__mode_t_defšed + + +72 +__mode_t + + tmode_t +; + +73 + #__mode_t_defšed + + + ) + +76 #iâdeà +__Æšk_t_defšed + + +77 +__Æšk_t + + tÆšk_t +; + +78 + #__Æšk_t_defšed + + + ) + +81 #iâdeà +__uid_t_defšed + + +82 +__uid_t + + tuid_t +; + +83 + #__uid_t_defšed + + + ) + +86 #iâdeà +__off_t_defšed + + +87 #iâdeà +__USE_FILE_OFFSET64 + + +88 +__off_t + + toff_t +; + +90 +__off64_t + + toff_t +; + +92 + #__off_t_defšed + + + ) + +94 #ià +defšed + +__USE_LARGEFILE64 + && !defšed +__off64_t_defšed + + +95 +__off64_t + + toff64_t +; + +96 + #__off64_t_defšed + + + ) + +99 #iâdeà +__pid_t_defšed + + +100 +__pid_t + + tpid_t +; + +101 + #__pid_t_defšed + + + ) + +104 #ià( +defšed + +__USE_SVID + || defšed +__USE_XOPEN +è&& !defšed +__id_t_defšed + + +105 +__id_t + + tid_t +; + +106 + #__id_t_defšed + + + ) + +109 #iâdeà +__ssize_t_defšed + + +110 +__ssize_t + + tssize_t +; + +111 + #__ssize_t_defšed + + + ) + +114 #ifdef +__USE_BSD + + +115 #iâdeà +__daddr_t_defšed + + +116 +__daddr_t + + tdaddr_t +; + +117 +__ÿddr_t + + tÿddr_t +; + +118 + #__daddr_t_defšed + + + ) + +122 #ià( +defšed + +__USE_SVID + || defšed +__USE_XOPEN +è&& !defšed +__key_t_defšed + + +123 +__key_t + + tkey_t +; + +124 + #__key_t_defšed + + + ) + +127 #ifdeà +__USE_XOPEN + + +128 + #__Ãed_þock_t + + + ) + +130 + #__Ãed_time_t + + + ) + +131 + #__Ãed_tim”_t + + + ) + +132 + #__Ãed_þockid_t + + + ) + +133 + ~<time.h +> + +135 #ifdeà +__USE_XOPEN + + +136 #iâdeà +__u£cÚds_t_defšed + + +137 +__u£cÚds_t + + tu£cÚds_t +; + +138 + #__u£cÚds_t_defšed + + + ) + +140 #iâdeà +__su£cÚds_t_defšed + + +141 +__su£cÚds_t + + tsu£cÚds_t +; + +142 + #__su£cÚds_t_defšed + + + ) + +146 + #__Ãed_size_t + + + ) + +147 + ~<¡ddef.h +> + +149 #ifdeà +__USE_MISC + + +151 + tulÚg +; + +152 + tushÜt +; + +153 + tušt +; + +158 #ià! +__GNUC_PREREQ + (2, 7) + +161 #iâdeà +__št8_t_defšed + + +162 + #__št8_t_defšed + + + ) + +163 + tšt8_t +; + +164 + tšt16_t +; + +165 + tšt32_t +; + +166 #ià +__WORDSIZE + == 64 + +167 + tšt64_t +; + +168 #–ià +__GLIBC_HAVE_LONG_LONG + + +169 +__ex‹nsiÚ__ + + tšt64_t +; + +174 + tu_št8_t +; + +175 + tu_št16_t +; + +176 + tu_št32_t +; + +177 #ià +__WORDSIZE + == 64 + +178 + tu_št64_t +; + +179 #–ià +__GLIBC_HAVE_LONG_LONG + + +180 +__ex‹nsiÚ__ + + tu_št64_t +; + +183 + t»gi¡”_t +; + +188 + #__štN_t +( +N +, +MODE +) \ + +189 ## + tN +## + t_t + + t__©Œibu‹__ + (( + t__mode__ + ( + tMODE +))) + + ) + +190 + t__u_štN_t +( + tN +, + tMODE +) \ + +191 + tu_št +## + tN +## + t_t + + t__©Œibu‹__ + (( + t__mode__ + ( + tMODE +))) + + ) + +193 #iâdeà + t__št8_t_defšed + + +194 + t__št8_t_defšed + + + ) + +195 + t__štN_t + (8, + t__QI__ +); + +196 +__štN_t + (16, +__HI__ +); + +197 +__štN_t + (32, +__SI__ +); + +198 +__štN_t + (64, +__DI__ +); + +201 +__u_štN_t + (8, +__QI__ +); + +202 +__u_štN_t + (16, +__HI__ +); + +203 +__u_štN_t + (32, +__SI__ +); + +204 +__u_štN_t + (64, +__DI__ +); + +206 + t»gi¡”_t + + t__©Œibu‹__ + (( + t__mode__ + ( + t__wÜd__ +))); + +212 + #__BIT_TYPES_DEFINED__ + 1 + + ) + +215 #ifdef +__USE_BSD + + +217 + ~<’dŸn.h +> + +220 + ~<sys/£Ëù.h +> + +223 + ~<sys/sysmaüos.h +> + +227 #ià +defšed + +__USE_UNIX98 + && !defšed +__blksize_t_defšed + + +228 +__blksize_t + + tblksize_t +; + +229 + #__blksize_t_defšed + + + ) + +233 #iâdeà +__USE_FILE_OFFSET64 + + +234 #iâdeà +__blkút_t_defšed + + +235 +__blkút_t + + tblkút_t +; + +236 + #__blkút_t_defšed + + + ) + +238 #iâdeà +__fsblkút_t_defšed + + +239 +__fsblkút_t + + tfsblkút_t +; + +240 + #__fsblkút_t_defšed + + + ) + +242 #iâdeà +__fsfžút_t_defšed + + +243 +__fsfžút_t + + tfsfžút_t +; + +244 + #__fsfžút_t_defšed + + + ) + +247 #iâdeà +__blkút_t_defšed + + +248 +__blkút64_t + + tblkút_t +; + +249 + #__blkút_t_defšed + + + ) + +251 #iâdeà +__fsblkút_t_defšed + + +252 +__fsblkút64_t + + tfsblkút_t +; + +253 + #__fsblkút_t_defšed + + + ) + +255 #iâdeà +__fsfžút_t_defšed + + +256 +__fsfžút64_t + + tfsfžút_t +; + +257 + #__fsfžút_t_defšed + + + ) + +261 #ifdeà +__USE_LARGEFILE64 + + +262 +__blkút64_t + + tblkút64_t +; + +263 +__fsblkút64_t + + tfsblkút64_t +; + +264 +__fsfžút64_t + + tfsfžút64_t +; + +269 #ià +defšed + +__USE_POSIX199506 + || defšed +__USE_UNIX98 + + +270 + ~<b™s/±h»adty³s.h +> + +273 + g__END_DECLS + + + @/usr/include/wchar.h + +24 #iâdeà +_WCHAR_H + + +26 #ià! +defšed + +__Ãed_mb¡©e_t + && !defšed +__Ãed_wšt_t + + +27 + #_WCHAR_H + 1 + + ) + +28 + ~<ã©u»s.h +> + +31 #ifdeà +_WCHAR_H + + +33 + #__Ãed___FILE + + + ) + +34 #ià +defšed + +__USE_UNIX98 + || defšed +__USE_XOPEN2K + + +35 + #__Ãed_FILE + + + ) + +37 + ~<¡dio.h +> + +39 + #__Ãed___va_li¡ + + + ) + +40 + ~<¡d¬g.h +> + +42 + ~<b™s/wch¬.h +> + +45 + #__Ãed_size_t + + + ) + +46 + #__Ãed_wch¬_t + + + ) + +47 + #__Ãed_NULL + + + ) + +49 #ià +defšed + +_WCHAR_H + || defšed +__Ãed_wšt_t + || !defšed +__WINT_TYPE__ + + +50 #undeà +__Ãed_wšt_t + + +51 + #__Ãed_wšt_t + + + ) + +52 + ~<¡ddef.h +> + +55 #ià +defšed + +__ýlu¥lus + && +__GNUC_PREREQ + (4, 4) + +56 + #__CORRECT_ISO_CPP_WCHAR_H_PROTO + + + ) + +61 #iâdeà +_WINT_T + + +66 + #_WINT_T + + + ) + +67 + twšt_t +; + +71 #ià +defšed + +__ýlu¥lus + && defšed +_GLIBCPP_USE_NAMESPACES + \ + +72 && +defšed + +__WINT_TYPE__ + + +73 +__BEGIN_NAMESPACE_STD + + +74 +__WINT_TYPE__ + + twšt_t +; + +75 + g__END_NAMESPACE_STD + + +80 #ià( +defšed + +_WCHAR_H + || defšed +__Ãed_mb¡©e_t +è&& !defšed +__mb¡©e_t_defšed + + +81 + #__mb¡©e_t_defšed + 1 + + ) + +85 + m__couÁ +; + +88 #ifdeà +__WINT_TYPE__ + + +89 +__WINT_TYPE__ + + m__wch +; + +91 +wšt_t + + m__wch +; + +93 + m__wchb +[4]; + +94 } + m__v®ue +; + +95 } + t__mb¡©e_t +; + +97 #undeà +__Ãed_mb¡©e_t + + +102 #ifdeà +_WCHAR_H + + +104 +__BEGIN_NAMESPACE_C99 + + +106 +__mb¡©e_t + + tmb¡©e_t +; + +107 + g__END_NAMESPACE_C99 + + +108 #ifdeà +__USE_GNU + + +109 + $__USING_NAMESPACE_C99 +( +mb¡©e_t +) + +112 #iâdeà +WCHAR_MIN + + +114 + #WCHAR_MIN + +__WCHAR_MIN + + + ) + +115 + #WCHAR_MAX + +__WCHAR_MAX + + + ) + +118 #iâdeà +WEOF + + +119 + #WEOF + (0xffffffffu) + + ) + +124 #ià +defšed + +__USE_XOPEN + && !defšed +__USE_UNIX98 + + +125 + ~<wùy³.h +> + +129 +__BEGIN_DECLS + + +131 +__BEGIN_NAMESPACE_STD + + +134 +tm +; + +135 +__END_NAMESPACE_STD + + +139 + $__USING_NAMESPACE_STD +( +tm +) + +142 +__BEGIN_NAMESPACE_STD + + +144
+wch¬_t + * + $wcsýy + ( +wch¬_t + * +__»¡riù + +__de¡ +, + +145 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +è +__THROW +; + +147
+wch¬_t + * + $wc¢ýy + ( +wch¬_t + * +__»¡riù + +__de¡ +, + +148 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, +size_t + +__n +) + +149 +__THROW +; + +152
+wch¬_t + * + $wcsÿt + ( +wch¬_t + * +__»¡riù + +__de¡ +, + +153 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +è +__THROW +; + +155
+wch¬_t + * + $wc¢ÿt + ( +wch¬_t + * +__»¡riù + +__de¡ +, + +156 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, +size_t + +__n +) + +157 +__THROW +; + +160
+ $wcscmp + ( +__cÚ¡ + +wch¬_t + * +__s1 +, __cÚ¡ wch¬_ˆ* +__s2 +) + +161 +__THROW + +__©Œibu‹_pu»__ +; + +163
+ $wc¢cmp + ( +__cÚ¡ + +wch¬_t + * +__s1 +, __cÚ¡ wch¬_ˆ* +__s2 +, +size_t + +__n +) + +164 +__THROW + +__©Œibu‹_pu»__ +; + +165 +__END_NAMESPACE_STD + + +167 #ifdeà +__USE_XOPEN2K8 + + +169
+ $wcsÿ£cmp + ( +__cÚ¡ + +wch¬_t + * +__s1 +, __cÚ¡ wch¬_ˆ* +__s2 +è +__THROW +; + +172
+ $wc¢ÿ£cmp + ( +__cÚ¡ + +wch¬_t + * +__s1 +, __cÚ¡ wch¬_ˆ* +__s2 +, + +173 +size_t + +__n +è +__THROW +; + +177 + ~<xloÿË.h +> + +179
+ $wcsÿ£cmp_l + ( +__cÚ¡ + +wch¬_t + * +__s1 +, __cÚ¡ wch¬_ˆ* +__s2 +, + +180 +__loÿË_t + +__loc +è +__THROW +; + +182
+ $wc¢ÿ£cmp_l + ( +__cÚ¡ + +wch¬_t + * +__s1 +, __cÚ¡ wch¬_ˆ* +__s2 +, + +183 +size_t + +__n +, +__loÿË_t + +__loc +è +__THROW +; + +186 +__BEGIN_NAMESPACE_STD + + +189
+ $wcscÞl + ( +__cÚ¡ + +wch¬_t + * +__s1 +, __cÚ¡ wch¬_ˆ* +__s2 +è +__THROW +; + +193
+size_t + + $wcsxäm + ( +wch¬_t + * +__»¡riù + +__s1 +, + +194 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s2 +, +size_t + +__n +è +__THROW +; + +195 +__END_NAMESPACE_STD + + +197 #ifdeà +__USE_XOPEN2K8 + + +203
+ $wcscÞl_l + ( +__cÚ¡ + +wch¬_t + * +__s1 +, __cÚ¡ wch¬_ˆ* +__s2 +, + +204 +__loÿË_t + +__loc +è +__THROW +; + +209
+size_t + + $wcsxäm_l + ( +wch¬_t + * +__s1 +, +__cÚ¡ + wch¬_ˆ* +__s2 +, + +210 +size_t + +__n +, +__loÿË_t + +__loc +è +__THROW +; + +213
+wch¬_t + * + $wcsdup + ( +__cÚ¡ + +wch¬_t + * +__s +è +__THROW + +__©Œibu‹_m®loc__ +; + +216 +__BEGIN_NAMESPACE_STD + + +218 #ifdeà +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +219
"C++" +wch¬_t + * + $wcschr + ( +wch¬_t + * +__wcs +, wch¬_ˆ +__wc +) + +220 +__THROW + + `__asm + ("wcschr"è +__©Œibu‹_pu»__ +; + +221
"C++" +__cÚ¡ + +wch¬_t + * + $wcschr + ( +__cÚ¡ + +wch¬_t + * +__wcs +, wch¬_ˆ +__wc +) + +222 +__THROW + + `__asm + ("wcschr"è +__©Œibu‹_pu»__ +; + +224
+wch¬_t + * + $wcschr + ( +__cÚ¡ + +wch¬_t + * +__wcs +, wch¬_ˆ +__wc +) + +225 +__THROW + +__©Œibu‹_pu»__ +; + +228 #ifdeà +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +229
"C++" +wch¬_t + * + $wc¤chr + ( +wch¬_t + * +__wcs +, wch¬_ˆ +__wc +) + +230 +__THROW + + `__asm + ("wc¤chr"è +__©Œibu‹_pu»__ +; + +231
"C++" +__cÚ¡ + +wch¬_t + * + $wc¤chr + ( +__cÚ¡ + +wch¬_t + * +__wcs +, wch¬_ˆ +__wc +) + +232 +__THROW + + `__asm + ("wc¤chr"è +__©Œibu‹_pu»__ +; + +234
+wch¬_t + * + $wc¤chr + ( +__cÚ¡ + +wch¬_t + * +__wcs +, wch¬_ˆ +__wc +) + +235 +__THROW + +__©Œibu‹_pu»__ +; + +237 +__END_NAMESPACE_STD + + +239 #ifdeà +__USE_GNU + + +242
+wch¬_t + * + $wcschºul + ( +__cÚ¡ + +wch¬_t + * +__s +, wch¬_ˆ +__wc +) + +243 +__THROW + +__©Œibu‹_pu»__ +; + +246 +__BEGIN_NAMESPACE_STD + + +249
+size_t + + $wcsc¥n + ( +__cÚ¡ + +wch¬_t + * +__wcs +, __cÚ¡ wch¬_ˆ* +__»jeù +) + +250 +__THROW + +__©Œibu‹_pu»__ +; + +253
+size_t + + $wcs¥n + ( +__cÚ¡ + +wch¬_t + * +__wcs +, __cÚ¡ wch¬_ˆ* +__acû± +) + +254 +__THROW + +__©Œibu‹_pu»__ +; + +256 #ifdeà +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +257
"C++" +wch¬_t + * + $wc¥brk + ( +wch¬_t + * +__wcs +, +__cÚ¡ + wch¬_ˆ* +__acû± +) + +258 +__THROW + + `__asm + ("wc¥brk"è +__©Œibu‹_pu»__ +; + +259
"C++" +__cÚ¡ + +wch¬_t + * + $wc¥brk + ( +__cÚ¡ + +wch¬_t + * +__wcs +, + +260 +__cÚ¡ + +wch¬_t + * +__acû± +) + +261 +__THROW + + `__asm + ("wc¥brk"è +__©Œibu‹_pu»__ +; + +263
+wch¬_t + * + $wc¥brk + ( +__cÚ¡ + +wch¬_t + * +__wcs +, __cÚ¡ wch¬_ˆ* +__acû± +) + +264 +__THROW + +__©Œibu‹_pu»__ +; + +267 #ifdeà +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +268
"C++" +wch¬_t + * + $wcs¡r + ( +wch¬_t + * +__hay¡ack +, +__cÚ¡ + wch¬_ˆ* +__ÃedË +) + +269 +__THROW + + `__asm + ("wcs¡r"è +__©Œibu‹_pu»__ +; + +270
"C++" +__cÚ¡ + +wch¬_t + * + $wcs¡r + ( +__cÚ¡ + +wch¬_t + * +__hay¡ack +, + +271 +__cÚ¡ + +wch¬_t + * +__ÃedË +) + +272 +__THROW + + `__asm + ("wcs¡r"è +__©Œibu‹_pu»__ +; + +274
+wch¬_t + * + $wcs¡r + ( +__cÚ¡ + +wch¬_t + * +__hay¡ack +, __cÚ¡ wch¬_ˆ* +__ÃedË +) + +275 +__THROW + +__©Œibu‹_pu»__ +; + +279
+wch¬_t + * + $wc¡ok + ( +wch¬_t + * +__»¡riù + +__s +, + +280 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__d–im +, + +281 +wch¬_t + ** +__»¡riù + +__±r +è +__THROW +; + +284
+size_t + + $wc¦’ + ( +__cÚ¡ + +wch¬_t + * +__s +è +__THROW + +__©Œibu‹_pu»__ +; + +285 +__END_NAMESPACE_STD + + +287 #ifdeà +__USE_XOPEN + + +289 #ifdeà +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +290
"C++" +wch¬_t + * + $wcswcs + ( +wch¬_t + * +__hay¡ack +, +__cÚ¡ + wch¬_ˆ* +__ÃedË +) + +291 +__THROW + + `__asm + ("wcswcs"è +__©Œibu‹_pu»__ +; + +292
"C++" +__cÚ¡ + +wch¬_t + * + $wcswcs + ( +__cÚ¡ + +wch¬_t + * +__hay¡ack +, + +293 +__cÚ¡ + +wch¬_t + * +__ÃedË +) + +294 +__THROW + + `__asm + ("wcswcs"è +__©Œibu‹_pu»__ +; + +296
+wch¬_t + * + $wcswcs + ( +__cÚ¡ + +wch¬_t + * +__hay¡ack +, __cÚ¡ wch¬_ˆ* +__ÃedË +) + +297 +__THROW + +__©Œibu‹_pu»__ +; + +301 #ifdeà +__USE_XOPEN2K8 + + +303
+size_t + + $wc¢Ën + ( +__cÚ¡ + +wch¬_t + * +__s +, +size_t + +__maxËn +) + +304 +__THROW + +__©Œibu‹_pu»__ +; + +308 +__BEGIN_NAMESPACE_STD + + +310 #ifdeà +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +311
"C++" +wch¬_t + * + $wmemchr + ( +wch¬_t + * +__s +, wch¬_ˆ +__c +, +size_t + +__n +) + +312 +__THROW + + `__asm + ("wmemchr"è +__©Œibu‹_pu»__ +; + +313
"C++" +__cÚ¡ + +wch¬_t + * + $wmemchr + ( +__cÚ¡ + +wch¬_t + * +__s +, wch¬_ˆ +__c +, + +314 +size_t + +__n +) + +315 +__THROW + + `__asm + ("wmemchr"è +__©Œibu‹_pu»__ +; + +317
+wch¬_t + * + $wmemchr + ( +__cÚ¡ + +wch¬_t + * +__s +, wch¬_ˆ +__c +, +size_t + +__n +) + +318 +__THROW + +__©Œibu‹_pu»__ +; + +322
+ $wmemcmp + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s1 +, + +323 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s2 +, +size_t + +__n +) + +324 +__THROW + +__©Œibu‹_pu»__ +; + +327
+wch¬_t + * + $wmemýy + ( +wch¬_t + * +__»¡riù + +__s1 +, + +328 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s2 +, +size_t + +__n +è +__THROW +; + +332
+wch¬_t + * + $wmemmove + ( +wch¬_t + * +__s1 +, +__cÚ¡ + wch¬_ˆ* +__s2 +, +size_t + +__n +) + +333 +__THROW +; + +336
+wch¬_t + * + $wmem£t + ( +wch¬_t + * +__s +, wch¬_ˆ +__c +, +size_t + +__n +è +__THROW +; + +337 +__END_NAMESPACE_STD + + +339 #ifdeà +__USE_GNU + + +342
+wch¬_t + * + $wmempýy + ( +wch¬_t + * +__»¡riù + +__s1 +, + +343 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s2 +, +size_t + +__n +) + +344 +__THROW +; + +348 +__BEGIN_NAMESPACE_STD + + +351
+wšt_t + + $btowc + ( +__c +è +__THROW +; + +355
+ $wùob + ( +wšt_t + +__c +è +__THROW +; + +359
+ $mbsš™ + ( +__cÚ¡ + +mb¡©e_t + * +__ps +è +__THROW + +__©Œibu‹_pu»__ +; + +363
+size_t + + $mb¹owc + ( +wch¬_t + * +__»¡riù + +__pwc +, + +364 +__cÚ¡ + * +__»¡riù + +__s +, +size_t + +__n +, + +365 +mb¡©e_t + * +__p +è +__THROW +; + +368
+size_t + + $wütomb + (* +__»¡riù + +__s +, +wch¬_t + +__wc +, + +369 +mb¡©e_t + * +__»¡riù + +__ps +è +__THROW +; + +372
+size_t + + $__mb¾’ + ( +__cÚ¡ + * +__»¡riù + +__s +, +size_t + +__n +, + +373 +mb¡©e_t + * +__»¡riù + +__ps +è +__THROW +; + +374
+size_t + + $mb¾’ + ( +__cÚ¡ + * +__»¡riù + +__s +, +size_t + +__n +, + +375 +mb¡©e_t + * +__»¡riù + +__ps +è +__THROW +; + +376 +__END_NAMESPACE_STD + + +378 #ifdeà +__USE_EXTERN_INLINES + + +384
+wšt_t + + $__btowc_®Ÿs + ( +__c +è + `__asm + ("btowc"); + +385 +__ex‹º_šlše + +wšt_t + + +386 + `__NTH + ( + $btowc + ( +__c +)) + +387 { ( + `__bužtš_cÚ¡ªt_p + ( +__c +) && __c >= '\0' && __c <= '\x7f' + +388 ? ( +wšt_t +è +__c + : + `__btowc_®Ÿs + (__c)); + } +} + +390
+ $__wùob_®Ÿs + ( +wšt_t + +__c +è + `__asm + ("wctob"); + +391 +__ex‹º_šlše + + +392 + `__NTH + ( + $wùob + ( +wšt_t + +__wc +)) + +393 { ( + `__bužtš_cÚ¡ªt_p + ( +__wc +è&& __wø>ð +L +'\0' && __wc <= L'\x7f' + +394 ? (è +__wc + : + `__wùob_®Ÿs + (__wc)); + } +} + +396 +__ex‹º_šlše + +size_t + + +397 +__NTH + ( + $mb¾’ + ( +__cÚ¡ + * +__»¡riù + +__s +, +size_t + +__n +, + +398 +mb¡©e_t + * +__»¡riù + +__ps +)) + +399 { ( +__ps + !ð +NULL + + +400 ? + `mb¹owc + ( +NULL +, +__s +, +__n +, +__ps +è: + `__mb¾’ + (__s, __n, NULL)); + } +} + +403 +__BEGIN_NAMESPACE_STD + + +406
+size_t + + $mb¤towcs + ( +wch¬_t + * +__»¡riù + +__d¡ +, + +407 +__cÚ¡ + ** +__»¡riù + +__¤c +, +size_t + +__Ën +, + +408 +mb¡©e_t + * +__»¡riù + +__ps +è +__THROW +; + +412
+size_t + + $wc¤tombs + (* +__»¡riù + +__d¡ +, + +413 +__cÚ¡ + +wch¬_t + ** +__»¡riù + +__¤c +, +size_t + +__Ën +, + +414 +mb¡©e_t + * +__»¡riù + +__ps +è +__THROW +; + +415 +__END_NAMESPACE_STD + + +418 #ifdef +__USE_XOPEN2K8 + + +421
+size_t + + $mb¢¹owcs + ( +wch¬_t + * +__»¡riù + +__d¡ +, + +422 +__cÚ¡ + ** +__»¡riù + +__¤c +, +size_t + +__nmc +, + +423 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +è +__THROW +; + +427
+size_t + + $wc¢¹ombs + (* +__»¡riù + +__d¡ +, + +428 +__cÚ¡ + +wch¬_t + ** +__»¡riù + +__¤c +, + +429 +size_t + +__nwc +, size_ˆ +__Ën +, + +430 +mb¡©e_t + * +__»¡riù + +__ps +è +__THROW +; + +435 #ifdeà +__USE_XOPEN + + +437
+ $wcwidth + ( +wch¬_t + +__c +è +__THROW +; + +441
+ $wcswidth + ( +__cÚ¡ + +wch¬_t + * +__s +, +size_t + +__n +è +__THROW +; + +445 +__BEGIN_NAMESPACE_STD + + +448
+ $wc¡od + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +449 +wch¬_t + ** +__»¡riù + +__’d±r +è +__THROW +; + +450 +__END_NAMESPACE_STD + + +452 #ifdeà +__USE_ISOC99 + + +453 +__BEGIN_NAMESPACE_C99 + + +455
+ $wc¡of + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +456 +wch¬_t + ** +__»¡riù + +__’d±r +è +__THROW +; + +457
+ $wc¡Þd + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +458 +wch¬_t + ** +__»¡riù + +__’d±r +è +__THROW +; + +459 +__END_NAMESPACE_C99 + + +463 +__BEGIN_NAMESPACE_STD + + +466
+ $wc¡Þ + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +467 +wch¬_t + ** +__»¡riù + +__’d±r +, +__ba£ +è +__THROW +; + +471
+ $wc¡oul + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +472 +wch¬_t + ** +__»¡riù + +__’d±r +, +__ba£ +) + +473 +__THROW +; + +474 +__END_NAMESPACE_STD + + +476 #ià +defšed + +__USE_ISOC99 + || (defšed +__GNUC__ + && defšed +__USE_GNU +) + +477 +__BEGIN_NAMESPACE_C99 + + +480 +__ex‹nsiÚ__ + + +481
+ $wc¡Þl + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +482 +wch¬_t + ** +__»¡riù + +__’d±r +, +__ba£ +) + +483 +__THROW +; + +487 +__ex‹nsiÚ__ + + +488
+ $wc¡ouÎ + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +489 +wch¬_t + ** +__»¡riù + +__’d±r +, + +490 +__ba£ +è +__THROW +; + +491 +__END_NAMESPACE_C99 + + +494 #ià +defšed + +__GNUC__ + && defšed +__USE_GNU + + +497 +__ex‹nsiÚ__ + + +498
+ $wc¡oq + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +499 +wch¬_t + ** +__»¡riù + +__’d±r +, +__ba£ +) + +500 +__THROW +; + +504 +__ex‹nsiÚ__ + + +505
+ $wc¡ouq + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +506 +wch¬_t + ** +__»¡riù + +__’d±r +, + +507 +__ba£ +è +__THROW +; + +510 #ifdeà +__USE_GNU + + +524 + ~<xloÿË.h +> + +528
+ $wc¡Þ_l + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +529 +wch¬_t + ** +__»¡riù + +__’d±r +, +__ba£ +, + +530 +__loÿË_t + +__loc +è +__THROW +; + +532
+ $wc¡oul_l + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +533 +wch¬_t + ** +__»¡riù + +__’d±r +, + +534 +__ba£ +, +__loÿË_t + +__loc +è +__THROW +; + +536 +__ex‹nsiÚ__ + + +537
+ $wc¡Þl_l + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +538 +wch¬_t + ** +__»¡riù + +__’d±r +, + +539 +__ba£ +, +__loÿË_t + +__loc +è +__THROW +; + +541 +__ex‹nsiÚ__ + + +542
+ $wc¡ouÎ_l + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +543 +wch¬_t + ** +__»¡riù + +__’d±r +, + +544 +__ba£ +, +__loÿË_t + +__loc +) + +545 +__THROW +; + +547
+ $wc¡od_l + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +548 +wch¬_t + ** +__»¡riù + +__’d±r +, +__loÿË_t + +__loc +) + +549 +__THROW +; + +551
+ $wc¡of_l + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +552 +wch¬_t + ** +__»¡riù + +__’d±r +, +__loÿË_t + +__loc +) + +553 +__THROW +; + +555
+ $wc¡Þd_l + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ÅŒ +, + +556 +wch¬_t + ** +__»¡riù + +__’d±r +, + +557 +__loÿË_t + +__loc +è +__THROW +; + +561 #ifdef +__USE_XOPEN2K8 + + +564
+wch¬_t + * + $wýýy + ( +wch¬_t + * +__de¡ +, +__cÚ¡ + wch¬_ˆ* +__¤c +è +__THROW +; + +568
+wch¬_t + * + $wýnýy + ( +wch¬_t + * +__de¡ +, +__cÚ¡ + wch¬_ˆ* +__¤c +, +size_t + +__n +) + +569 +__THROW +; + +575 #ifdef +__USE_XOPEN2K8 + + +578
+__FILE + * + $Ý’_wmem¡»am + ( +wch¬_t + ** +__buæoc +, +size_t + * +__siz–oc +è +__THROW +; + +581 #ià +defšed + +__USE_ISOC95 + || defšed +__USE_UNIX98 + + +582 +__BEGIN_NAMESPACE_STD + + +585
+ $fwide + ( +__FILE + * +__å +, +__mode +è +__THROW +; + +592
+ `fw´štf + ( +__FILE + * +__»¡riù + +__¡»am +, + +593 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...) + +599
+ `w´štf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...) + +602
+ $sw´štf + ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__n +, + +603 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...) + +604 +__THROW + ; + +610
+ `vfw´štf + ( +__FILE + * +__»¡riù + +__s +, + +611 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +612 +__gnuc_va_li¡ + +__¬g +) + +618
+ `vw´štf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +619 +__gnuc_va_li¡ + +__¬g +) + +623
+ $vsw´štf + ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__n +, + +624 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +625 +__gnuc_va_li¡ + +__¬g +) + +626 +__THROW + ; + +633
+ `fwsÿnf + ( +__FILE + * +__»¡riù + +__¡»am +, + +634 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...) + +640
+ `wsÿnf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...) + +643
+ $swsÿnf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s +, + +644 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...) + +645 +__THROW + ; + +647 #ià +defšed + +__USE_ISOC99 + && !defšed +__USE_GNU + \ + +648 && (! +defšed + +__LDBL_COMPAT + || !defšed +__REDIRECT +) \ + +649 && ( +defšed + +__STRICT_ANSI__ + || defšed +__USE_XOPEN2K +) + +650 #ifdeà +__REDIRECT + + +654
+ `__REDIRECT + ( +fwsÿnf +, ( +__FILE + * +__»¡riù + +__¡»am +, + +655 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...), + +656 +__isoc99_fwsÿnf +) + +658
+ `__REDIRECT + ( +wsÿnf +, ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...), + +659 +__isoc99_wsÿnf +) + +661
+ `__REDIRECT + ( +swsÿnf +, ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s +, + +662 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...), + +663 +__isoc99_swsÿnf +) + +664 +__THROW + ; + +666
+ `__isoc99_fwsÿnf + ( +__FILE + * +__»¡riù + +__¡»am +, + +667 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...); + +668
+ `__isoc99_wsÿnf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...); + +669
+ $__isoc99_swsÿnf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s +, + +670 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...) + +671 +__THROW +; + +672 + #fwsÿnf + +__isoc99_fwsÿnf + + + ) + +673 + #wsÿnf + +__isoc99_wsÿnf + + + ) + +674 + #swsÿnf + +__isoc99_swsÿnf + + + ) + +678 +__END_NAMESPACE_STD + + +681 #ifdeà +__USE_ISOC99 + + +682 +__BEGIN_NAMESPACE_C99 + + +687
+ `vfwsÿnf + ( +__FILE + * +__»¡riù + +__s +, + +688 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +689 +__gnuc_va_li¡ + +__¬g +) + +695
+ `vwsÿnf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +696 +__gnuc_va_li¡ + +__¬g +) + +699
+ $vswsÿnf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s +, + +700 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +701 +__gnuc_va_li¡ + +__¬g +) + +702 +__THROW + ; + +704 #ià! +defšed + +__USE_GNU + \ + +705 && (! +defšed + +__LDBL_COMPAT + || !defšed +__REDIRECT +) \ + +706 && ( +defšed + +__STRICT_ANSI__ + || defšed +__USE_XOPEN2K +) + +707 #ifdeà +__REDIRECT + + +708
+ `__REDIRECT + ( +vfwsÿnf +, ( +__FILE + * +__»¡riù + +__s +, + +709 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +710 +__gnuc_va_li¡ + +__¬g +), +__isoc99_vfwsÿnf +) + +712
+ `__REDIRECT + ( +vwsÿnf +, ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +713 +__gnuc_va_li¡ + +__¬g +), +__isoc99_vwsÿnf +) + +715
+ `__REDIRECT + ( +vswsÿnf +, ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s +, + +716 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +717 +__gnuc_va_li¡ + +__¬g +), +__isoc99_vswsÿnf +) + +718 +__THROW + ; + +720
+ `__isoc99_vfwsÿnf + ( +__FILE + * +__»¡riù + +__s +, + +721 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +722 +__gnuc_va_li¡ + +__¬g +); + +723
+ `__isoc99_vwsÿnf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +724 +__gnuc_va_li¡ + +__¬g +); + +725
+ $__isoc99_vswsÿnf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s +, + +726 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +727 +__gnuc_va_li¡ + +__¬g +è +__THROW +; + +728 + #vfwsÿnf + +__isoc99_vfwsÿnf + + + ) + +729 + #vwsÿnf + +__isoc99_vwsÿnf + + + ) + +730 + #vswsÿnf + +__isoc99_vswsÿnf + + + ) + +734 +__END_NAMESPACE_C99 + + +738 +__BEGIN_NAMESPACE_STD + + +743
+wšt_t + + `fg‘wc + ( +__FILE + * +__¡»am +); + +744
+wšt_t + + `g‘wc + ( +__FILE + * +__¡»am +); + +750
+wšt_t + + `g‘wch¬ + ( ); + +757
+wšt_t + + `åutwc + ( +wch¬_t + +__wc +, +__FILE + * +__¡»am +); + +758
+wšt_t + + `putwc + ( +wch¬_t + +__wc +, +__FILE + * +__¡»am +); + +764
+wšt_t + + `putwch¬ + ( +wch¬_t + +__wc +); + +772
+wch¬_t + * + `fg‘ws + (wch¬_ˆ* +__»¡riù + +__ws +, +__n +, + +773 +__FILE + * +__»¡riù + +__¡»am +); + +779
+ `åutws + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ws +, + +780 +__FILE + * +__»¡riù + +__¡»am +); + +787
+wšt_t + + `ung‘wc + (wšt_ˆ +__wc +, +__FILE + * +__¡»am +); + +788 +__END_NAMESPACE_STD + + +791 #ifdeà +__USE_GNU + + +799
+wšt_t + + `g‘wc_uÆocked + ( +__FILE + * +__¡»am +); + +800
+wšt_t + + `g‘wch¬_uÆocked + ( ); + +808
+wšt_t + + `fg‘wc_uÆocked + ( +__FILE + * +__¡»am +); + +816
+wšt_t + + `åutwc_uÆocked + ( +wch¬_t + +__wc +, +__FILE + * +__¡»am +); + +825
+wšt_t + + `putwc_uÆocked + ( +wch¬_t + +__wc +, +__FILE + * +__¡»am +); + +826
+wšt_t + + `putwch¬_uÆocked + ( +wch¬_t + +__wc +); + +835
+wch¬_t + * + `fg‘ws_uÆocked + (wch¬_ˆ* +__»¡riù + +__ws +, +__n +, + +836 +__FILE + * +__»¡riù + +__¡»am +); + +844
+ `åutws_uÆocked + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__ws +, + +845 +__FILE + * +__»¡riù + +__¡»am +); + +849 +__BEGIN_NAMESPACE_C99 + + +853
+size_t + + $wcsáime + ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__maxsize +, + +854 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +855 +__cÚ¡ + +tm + * +__»¡riù + +__ +è +__THROW +; + +856 +__END_NAMESPACE_C99 + + +858 #ifdeà +__USE_GNU + + +859 + ~<xloÿË.h +> + +863
+size_t + + $wcsáime_l + ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__maxsize +, + +864 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +865 +__cÚ¡ + +tm + * +__»¡riù + +__ +, + +866 +__loÿË_t + +__loc +è +__THROW +; + +875 #ià +defšed + +__USE_UNIX98 + && !defšed +__USE_GNU + + +876 + #__Ãed_iswxxx + + + ) + +877 + ~<wùy³.h +> + +881 #ià +__USE_FORTIFY_LEVEL + > 0 && +defšed + +__ex‹º_®ways_šlše + + +882 + ~<b™s/wch¬2.h +> + +885 #ifdeà +__LDBL_COMPAT + + +886 + ~<b™s/wch¬-ldbl.h +> + +889 +__END_DECLS + + +897 #undeà +__Ãed_mb¡©e_t + + +898 #undeà +__Ãed_wšt_t + + + @/usr/include/bits/pthreadtypes.h + +20 #iâdeà +_BITS_PTHREADTYPES_H + + +21 + #_BITS_PTHREADTYPES_H + 1 + + ) + +23 + ~<b™s/wÜdsize.h +> + +25 #ià +__WORDSIZE + == 64 + +26 + #__SIZEOF_PTHREAD_ATTR_T + 56 + + ) + +27 + #__SIZEOF_PTHREAD_MUTEX_T + 40 + + ) + +28 + #__SIZEOF_PTHREAD_MUTEXATTR_T + 4 + + ) + +29 + #__SIZEOF_PTHREAD_COND_T + 48 + + ) + +30 + #__SIZEOF_PTHREAD_CONDATTR_T + 4 + + ) + +31 + #__SIZEOF_PTHREAD_RWLOCK_T + 56 + + ) + +32 + #__SIZEOF_PTHREAD_RWLOCKATTR_T + 8 + + ) + +33 + #__SIZEOF_PTHREAD_BARRIER_T + 32 + + ) + +34 + #__SIZEOF_PTHREAD_BARRIERATTR_T + 4 + + ) + +36 + #__SIZEOF_PTHREAD_ATTR_T + 36 + + ) + +37 + #__SIZEOF_PTHREAD_MUTEX_T + 24 + + ) + +38 + #__SIZEOF_PTHREAD_MUTEXATTR_T + 4 + + ) + +39 + #__SIZEOF_PTHREAD_COND_T + 48 + + ) + +40 + #__SIZEOF_PTHREAD_CONDATTR_T + 4 + + ) + +41 + #__SIZEOF_PTHREAD_RWLOCK_T + 32 + + ) + +42 + #__SIZEOF_PTHREAD_RWLOCKATTR_T + 8 + + ) + +43 + #__SIZEOF_PTHREAD_BARRIER_T + 20 + + ) + +44 + #__SIZEOF_PTHREAD_BARRIERATTR_T + 4 + + ) + +50 + t±h»ad_t +; + +55 + m__size +[ +__SIZEOF_PTHREAD_ATTR_T +]; + +56 + m__®ign +; + +57 } + t±h»ad_©Œ_t +; + +60 #ià +__WORDSIZE + == 64 + +61 + s__±h»ad_š‹º®_li¡ + + +63 +__±h»ad_š‹º®_li¡ + * + m__´ev +; + +64 +__±h»ad_š‹º®_li¡ + * + m__Ãxt +; + +65 } + t__±h»ad_li¡_t +; + +67 + s__±h»ad_š‹º®_¦i¡ + + +69 +__±h»ad_š‹º®_¦i¡ + * + m__Ãxt +; + +70 } + t__±h»ad_¦i¡_t +; + +78 + s__±h»ad_mu‹x_s + + +80 + m__lock +; + +81 + m__couÁ +; + +82 + m__owÃr +; + +83 #ià +__WORDSIZE + == 64 + +84 + m__nu£rs +; + +88 + m__kšd +; + +89 #ià +__WORDSIZE + == 64 + +90 + m__¥šs +; + +91 +__±h»ad_li¡_t + + m__li¡ +; + +92 + #__PTHREAD_MUTEX_HAVE_PREV + 1 + + ) + +94 + m__nu£rs +; + +95 +__ex‹nsiÚ__ + union + +97 + m__¥šs +; + +98 +__±h»ad_¦i¡_t + + m__li¡ +; + +101 } + m__d©a +; + +102 + m__size +[ +__SIZEOF_PTHREAD_MUTEX_T +]; + +103 + m__®ign +; + +104 } + t±h»ad_mu‹x_t +; + +108 + m__size +[ +__SIZEOF_PTHREAD_MUTEXATTR_T +]; + +109 + m__®ign +; + +110 } + t±h»ad_mu‹x©Œ_t +; + +119 + m__lock +; + +120 + m__fu‹x +; + +121 +__ex‹nsiÚ__ + + m__tÙ®_£q +; + +122 +__ex‹nsiÚ__ + + m__wakeup_£q +; + +123 +__ex‹nsiÚ__ + + m__wok’_£q +; + +124 * + m__mu‹x +; + +125 + m__nwa™”s +; + +126 + m__brßdÿ¡_£q +; + +127 } + m__d©a +; + +128 + m__size +[ +__SIZEOF_PTHREAD_COND_T +]; + +129 +__ex‹nsiÚ__ + + m__®ign +; + +130 } + t±h»ad_cÚd_t +; + +134 + m__size +[ +__SIZEOF_PTHREAD_CONDATTR_T +]; + +135 + m__®ign +; + +136 } + t±h»ad_cÚd©Œ_t +; + +140 + t±h»ad_key_t +; + +144 + t±h»ad_Úû_t +; + +147 #ià +defšed + +__USE_UNIX98 + || defšed +__USE_XOPEN2K + + +152 #ià +__WORDSIZE + == 64 + +155 + m__lock +; + +156 + m__Ä_»ad”s +; + +157 + m__»ad”s_wakeup +; + +158 + m__wr™”_wakeup +; + +159 + m__Ä_»ad”s_queued +; + +160 + m__Ä_wr™”s_queued +; + +161 + m__wr™” +; + +162 + m__sh¬ed +; + +163 + m__·d1 +; + +164 + m__·d2 +; + +167 + m__æags +; + +168 } + m__d©a +; + +172 + m__lock +; + +173 + m__Ä_»ad”s +; + +174 + m__»ad”s_wakeup +; + +175 + m__wr™”_wakeup +; + +176 + m__Ä_»ad”s_queued +; + +177 + m__Ä_wr™”s_queued +; + +180 + m__æags +; + +181 + m__sh¬ed +; + +182 + m__·d1 +; + +183 + m__·d2 +; + +184 + m__wr™” +; + +185 } + m__d©a +; + +187 + m__size +[ +__SIZEOF_PTHREAD_RWLOCK_T +]; + +188 + m__®ign +; + +189 } + t±h»ad_rwlock_t +; + +193 + m__size +[ +__SIZEOF_PTHREAD_RWLOCKATTR_T +]; + +194 + m__®ign +; + +195 } + t±h»ad_rwlock©Œ_t +; + +199 #ifdeà +__USE_XOPEN2K + + +201 vÞ©ž + t±h»ad_¥šlock_t +; + +208 + m__size +[ +__SIZEOF_PTHREAD_BARRIER_T +]; + +209 + m__®ign +; + +210 } + t±h»ad_b¬r›r_t +; + +214 + m__size +[ +__SIZEOF_PTHREAD_BARRIERATTR_T +]; + +215 + m__®ign +; + +216 } + t±h»ad_b¬r›¿‰r_t +; + +220 #ià +__WORDSIZE + == 32 + +222 + #__þ—nup_fù_©Œibu‹ + + `__©Œibu‹__ + (( + `__»g·rm__ + (1))) + + ) + + @/usr/include/bits/wchar-ldbl.h + +20 #iâdeà +_WCHAR_H + + +24 #ià +defšed + +__USE_ISOC95 + || defšed +__USE_UNIX98 + + +25 +__BEGIN_NAMESPACE_C99 + + +26 +__LDBL_REDIR_DECL + ( +fw´štf +); + +27 +__LDBL_REDIR_DECL + ( +w´štf +); + +28 +__LDBL_REDIR_DECL + ( +sw´štf +); + +29 +__LDBL_REDIR_DECL + ( +vfw´štf +); + +30 +__LDBL_REDIR_DECL + ( +vw´štf +); + +31 +__LDBL_REDIR_DECL + ( +vsw´štf +); + +32 #ià +defšed + +__USE_ISOC99 + && !defšed +__USE_GNU + \ + +33 && ! +defšed + + g__REDIRECT + \ + +34 && ( +defšed + + g__STRICT_ANSI__ + || defšed + g__USE_XOPEN2K +) + +35 + $__LDBL_REDIR1_DECL + ( +fwsÿnf +, +__Ædbl___isoc99_fwsÿnf +) + +36 + $__LDBL_REDIR1_DECL + ( +wsÿnf +, +__Ædbl___isoc99_wsÿnf +) + +37 + $__LDBL_REDIR1_DECL + ( +swsÿnf +, +__Ædbl___isoc99_swsÿnf +) + +39 + `__LDBL_REDIR_DECL + ( +fwsÿnf +); + +40 + `__LDBL_REDIR_DECL + ( +wsÿnf +); + +41 + `__LDBL_REDIR_DECL + ( +swsÿnf +); + +43 +__END_NAMESPACE_C99 + + +46 #ifdeà +__USE_ISOC99 + + +47 +__BEGIN_NAMESPACE_C99 + + +48 + `__LDBL_REDIR1_DECL + ( +wc¡Þd +, +wc¡od +); + +49 #ià! +defšed + +__USE_GNU + && !defšed +__REDIRECT + \ + +50 && ( +defšed + +__STRICT_ANSI__ + || defšed +__USE_XOPEN2K +) + +51 + $__LDBL_REDIR1_DECL + ( +vfwsÿnf +, +__Ædbl___isoc99_vfwsÿnf +) + +52 + $__LDBL_REDIR1_DECL + ( +vwsÿnf +, +__Ædbl___isoc99_vwsÿnf +) + +53 + $__LDBL_REDIR1_DECL + ( +vswsÿnf +, +__Ædbl___isoc99_vswsÿnf +) + +55 + `__LDBL_REDIR_DECL + ( +vfwsÿnf +); + +56 + `__LDBL_REDIR_DECL + ( +vwsÿnf +); + +57 + `__LDBL_REDIR_DECL + ( +vswsÿnf +); + +59 +__END_NAMESPACE_C99 + + +62 #ifdeà +__USE_GNU + + +63 + `__LDBL_REDIR1_DECL + ( +wc¡Þd_l +, +wc¡od_l +); + +66 #ià +__USE_FORTIFY_LEVEL + > 0 && +defšed + +__ex‹º_®ways_šlše + + +67 + $__LDBL_REDIR_DECL + ( +__sw´štf_chk +) + +68 + $__LDBL_REDIR_DECL + ( +__vsw´štf_chk +) + +69 #ià +__USE_FORTIFY_LEVEL + > 1 + +70 + $__LDBL_REDIR_DECL + ( +__fw´štf_chk +) + +71 + $__LDBL_REDIR_DECL + ( +__w´štf_chk +) + +72 + $__LDBL_REDIR_DECL + ( +__vfw´štf_chk +) + +73 + $__LDBL_REDIR_DECL + ( +__vw´štf_chk +) + + @/usr/include/bits/wchar.h + +20 #iâdeà +_BITS_WCHAR_H + + +21 + #_BITS_WCHAR_H + 1 + + ) + +24 #ifdeà +__WCHAR_MAX__ + + +25 + #__WCHAR_MAX + +__WCHAR_MAX__ + + + ) + +27 + #__WCHAR_MAX + (2147483647) + + ) + +32 #ifdeà +__WCHAR_UNSIGNED__ + + +33 + #__WCHAR_MIN + +L +'\0' + + ) + +37 #–ià +L +'\0' - 1 > 0 + +38 + #__WCHAR_MIN + +L +'\0' + + ) + +40 + #__WCHAR_MIN + (- +__WCHAR_MAX + - 1) + + ) + + @/usr/include/bits/wchar2.h + +20 #iâdeà +_WCHAR_H + + +25
+wch¬_t + * + $__wmemýy_chk + ( +wch¬_t + * +__»¡riù + +__s1 +, + +26 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s2 +, +size_t + +__n +, + +27 +size_t + +__ns1 +è +__THROW +; + +28
+wch¬_t + * + `__REDIRECT_NTH + ( +__wmemýy_®Ÿs +, + +29 ( +wch¬_t + * +__»¡riù + +__s1 +, + +30 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s2 +, +size_t + +__n +), + +31 +wmemýy +); + +32
+wch¬_t + * + `__REDIRECT_NTH + ( +__wmemýy_chk_w¬n +, + +33 ( +wch¬_t + * +__»¡riù + +__s1 +, + +34 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s2 +, +size_t + +__n +, + +35 +size_t + +__ns1 +), +__wmemýy_chk +) + +36 + `__w¬Ç‰r + ("wmemcpy called with†ength biggerhan size of destination " + +39 +__ex‹º_®ways_šlše + +wch¬_t + * + +40 + `__NTH + ( + $wmemýy + ( +wch¬_t + * +__»¡riù + +__s1 +, +__cÚ¡ + wch¬_ˆ*__»¡riù +__s2 +, + +41 +size_t + +__n +)) + +43 ià( + `__bos0 + ( +__s1 +è!ð( +size_t +) -1) + +45 ià(! + `__bužtš_cÚ¡ªt_p + ( +__n +)) + +46 + `__wmemýy_chk + ( +__s1 +, +__s2 +, +__n +, + +47 + `__bos0 + ( +__s1 +è/ ( +wch¬_t +)); + +49 ià( +__n + > + `__bos0 + ( +__s1 +è/ ( +wch¬_t +)) + +50 + `__wmemýy_chk_w¬n + ( +__s1 +, +__s2 +, +__n +, + +51 + `__bos0 + ( +__s1 +è/ ( +wch¬_t +)); + +53 + `__wmemýy_®Ÿs + ( +__s1 +, +__s2 +, +__n +); + +54 + } +} + +57
+wch¬_t + * + $__wmemmove_chk + ( +wch¬_t + * +__s1 +, +__cÚ¡ + wch¬_ˆ* +__s2 +, + +58 +size_t + +__n +, size_ˆ +__ns1 +è +__THROW +; + +59
+wch¬_t + * + `__REDIRECT_NTH + ( +__wmemmove_®Ÿs +, (wch¬_ˆ* +__s1 +, + +60 +__cÚ¡ + +wch¬_t + * +__s2 +, + +61 +size_t + +__n +), +wmemmove +); + +62
+wch¬_t + * + `__REDIRECT_NTH + ( +__wmemmove_chk_w¬n +, + +63 ( +wch¬_t + * +__»¡riù + +__s1 +, + +64 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s2 +, +size_t + +__n +, + +65 +size_t + +__ns1 +), +__wmemmove_chk +) + +66 + `__w¬Ç‰r + ("wmemmove called with†ength biggerhan size of destination " + +69 +__ex‹º_®ways_šlše + +wch¬_t + * + +70 + `__NTH + ( + $wmemmove + ( +wch¬_t + * +__»¡riù + +__s1 +, +__cÚ¡ + wch¬_ˆ*__»¡riù +__s2 +, + +71 +size_t + +__n +)) + +73 ià( + `__bos0 + ( +__s1 +è!ð( +size_t +) -1) + +75 ià(! + `__bužtš_cÚ¡ªt_p + ( +__n +)) + +76 + `__wmemmove_chk + ( +__s1 +, +__s2 +, +__n +, + +77 + `__bos0 + ( +__s1 +è/ ( +wch¬_t +)); + +79 ià( +__n + > + `__bos0 + ( +__s1 +è/ ( +wch¬_t +)) + +80 + `__wmemmove_chk_w¬n + ( +__s1 +, +__s2 +, +__n +, + +81 + `__bos0 + ( +__s1 +è/ ( +wch¬_t +)); + +83 + `__wmemmove_®Ÿs + ( +__s1 +, +__s2 +, +__n +); + +84 + } +} + +87 #ifdeà +__USE_GNU + + +88
+wch¬_t + * + $__wmempýy_chk + ( +wch¬_t + * +__»¡riù + +__s1 +, + +89 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s2 +, +size_t + +__n +, + +90 +size_t + +__ns1 +è +__THROW +; + +91
+wch¬_t + * + `__REDIRECT_NTH + ( +__wmempýy_®Ÿs +, + +92 ( +wch¬_t + * +__»¡riù + +__s1 +, + +93 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s2 +, + +94 +size_t + +__n +), +wmempýy +); + +95
+wch¬_t + * + `__REDIRECT_NTH + ( +__wmempýy_chk_w¬n +, + +96 ( +wch¬_t + * +__»¡riù + +__s1 +, + +97 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__s2 +, +size_t + +__n +, + +98 +size_t + +__ns1 +), +__wmempýy_chk +) + +99 + `__w¬Ç‰r + ("wmempcpy called with†ength biggerhan size of destination " + +102 +__ex‹º_®ways_šlše + +wch¬_t + * + +103 + `__NTH + ( + $wmempýy + ( +wch¬_t + * +__»¡riù + +__s1 +, +__cÚ¡ + wch¬_ˆ*__»¡riù +__s2 +, + +104 +size_t + +__n +)) + +106 ià( + `__bos0 + ( +__s1 +è!ð( +size_t +) -1) + +108 ià(! + `__bužtš_cÚ¡ªt_p + ( +__n +)) + +109 + `__wmempýy_chk + ( +__s1 +, +__s2 +, +__n +, + +110 + `__bos0 + ( +__s1 +è/ ( +wch¬_t +)); + +112 ià( +__n + > + `__bos0 + ( +__s1 +è/ ( +wch¬_t +)) + +113 + `__wmempýy_chk_w¬n + ( +__s1 +, +__s2 +, +__n +, + +114 + `__bos0 + ( +__s1 +è/ ( +wch¬_t +)); + +116 + `__wmempýy_®Ÿs + ( +__s1 +, +__s2 +, +__n +); + +117 + } +} + +121
+wch¬_t + * + $__wmem£t_chk + ( +wch¬_t + * +__s +, wch¬_ˆ +__c +, +size_t + +__n +, + +122 +size_t + +__ns +è +__THROW +; + +123
+wch¬_t + * + `__REDIRECT_NTH + ( +__wmem£t_®Ÿs +, (wch¬_ˆ* +__s +, wch¬_ˆ +__c +, + +124 +size_t + +__n +), +wmem£t +); + +125
+wch¬_t + * + `__REDIRECT_NTH + ( +__wmem£t_chk_w¬n +, + +126 ( +wch¬_t + * +__s +, wch¬_ˆ +__c +, +size_t + +__n +, + +127 +size_t + +__ns +), +__wmem£t_chk +) + +128 + `__w¬Ç‰r + ("wmemset called with†ength biggerhan size of destination " + +131 +__ex‹º_®ways_šlše + +wch¬_t + * + +132 + `__NTH + ( + $wmem£t + ( +wch¬_t + * +__»¡riù + +__s +, wch¬_ˆ +__c +, +size_t + +__n +)) + +134 ià( + `__bos0 + ( +__s +è!ð( +size_t +) -1) + +136 ià(! + `__bužtš_cÚ¡ªt_p + ( +__n +)) + +137 + `__wmem£t_chk + ( +__s +, +__c +, +__n +, + `__bos0 + (__sè/ ( +wch¬_t +)); + +139 ià( +__n + > + `__bos0 + ( +__s +è/ ( +wch¬_t +)) + +140 + `__wmem£t_chk_w¬n + ( +__s +, +__c +, +__n +, + +141 + `__bos0 + ( +__s +è/ ( +wch¬_t +)); + +143 + `__wmem£t_®Ÿs + ( +__s +, +__c +, +__n +); + +144 + } +} + +147
+wch¬_t + * + $__wcsýy_chk + ( +wch¬_t + * +__»¡riù + +__de¡ +, + +148 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, + +149 +size_t + +__n +è +__THROW +; + +150
+wch¬_t + * + `__REDIRECT_NTH + ( +__wcsýy_®Ÿs +, + +151 ( +wch¬_t + * +__»¡riù + +__de¡ +, + +152 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +), +wcsýy +); + +154 +__ex‹º_®ways_šlše + +wch¬_t + * + +155 + `__NTH + ( + $wcsýy + ( +wch¬_t + * +__de¡ +, +__cÚ¡ + wch¬_ˆ* +__¤c +)) + +157 ià( + `__bos + ( +__de¡ +è!ð( +size_t +) -1) + +158 + `__wcsýy_chk + ( +__de¡ +, +__¤c +, + `__bos + (__de¡è/ ( +wch¬_t +)); + +159 + `__wcsýy_®Ÿs + ( +__de¡ +, +__¤c +); + +160 + } +} + +163
+wch¬_t + * + $__wýýy_chk + ( +wch¬_t + * +__de¡ +, +__cÚ¡ + wch¬_ˆ* +__¤c +, + +164 +size_t + +__de¡Ën +è +__THROW +; + +165
+wch¬_t + * + `__REDIRECT_NTH + ( +__wýýy_®Ÿs +, (wch¬_ˆ* +__de¡ +, + +166 +__cÚ¡ + +wch¬_t + * +__¤c +), + +167 +wýýy +); + +169 +__ex‹º_®ways_šlše + +wch¬_t + * + +170 + `__NTH + ( + $wýýy + ( +wch¬_t + * +__de¡ +, +__cÚ¡ + wch¬_ˆ* +__¤c +)) + +172 ià( + `__bos + ( +__de¡ +è!ð( +size_t +) -1) + +173 + `__wýýy_chk + ( +__de¡ +, +__¤c +, + `__bos + (__de¡è/ ( +wch¬_t +)); + +174 + `__wýýy_®Ÿs + ( +__de¡ +, +__¤c +); + +175 + } +} + +178
+wch¬_t + * + $__wc¢ýy_chk + ( +wch¬_t + * +__»¡riù + +__de¡ +, + +179 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, +size_t + +__n +, + +180 +size_t + +__de¡Ën +è +__THROW +; + +181
+wch¬_t + * + `__REDIRECT_NTH + ( +__wc¢ýy_®Ÿs +, + +182 ( +wch¬_t + * +__»¡riù + +__de¡ +, + +183 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, + +184 +size_t + +__n +), +wc¢ýy +); + +185
+wch¬_t + * + `__REDIRECT_NTH + ( +__wc¢ýy_chk_w¬n +, + +186 ( +wch¬_t + * +__»¡riù + +__de¡ +, + +187 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, + +188 +size_t + +__n +, size_ˆ +__de¡Ën +), +__wc¢ýy_chk +) + +189 + `__w¬Ç‰r + ("wcsncpy called with†ength biggerhan size of destination " + +192 +__ex‹º_®ways_šlše + +wch¬_t + * + +193 + `__NTH + ( + $wc¢ýy + ( +wch¬_t + * +__de¡ +, +__cÚ¡ + wch¬_ˆ* +__¤c +, +size_t + +__n +)) + +195 ià( + `__bos + ( +__de¡ +è!ð( +size_t +) -1) + +197 ià(! + `__bužtš_cÚ¡ªt_p + ( +__n +)) + +198 + `__wc¢ýy_chk + ( +__de¡ +, +__¤c +, +__n +, + +199 + `__bos + ( +__de¡ +è/ ( +wch¬_t +)); + +200 ià( +__n + > + `__bos + ( +__de¡ +è/ ( +wch¬_t +)) + +201 + `__wc¢ýy_chk_w¬n + ( +__de¡ +, +__¤c +, +__n +, + +202 + `__bos + ( +__de¡ +è/ ( +wch¬_t +)); + +204 + `__wc¢ýy_®Ÿs + ( +__de¡ +, +__¤c +, +__n +); + +205 + } +} + +208
+wch¬_t + * + $__wýnýy_chk + ( +wch¬_t + * +__»¡riù + +__de¡ +, + +209 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, +size_t + +__n +, + +210 +size_t + +__de¡Ën +è +__THROW +; + +211
+wch¬_t + * + `__REDIRECT_NTH + ( +__wýnýy_®Ÿs +, + +212 ( +wch¬_t + * +__»¡riù + +__de¡ +, + +213 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, + +214 +size_t + +__n +), +wýnýy +); + +215
+wch¬_t + * + `__REDIRECT_NTH + ( +__wýnýy_chk_w¬n +, + +216 ( +wch¬_t + * +__»¡riù + +__de¡ +, + +217 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, + +218 +size_t + +__n +, size_ˆ +__de¡Ën +), +__wýnýy_chk +) + +219 + `__w¬Ç‰r + ("wcpncpy called with†ength biggerhan size of destination " + +222 +__ex‹º_®ways_šlše + +wch¬_t + * + +223 + `__NTH + ( + $wýnýy + ( +wch¬_t + * +__de¡ +, +__cÚ¡ + wch¬_ˆ* +__¤c +, +size_t + +__n +)) + +225 ià( + `__bos + ( +__de¡ +è!ð( +size_t +) -1) + +227 ià(! + `__bužtš_cÚ¡ªt_p + ( +__n +)) + +228 + `__wýnýy_chk + ( +__de¡ +, +__¤c +, +__n +, + +229 + `__bos + ( +__de¡ +è/ ( +wch¬_t +)); + +230 ià( +__n + > + `__bos + ( +__de¡ +è/ ( +wch¬_t +)) + +231 + `__wýnýy_chk_w¬n + ( +__de¡ +, +__¤c +, +__n +, + +232 + `__bos + ( +__de¡ +è/ ( +wch¬_t +)); + +234 + `__wýnýy_®Ÿs + ( +__de¡ +, +__¤c +, +__n +); + +235 + } +} + +238
+wch¬_t + * + $__wcsÿt_chk + ( +wch¬_t + * +__»¡riù + +__de¡ +, + +239 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, + +240 +size_t + +__de¡Ën +è +__THROW +; + +241
+wch¬_t + * + `__REDIRECT_NTH + ( +__wcsÿt_®Ÿs +, + +242 ( +wch¬_t + * +__»¡riù + +__de¡ +, + +243 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +), +wcsÿt +); + +245 +__ex‹º_®ways_šlše + +wch¬_t + * + +246 + `__NTH + ( + $wcsÿt + ( +wch¬_t + * +__de¡ +, +__cÚ¡ + wch¬_ˆ* +__¤c +)) + +248 ià( + `__bos + ( +__de¡ +è!ð( +size_t +) -1) + +249 + `__wcsÿt_chk + ( +__de¡ +, +__¤c +, + `__bos + (__de¡è/ ( +wch¬_t +)); + +250 + `__wcsÿt_®Ÿs + ( +__de¡ +, +__¤c +); + +251 + } +} + +254
+wch¬_t + * + $__wc¢ÿt_chk + ( +wch¬_t + * +__»¡riù + +__de¡ +, + +255 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, + +256 +size_t + +__n +, size_ˆ +__de¡Ën +è +__THROW +; + +257
+wch¬_t + * + `__REDIRECT_NTH + ( +__wc¢ÿt_®Ÿs +, + +258 ( +wch¬_t + * +__»¡riù + +__de¡ +, + +259 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__¤c +, + +260 +size_t + +__n +), +wc¢ÿt +); + +262 +__ex‹º_®ways_šlše + +wch¬_t + * + +263 + `__NTH + ( + $wc¢ÿt + ( +wch¬_t + * +__de¡ +, +__cÚ¡ + wch¬_ˆ* +__¤c +, +size_t + +__n +)) + +265 ià( + `__bos + ( +__de¡ +è!ð( +size_t +) -1) + +266 + `__wc¢ÿt_chk + ( +__de¡ +, +__¤c +, +__n +, + +267 + `__bos + ( +__de¡ +è/ ( +wch¬_t +)); + +268 + `__wc¢ÿt_®Ÿs + ( +__de¡ +, +__¤c +, +__n +); + +269 + } +} + +272
+ $__sw´štf_chk + ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__n +, + +273 +__æag +, +size_t + +__s_Ën +, + +274 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...) + +275 +__THROW + ; + +277
+ `__REDIRECT_NTH_LDBL + ( +__sw´štf_®Ÿs +, + +278 ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__n +, + +279 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fmt +, ...), + +280 +sw´štf +); + +282 #ifdeà +__va_¬g_·ck + + +283 +__ex‹º_®ways_šlše + + +284 + `__NTH + ( + $sw´štf + ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__n +, + +285 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fmt +, ...)) + +287 ià( + `__bos + ( +__s +è!ð( +size_t +è-1 || +__USE_FORTIFY_LEVEL + > 1) + +288 + `__sw´štf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +289 + `__bos + ( +__s +è/ ( +wch¬_t +), + +290 +__fmt +, + `__va_¬g_·ck + ()); + +291 + `__sw´štf_®Ÿs + ( +__s +, +__n +, +__fmt +, + `__va_¬g_·ck + ()); + +292 + } +} + +293 #–ià! +defšed + +__ýlu¥lus + + +295 + #sw´štf +( +s +, +n +, ...) \ + +296 ( + `__bos + ( +s +è!ð( +size_t +è-1 || +__USE_FORTIFY_LEVEL + > 1 \ + +297 ? + `__sw´štf_chk + ( +s +, +n +, +__USE_FORTIFY_LEVEL + - 1, \ + +298 + `__bos + ( +s +è/ ( +wch¬_t +), +__VA_ARGS__ +) \ + +299 : + `sw´štf + ( +s +, +n +, +__VA_ARGS__ +)) + + ) + +302
+ $__vsw´štf_chk + ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__n +, + +303 +__æag +, +size_t + +__s_Ën +, + +304 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +305 +__gnuc_va_li¡ + +__¬g +) + +306 +__THROW + ; + +308
+ `__REDIRECT_NTH_LDBL + ( +__vsw´štf_®Ÿs +, + +309 ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__n +, + +310 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fmt +, + +311 +__gnuc_va_li¡ + +__ +), +vsw´štf +); + +313 +__ex‹º_®ways_šlše + + +314 + `__NTH + ( + $vsw´štf + ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__n +, + +315 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fmt +, +__gnuc_va_li¡ + +__ +)) + +317 ià( + `__bos + ( +__s +è!ð( +size_t +è-1 || +__USE_FORTIFY_LEVEL + > 1) + +318 + `__vsw´štf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +319 + `__bos + ( +__s +è/ ( +wch¬_t +), +__fmt +, +__ +); + +320 + `__vsw´štf_®Ÿs + ( +__s +, +__n +, +__fmt +, +__ +); + +321 + } +} + +324 #ià +__USE_FORTIFY_LEVEL + > 1 + +326
+__fw´štf_chk + ( +__FILE + * +__»¡riù + +__¡»am +, +__æag +, + +327 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, ...); + +328
+__w´štf_chk + ( +__æag +, +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +330
+__vfw´štf_chk + ( +__FILE + * +__»¡riù + +__¡»am +, +__æag +, + +331 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +332 +__gnuc_va_li¡ + +__ +); + +333
+__vw´štf_chk + ( +__æag +, +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fÜm© +, + +334 +__gnuc_va_li¡ + +__ +); + +336 #ifdeà +__va_¬g_·ck + + +337 +__ex‹º_®ways_šlše + + +338 + $w´štf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fmt +, ...) + +340 + `__w´štf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + `__va_¬g_·ck + ()); + +341 + } +} + +343 +__ex‹º_®ways_šlše + + +344 + $fw´štf + ( +__FILE + * +__»¡riù + +__¡»am +, +__cÚ¡ + +wch¬_t + *__»¡riù +__fmt +, ...) + +346 + `__fw´štf_chk + ( +__¡»am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +347 + `__va_¬g_·ck + ()); + +348 + } +} + +349 #–ià! +defšed + +__ýlu¥lus + + +350 + #w´štf +(...) \ + +351 + `__w´štf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +352 + #fw´štf +( +¡»am +, ...) \ + +353 + `__fw´štf_chk + ( +¡»am +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +356 +__ex‹º_®ways_šlše + + +357 + $vw´štf + ( +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fmt +, +__gnuc_va_li¡ + +__ +) + +359 + `__vw´štf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +360 + } +} + +362 +__ex‹º_®ways_šlše + + +363 + $vfw´štf + ( +__FILE + * +__»¡riù + +__¡»am +, + +364 +__cÚ¡ + +wch¬_t + * +__»¡riù + +__fmt +, +__gnuc_va_li¡ + +__ +) + +366 + `__vfw´štf_chk + ( +__¡»am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +367 + } +} + +371
+wch¬_t + * + $__fg‘ws_chk + ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__size +, +__n +, + +372 +__FILE + * +__»¡riù + +__¡»am +è +__wur +; + +373
+wch¬_t + * + `__REDIRECT + ( +__fg‘ws_®Ÿs +, + +374 ( +wch¬_t + * +__»¡riù + +__s +, +__n +, + +375 +__FILE + * +__»¡riù + +__¡»am +), +fg‘ws +è +__wur +; + +376
+wch¬_t + * + `__REDIRECT + ( +__fg‘ws_chk_w¬n +, + +377 ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__size +, +__n +, + +378 +__FILE + * +__»¡riù + +__¡»am +), +__fg‘ws_chk +) + +379 +__wur + + `__w¬Ç‰r + ("fgetws called with bigger sizehan†ength " + +382 +__ex‹º_®ways_šlše + +__wur + +wch¬_t + * + +383 + $fg‘ws + ( +wch¬_t + * +__»¡riù + +__s +, +__n +, +__FILE + *__»¡riù +__¡»am +) + +385 ià( + `__bos + ( +__s +è!ð( +size_t +) -1) + +387 ià(! + `__bužtš_cÚ¡ªt_p + ( +__n +) || __n <= 0) + +388 + `__fg‘ws_chk + ( +__s +, + `__bos + (__sè/ ( +wch¬_t +), + +389 +__n +, +__¡»am +); + +391 ià(( +size_t +è +__n + > + `__bos + ( +__s +è/ ( +wch¬_t +)) + +392 + `__fg‘ws_chk_w¬n + ( +__s +, + `__bos + (__sè/ ( +wch¬_t +), + +393 +__n +, +__¡»am +); + +395 + `__fg‘ws_®Ÿs + ( +__s +, +__n +, +__¡»am +); + +396 + } +} + +398 #ifdeà +__USE_GNU + + +399
+wch¬_t + * + $__fg‘ws_uÆocked_chk + ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__size +, + +400 +__n +, +__FILE + * +__»¡riù + +__¡»am +) + +401 +__wur +; + +402
+wch¬_t + * + `__REDIRECT + ( +__fg‘ws_uÆocked_®Ÿs +, + +403 ( +wch¬_t + * +__»¡riù + +__s +, +__n +, + +404 +__FILE + * +__»¡riù + +__¡»am +), +fg‘ws_uÆocked +) + +405 +__wur +; + +406
+wch¬_t + * + `__REDIRECT + ( +__fg‘ws_uÆocked_chk_w¬n +, + +407 ( +wch¬_t + * +__»¡riù + +__s +, +size_t + +__size +, +__n +, + +408 +__FILE + * +__»¡riù + +__¡»am +), + +409 +__fg‘ws_uÆocked_chk +) + +410 +__wur + + `__w¬Ç‰r + ("fgetws_unlocked called with bigger sizehan†ength " + +413 +__ex‹º_®ways_šlše + +__wur + +wch¬_t + * + +414 + $fg‘ws_uÆocked + ( +wch¬_t + * +__»¡riù + +__s +, +__n +, +__FILE + *__»¡riù +__¡»am +) + +416 ià( + `__bos + ( +__s +è!ð( +size_t +) -1) + +418 ià(! + `__bužtš_cÚ¡ªt_p + ( +__n +) || __n <= 0) + +419 + `__fg‘ws_uÆocked_chk + ( +__s +, + `__bos + (__sè/ ( +wch¬_t +), + +420 +__n +, +__¡»am +); + +422 ià(( +size_t +è +__n + > + `__bos + ( +__s +è/ ( +wch¬_t +)) + +423 + `__fg‘ws_uÆocked_chk_w¬n + ( +__s +, + `__bos + (__sè/ ( +wch¬_t +), + +424 +__n +, +__¡»am +); + +426 + `__fg‘ws_uÆocked_®Ÿs + ( +__s +, +__n +, +__¡»am +); + +427 + } +} + +431
+size_t + + $__wütomb_chk + (* +__s +, +wch¬_t + +__wch¬ +, +mb¡©e_t + * +__p +, + +432 +size_t + +__buæ’ +è +__THROW + +__wur +; + +433
+size_t + + `__REDIRECT_NTH + ( +__wütomb_®Ÿs +, + +434 (* +__»¡riù + +__s +, +wch¬_t + +__wch¬ +, + +435 +mb¡©e_t + * +__»¡riù + +__ps +), +wütomb +è +__wur +; + +437 +__ex‹º_®ways_šlše + +__wur + +size_t + + +438 + `__NTH + ( + $wütomb + (* +__s +, +wch¬_t + +__wch¬ +, +mb¡©e_t + * +__ps +)) + +443 + #__WCHAR_MB_LEN_MAX + 16 + + ) + +444 #ià +defšed + +MB_LEN_MAX + && MB_LEN_MAX !ð +__WCHAR_MB_LEN_MAX + + +447 ià( + `__bos + ( +__s +è!ð( +size_t +è-1 && +__WCHAR_MB_LEN_MAX + > __bos (__s)) + +448 + `__wütomb_chk + ( +__s +, +__wch¬ +, +__ps +, + `__bos + (__s)); + +449 + `__wütomb_®Ÿs + ( +__s +, +__wch¬ +, +__ps +); + +450 + } +} + +453
+size_t + + $__mb¤towcs_chk + ( +wch¬_t + * +__»¡riù + +__d¡ +, + +454 +__cÚ¡ + ** +__»¡riù + +__¤c +, + +455 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +, + +456 +size_t + +__d¡Ën +è +__THROW +; + +457
+size_t + + `__REDIRECT_NTH + ( +__mb¤towcs_®Ÿs +, + +458 ( +wch¬_t + * +__»¡riù + +__d¡ +, + +459 +__cÚ¡ + ** +__»¡riù + +__¤c +, + +460 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +), + +461 +mb¤towcs +); + +462
+size_t + + `__REDIRECT_NTH + ( +__mb¤towcs_chk_w¬n +, + +463 ( +wch¬_t + * +__»¡riù + +__d¡ +, + +464 +__cÚ¡ + ** +__»¡riù + +__¤c +, + +465 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +, + +466 +size_t + +__d¡Ën +), +__mb¤towcs_chk +) + +467 + `__w¬Ç‰r + ("mbsrtowcs called with dst buffer smallerhan†en " + +470 +__ex‹º_®ways_šlše + +size_t + + +471 + `__NTH + ( + $mb¤towcs + ( +wch¬_t + * +__»¡riù + +__d¡ +, +__cÚ¡ + **__»¡riù +__¤c +, + +472 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +)) + +474 ià( + `__bos + ( +__d¡ +è!ð( +size_t +) -1) + +476 ià(! + `__bužtš_cÚ¡ªt_p + ( +__Ën +)) + +477 + `__mb¤towcs_chk + ( +__d¡ +, +__¤c +, +__Ën +, +__ps +, + +478 + `__bos + ( +__d¡ +è/ ( +wch¬_t +)); + +480 ià( +__Ën + > + `__bos + ( +__d¡ +è/ ( +wch¬_t +)) + +481 + `__mb¤towcs_chk_w¬n + ( +__d¡ +, +__¤c +, +__Ën +, +__ps +, + +482 + `__bos + ( +__d¡ +è/ ( +wch¬_t +)); + +484 + `__mb¤towcs_®Ÿs + ( +__d¡ +, +__¤c +, +__Ën +, +__ps +); + +485 + } +} + +488
+size_t + + $__wc¤tombs_chk + (* +__»¡riù + +__d¡ +, + +489 +__cÚ¡ + +wch¬_t + ** +__»¡riù + +__¤c +, + +490 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +, + +491 +size_t + +__d¡Ën +è +__THROW +; + +492
+size_t + + `__REDIRECT_NTH + ( +__wc¤tombs_®Ÿs +, + +493 (* +__»¡riù + +__d¡ +, + +494 +__cÚ¡ + +wch¬_t + ** +__»¡riù + +__¤c +, + +495 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +), + +496 +wc¤tombs +); + +497
+size_t + + `__REDIRECT_NTH + ( +__wc¤tombs_chk_w¬n +, + +498 (* +__»¡riù + +__d¡ +, + +499 +__cÚ¡ + +wch¬_t + ** +__»¡riù + +__¤c +, + +500 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +, + +501 +size_t + +__d¡Ën +), +__wc¤tombs_chk +) + +502 + `__w¬Ç‰r + ("wcsrtombs called with dst buffer smallerhan†en"); + +504 +__ex‹º_®ways_šlše + +size_t + + +505 + `__NTH + ( + $wc¤tombs + (* +__»¡riù + +__d¡ +, +__cÚ¡ + +wch¬_t + **__»¡riù +__¤c +, + +506 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +)) + +508 ià( + `__bos + ( +__d¡ +è!ð( +size_t +) -1) + +510 ià(! + `__bužtš_cÚ¡ªt_p + ( +__Ën +)) + +511 + `__wc¤tombs_chk + ( +__d¡ +, +__¤c +, +__Ën +, +__ps +, + `__bos + (__dst)); + +513 ià( +__Ën + > + `__bos + ( +__d¡ +)) + +514 + `__wc¤tombs_chk_w¬n + ( +__d¡ +, +__¤c +, +__Ën +, +__ps +, + `__bos + (__dst)); + +516 + `__wc¤tombs_®Ÿs + ( +__d¡ +, +__¤c +, +__Ën +, +__ps +); + +517 + } +} + +520 #ifdeà +__USE_GNU + + +521
+size_t + + $__mb¢¹owcs_chk + ( +wch¬_t + * +__»¡riù + +__d¡ +, + +522 +__cÚ¡ + ** +__»¡riù + +__¤c +, +size_t + +__nmc +, + +523 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +, + +524 +size_t + +__d¡Ën +è +__THROW +; + +525
+size_t + + `__REDIRECT_NTH + ( +__mb¢¹owcs_®Ÿs +, + +526 ( +wch¬_t + * +__»¡riù + +__d¡ +, + +527 +__cÚ¡ + ** +__»¡riù + +__¤c +, +size_t + +__nmc +, + +528 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +), + +529 +mb¢¹owcs +); + +530
+size_t + + `__REDIRECT_NTH + ( +__mb¢¹owcs_chk_w¬n +, + +531 ( +wch¬_t + * +__»¡riù + +__d¡ +, + +532 +__cÚ¡ + ** +__»¡riù + +__¤c +, +size_t + +__nmc +, + +533 +size_t + +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +, + +534 +size_t + +__d¡Ën +), +__mb¢¹owcs_chk +) + +535 + `__w¬Ç‰r + ("mbsnrtowcs called with dst buffer smallerhan†en " + +538 +__ex‹º_®ways_šlše + +size_t + + +539 + `__NTH + ( + $mb¢¹owcs + ( +wch¬_t + * +__»¡riù + +__d¡ +, +__cÚ¡ + **__»¡riù +__¤c +, + +540 +size_t + +__nmc +, size_ˆ +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +)) + +542 ià( + `__bos + ( +__d¡ +è!ð( +size_t +) -1) + +544 ià(! + `__bužtš_cÚ¡ªt_p + ( +__Ën +)) + +545 + `__mb¢¹owcs_chk + ( +__d¡ +, +__¤c +, +__nmc +, +__Ën +, +__ps +, + +546 + `__bos + ( +__d¡ +è/ ( +wch¬_t +)); + +548 ià( +__Ën + > + `__bos + ( +__d¡ +è/ ( +wch¬_t +)) + +549 + `__mb¢¹owcs_chk_w¬n + ( +__d¡ +, +__¤c +, +__nmc +, +__Ën +, +__ps +, + +550 + `__bos + ( +__d¡ +è/ ( +wch¬_t +)); + +552 + `__mb¢¹owcs_®Ÿs + ( +__d¡ +, +__¤c +, +__nmc +, +__Ën +, +__ps +); + +553 + } +} + +556
+size_t + + $__wc¢¹ombs_chk + (* +__»¡riù + +__d¡ +, + +557 +__cÚ¡ + +wch¬_t + ** +__»¡riù + +__¤c +, + +558 +size_t + +__nwc +, size_ˆ +__Ën +, + +559 +mb¡©e_t + * +__»¡riù + +__ps +, +size_t + +__d¡Ën +) + +560 +__THROW +; + +561
+size_t + + `__REDIRECT_NTH + ( +__wc¢¹ombs_®Ÿs +, + +562 (* +__»¡riù + +__d¡ +, + +563 +__cÚ¡ + +wch¬_t + ** +__»¡riù + +__¤c +, + +564 +size_t + +__nwc +, size_ˆ +__Ën +, + +565 +mb¡©e_t + * +__»¡riù + +__ps +), +wc¢¹ombs +); + +566
+size_t + + `__REDIRECT_NTH + ( +__wc¢¹ombs_chk_w¬n +, + +567 (* +__»¡riù + +__d¡ +, + +568 +__cÚ¡ + +wch¬_t + ** +__»¡riù + +__¤c +, + +569 +size_t + +__nwc +, size_ˆ +__Ën +, + +570 +mb¡©e_t + * +__»¡riù + +__ps +, + +571 +size_t + +__d¡Ën +), +__wc¢¹ombs_chk +) + +572 + `__w¬Ç‰r + ("wcsnrtombs called with dst buffer smallerhan†en"); + +574 +__ex‹º_®ways_šlše + +size_t + + +575 + `__NTH + ( + $wc¢¹ombs + (* +__»¡riù + +__d¡ +, +__cÚ¡ + +wch¬_t + **__»¡riù +__¤c +, + +576 +size_t + +__nwc +, size_ˆ +__Ën +, +mb¡©e_t + * +__»¡riù + +__ps +)) + +578 ià( + `__bos + ( +__d¡ +è!ð( +size_t +) -1) + +580 ià(! + `__bužtš_cÚ¡ªt_p + ( +__Ën +)) + +581 + `__wc¢¹ombs_chk + ( +__d¡ +, +__¤c +, +__nwc +, +__Ën +, +__ps +, + +582 + `__bos + ( +__d¡ +)); + +584 ià( +__Ën + > + `__bos + ( +__d¡ +)) + +585 + `__wc¢¹ombs_chk_w¬n + ( +__d¡ +, +__¤c +, +__nwc +, +__Ën +, +__ps +, + +586 + `__bos + ( +__d¡ +)); + +588 + `__wc¢¹ombs_®Ÿs + ( +__d¡ +, +__¤c +, +__nwc +, +__Ën +, +__ps +); + +589 + } +} + + @/usr/include/errno.h + +23 #iâdef +_ERRNO_H + + +27 #iâdef +__Ãed_Em©h + + +28 + #_ERRNO_H + 1 + + ) + +29 + ~<ã©u»s.h +> + +32 + g__BEGIN_DECLS + + +36 + ~<b™s/”ºo.h +> + +37 #undeà +__Ãed_Em©h + + +39 #ifdef +_ERRNO_H + + +46 #iâdef +”ºo + + +47
+”ºo +; + +50 #ifdeà +__USE_GNU + + +55
* +´og¿m_švoÿtiÚ_Çme +, * +´og¿m_švoÿtiÚ_shÜt_Çme +; + +59 + g__END_DECLS + + +67 #ià +defšed + +__USE_GNU + || defšed +__Ãed_”rÜ_t + + +68 #iâdeà +__”rÜ_t_defšed + + +69 + t”rÜ_t +; + +70 + #__”rÜ_t_defšed + 1 + + ) + +72 #undeà +__Ãed_”rÜ_t + + + @/usr/include/gnu/option-groups.h + +10 #iâdeà +__GNU_OPTION_GROUPS_H + + +11 + #__GNU_OPTION_GROUPS_H + + + ) + +13 + #__OPTION_EGLIBC_ADVANCED_INET6 + 1 + + ) + +14 + #__OPTION_EGLIBC_BACKTRACE + 1 + + ) + +15 + #__OPTION_EGLIBC_BIG_MACROS + 1 + + ) + +16 + #__OPTION_EGLIBC_BSD + 1 + + ) + +17 + #__OPTION_EGLIBC_CATGETS + 1 + + ) + +18 + #__OPTION_EGLIBC_CHARSETS + 1 + + ) + +19 + #__OPTION_EGLIBC_CXX_TESTS + 1 + + ) + +20 + #__OPTION_EGLIBC_DB_ALIASES + 1 + + ) + +21 + #__OPTION_EGLIBC_ENVZ + 1 + + ) + +22 + #__OPTION_EGLIBC_FCVT + 1 + + ) + +23 + #__OPTION_EGLIBC_FMTMSG + 1 + + ) + +24 + #__OPTION_EGLIBC_FSTAB + 1 + + ) + +25 + #__OPTION_EGLIBC_FTRAVERSE + 1 + + ) + +26 + #__OPTION_EGLIBC_GETLOGIN + 1 + + ) + +27 + #__OPTION_EGLIBC_INET + 1 + + ) + +28 + #__OPTION_EGLIBC_LIBM + 1 + + ) + +29 + #__OPTION_EGLIBC_LOCALES + 1 + + ) + +30 + #__OPTION_EGLIBC_LOCALE_CODE + 1 + + ) + +31 + #__OPTION_EGLIBC_MEMUSAGE + 1 + + ) + +32 + #__OPTION_EGLIBC_NIS + 1 + + ) + +33 + #__OPTION_EGLIBC_NSSWITCH + 1 + + ) + +34 + #__OPTION_EGLIBC_RCMD + 1 + + ) + +35 + #__OPTION_EGLIBC_SPAWN + 1 + + ) + +36 + #__OPTION_EGLIBC_STREAMS + 1 + + ) + +37 + #__OPTION_EGLIBC_SUNRPC + 1 + + ) + +38 + #__OPTION_EGLIBC_UTMP + 1 + + ) + +39 + #__OPTION_EGLIBC_UTMPX + 1 + + ) + +40 + #__OPTION_EGLIBC_WORDEXP + 1 + + ) + +41 + #__OPTION_POSIX_C_LANG_WIDE_CHAR + 1 + + ) + +42 + #__OPTION_POSIX_REGEXP + 1 + + ) + +43 + #__OPTION_POSIX_REGEXP_GLIBC + 1 + + ) + +44 + #__OPTION_POSIX_WIDE_CHAR_DEVICE_IO + 1 + + ) + + @/usr/include/pthread.h + +20 #iâdeà +_PTHREAD_H + + +21 + #_PTHREAD_H + 1 + + ) + +23 + ~<ã©u»s.h +> + +24 + ~<’dŸn.h +> + +25 + ~<sched.h +> + +26 + ~<time.h +> + +28 + #__Ãed_sig£t_t + + + ) + +29 + ~<sigÇl.h +> + +30 + ~<b™s/±h»adty³s.h +> + +31 + ~<b™s/£tjmp.h +> + +32 + ~<b™s/wÜdsize.h +> + +38 + mPTHREAD_CREATE_JOINABLE +, + +39 + #PTHREAD_CREATE_JOINABLE + +PTHREAD_CREATE_JOINABLE + + + ) + +40 + mPTHREAD_CREATE_DETACHED + + +41 + #PTHREAD_CREATE_DETACHED + +PTHREAD_CREATE_DETACHED + + + ) + +48 + mPTHREAD_MUTEX_TIMED_NP +, + +49 + mPTHREAD_MUTEX_RECURSIVE_NP +, + +50 + mPTHREAD_MUTEX_ERRORCHECK_NP +, + +51 + mPTHREAD_MUTEX_ADAPTIVE_NP + + +52 #ifdeà +__USE_UNIX98 + + +54 + mPTHREAD_MUTEX_NORMAL + = +PTHREAD_MUTEX_TIMED_NP +, + +55 + mPTHREAD_MUTEX_RECURSIVE + = +PTHREAD_MUTEX_RECURSIVE_NP +, + +56 + mPTHREAD_MUTEX_ERRORCHECK + = +PTHREAD_MUTEX_ERRORCHECK_NP +, + +57 + mPTHREAD_MUTEX_DEFAULT + = +PTHREAD_MUTEX_NORMAL + + +59 #ifdeà +__USE_GNU + + +61 , + mPTHREAD_MUTEX_FAST_NP + = +PTHREAD_MUTEX_TIMED_NP + + +66 #ifdeà +__USE_XOPEN2K + + +70 + mPTHREAD_MUTEX_STALLED +, + +71 + mPTHREAD_MUTEX_STALLED_NP + = +PTHREAD_MUTEX_STALLED +, + +72 + mPTHREAD_MUTEX_ROBUST +, + +73 + mPTHREAD_MUTEX_ROBUST_NP + = +PTHREAD_MUTEX_ROBUST + + +78 #ifdeà +__USE_UNIX98 + + +82 + mPTHREAD_PRIO_NONE +, + +83 + mPTHREAD_PRIO_INHERIT +, + +84 + mPTHREAD_PRIO_PROTECT + + +90 #ià +__WORDSIZE + == 64 + +91 + #PTHREAD_MUTEX_INITIALIZER + \ + +92 { { 0, 0, 0, 0, 0, 0, { 0, 0 } } } + + ) + +93 #ifdeà +__USE_GNU + + +94 + #PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP + \ + +95 { { 0, 0, 0, 0, +PTHREAD_MUTEX_RECURSIVE_NP +, 0, { 0, 0 } } } + + ) + +96 + #PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP + \ + +97 { { 0, 0, 0, 0, +PTHREAD_MUTEX_ERRORCHECK_NP +, 0, { 0, 0 } } } + + ) + +98 + #PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP + \ + +99 { { 0, 0, 0, 0, +PTHREAD_MUTEX_ADAPTIVE_NP +, 0, { 0, 0 } } } + + ) + +102 + #PTHREAD_MUTEX_INITIALIZER + \ + +103 { { 0, 0, 0, 0, 0, { 0 } } } + + ) + +104 #ifdeà +__USE_GNU + + +105 + #PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP + \ + +106 { { 0, 0, 0, +PTHREAD_MUTEX_RECURSIVE_NP +, 0, { 0 } } } + + ) + +107 + #PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP + \ + +108 { { 0, 0, 0, +PTHREAD_MUTEX_ERRORCHECK_NP +, 0, { 0 } } } + + ) + +109 + #PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP + \ + +110 { { 0, 0, 0, +PTHREAD_MUTEX_ADAPTIVE_NP +, 0, { 0 } } } + + ) + +116 #ià +defšed + +__USE_UNIX98 + || defšed +__USE_XOPEN2K + + +119 + mPTHREAD_RWLOCK_PREFER_READER_NP +, + +120 + mPTHREAD_RWLOCK_PREFER_WRITER_NP +, + +121 + mPTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP +, + +122 + mPTHREAD_RWLOCK_DEFAULT_NP + = +PTHREAD_RWLOCK_PREFER_READER_NP + + +126 + #PTHREAD_RWLOCK_INITIALIZER + \ + +127 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } + + ) + +128 #ifdeà +__USE_GNU + + +129 #ià +__WORDSIZE + == 64 + +130 + #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP + \ + +132 +PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP + } } + + ) + +134 #ià +__BYTE_ORDER + =ð +__LITTLE_ENDIAN + + +135 + #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP + \ + +136 { { 0, 0, 0, 0, 0, 0, +PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP +, \ + +137 0, 0, 0, 0 } } + + ) + +139 + #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP + \ + +140 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, +PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP +,\ + +141 0 } } + + ) + +151 + mPTHREAD_INHERIT_SCHED +, + +152 + #PTHREAD_INHERIT_SCHED + +PTHREAD_INHERIT_SCHED + + + ) + +153 + mPTHREAD_EXPLICIT_SCHED + + +154 + #PTHREAD_EXPLICIT_SCHED + +PTHREAD_EXPLICIT_SCHED + + + ) + +161 + mPTHREAD_SCOPE_SYSTEM +, + +162 + #PTHREAD_SCOPE_SYSTEM + +PTHREAD_SCOPE_SYSTEM + + + ) + +163 + mPTHREAD_SCOPE_PROCESS + + +164 + #PTHREAD_SCOPE_PROCESS + +PTHREAD_SCOPE_PROCESS + + + ) + +171 + mPTHREAD_PROCESS_PRIVATE +, + +172 + #PTHREAD_PROCESS_PRIVATE + +PTHREAD_PROCESS_PRIVATE + + + ) + +173 + mPTHREAD_PROCESS_SHARED + + +174 + #PTHREAD_PROCESS_SHARED + +PTHREAD_PROCESS_SHARED + + + ) + +180 + #PTHREAD_COND_INITIALIZER + { { 0, 0, 0, 0, 0, ( *è0, 0, 0 } } + + ) + +184 + s_±h»ad_þ—nup_bufãr + + +186 (* + m__routše +) ( *); + +187 * + m__¬g +; + +188 + m__ÿnûÉy³ +; + +189 +_±h»ad_þ—nup_bufãr + * + m__´ev +; + +195 + mPTHREAD_CANCEL_ENABLE +, + +196 + #PTHREAD_CANCEL_ENABLE + +PTHREAD_CANCEL_ENABLE + + + ) + +197 + mPTHREAD_CANCEL_DISABLE + + +198 + #PTHREAD_CANCEL_DISABLE + +PTHREAD_CANCEL_DISABLE + + + ) + +202 + mPTHREAD_CANCEL_DEFERRED +, + +203 + #PTHREAD_CANCEL_DEFERRED + +PTHREAD_CANCEL_DEFERRED + + + ) + +204 + mPTHREAD_CANCEL_ASYNCHRONOUS + + +205 + #PTHREAD_CANCEL_ASYNCHRONOUS + +PTHREAD_CANCEL_ASYNCHRONOUS + + + ) + +207 + #PTHREAD_CANCELED + (( *è-1) + + ) + +211 + #PTHREAD_ONCE_INIT + 0 + + ) + +214 #ifdeà +__USE_XOPEN2K + + +218 + #PTHREAD_BARRIER_SERIAL_THREAD + -1 + + ) + +222 +__BEGIN_DECLS + + +227
+±h»ad_ü—‹ + ( +±h»ad_t + * +__»¡riù + +__Ãwth»ad +, + +228 +__cÚ¡ + +±h»ad_©Œ_t + * +__»¡riù + +__©Œ +, + +229 *(* +__¡¬t_routše +) ( *), + +230 * +__»¡riù + +__¬g +è +__THROW + +__nÚnuÎ + ((1, 3)); + +236
+ $±h»ad_ex™ + ( * +__»tv® +è + `__©Œibu‹__ + (( +__nÜ‘uº__ +)); + +244
+ `±h»ad_još + ( +±h»ad_t + +__th +, ** +__th»ad_»tuº +); + +246 #ifdeà +__USE_GNU + + +249
+ $±h»ad_Œyjoš_Å + ( +±h»ad_t + +__th +, ** +__th»ad_»tuº +è +__THROW +; + +257
+ `±h»ad_timedjoš_Å + ( +±h»ad_t + +__th +, ** +__th»ad_»tuº +, + +258 +__cÚ¡ + +time¥ec + * +__ab¡ime +); + +265
+ $±h»ad_d‘ach + ( +±h»ad_t + +__th +è +__THROW +; + +269
+±h»ad_t + + $±h»ad_£lf + ( è +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)); + +272
+ $±h»ad_equ® + ( +±h»ad_t + +__th»ad1 +,…th»ad_ˆ +__th»ad2 +è +__THROW +; + +280
+ $±h»ad_©Œ_š™ + ( +±h»ad_©Œ_t + * +__©Œ +è +__THROW + + `__nÚnuÎ + ((1)); + +283
+ $±h»ad_©Œ_de¡roy + ( +±h»ad_©Œ_t + * +__©Œ +) + +284 +__THROW + + `__nÚnuÎ + ((1)); + +287
+ $±h»ad_©Œ_g‘d‘ach¡©e + ( +__cÚ¡ + +±h»ad_©Œ_t + * +__©Œ +, + +288 * +__d‘ach¡©e +) + +289 +__THROW + + `__nÚnuÎ + ((1, 2)); + +292
+ $±h»ad_©Œ_£td‘ach¡©e + ( +±h»ad_©Œ_t + * +__©Œ +, + +293 +__d‘ach¡©e +) + +294 +__THROW + + `__nÚnuÎ + ((1)); + +298
+ $±h»ad_©Œ_g‘gu¬dsize + ( +__cÚ¡ + +±h»ad_©Œ_t + * +__©Œ +, + +299 +size_t + * +__gu¬dsize +) + +300 +__THROW + + `__nÚnuÎ + ((1, 2)); + +303
+ $±h»ad_©Œ_£tgu¬dsize + ( +±h»ad_©Œ_t + * +__©Œ +, + +304 +size_t + +__gu¬dsize +) + +305 +__THROW + + `__nÚnuÎ + ((1)); + +309
+ $±h»ad_©Œ_g‘sched·¿m + ( +__cÚ¡ + +±h»ad_©Œ_t + * +__»¡riù + + +310 +__©Œ +, + +311 +sched_·¿m + * +__»¡riù + +__·¿m +) + +312 +__THROW + + `__nÚnuÎ + ((1, 2)); + +315
+ $±h»ad_©Œ_£tsched·¿m + ( +±h»ad_©Œ_t + * +__»¡riù + +__©Œ +, + +316 +__cÚ¡ + +sched_·¿m + * +__»¡riù + + +317 +__·¿m +è +__THROW + + `__nÚnuÎ + ((1, 2)); + +320
+ $±h»ad_©Œ_g‘schedpÞicy + ( +__cÚ¡ + +±h»ad_©Œ_t + * +__»¡riù + + +321 +__©Œ +, * +__»¡riù + +__pÞicy +) + +322 +__THROW + + `__nÚnuÎ + ((1, 2)); + +325
+ $±h»ad_©Œ_£tschedpÞicy + ( +±h»ad_©Œ_t + * +__©Œ +, +__pÞicy +) + +326 +__THROW + + `__nÚnuÎ + ((1)); + +329
+ $±h»ad_©Œ_g‘šh”™sched + ( +__cÚ¡ + +±h»ad_©Œ_t + * +__»¡riù + + +330 +__©Œ +, * +__»¡riù + +__šh”™ +) + +331 +__THROW + + `__nÚnuÎ + ((1, 2)); + +334
+ $±h»ad_©Œ_£tšh”™sched + ( +±h»ad_©Œ_t + * +__©Œ +, + +335 +__šh”™ +) + +336 +__THROW + + `__nÚnuÎ + ((1)); + +340
+ $±h»ad_©Œ_g‘scÝe + ( +__cÚ¡ + +±h»ad_©Œ_t + * +__»¡riù + +__©Œ +, + +341 * +__»¡riù + +__scÝe +) + +342 +__THROW + + `__nÚnuÎ + ((1, 2)); + +345
+ $±h»ad_©Œ_£tscÝe + ( +±h»ad_©Œ_t + * +__©Œ +, +__scÝe +) + +346 +__THROW + + `__nÚnuÎ + ((1)); + +349
+ $±h»ad_©Œ_g‘¡ackaddr + ( +__cÚ¡ + +±h»ad_©Œ_t + * +__»¡riù + + +350 +__©Œ +, ** +__»¡riù + +__¡ackaddr +) + +351 +__THROW + + `__nÚnuÎ + ((1, 2)è +__©Œibu‹_d•»ÿ‹d__ +; + +357
+ $±h»ad_©Œ_£t¡ackaddr + ( +±h»ad_©Œ_t + * +__©Œ +, + +358 * +__¡ackaddr +) + +359 +__THROW + + `__nÚnuÎ + ((1)è +__©Œibu‹_d•»ÿ‹d__ +; + +362
+ $±h»ad_©Œ_g‘¡acksize + ( +__cÚ¡ + +±h»ad_©Œ_t + * +__»¡riù + + +363 +__©Œ +, +size_t + * +__»¡riù + +__¡acksize +) + +364 +__THROW + + `__nÚnuÎ + ((1, 2)); + +369
+ $±h»ad_©Œ_£t¡acksize + ( +±h»ad_©Œ_t + * +__©Œ +, + +370 +size_t + +__¡acksize +) + +371 +__THROW + + `__nÚnuÎ + ((1)); + +373 #ifdeà +__USE_XOPEN2K + + +375
+ $±h»ad_©Œ_g‘¡ack + ( +__cÚ¡ + +±h»ad_©Œ_t + * +__»¡riù + +__©Œ +, + +376 ** +__»¡riù + +__¡ackaddr +, + +377 +size_t + * +__»¡riù + +__¡acksize +) + +378 +__THROW + + `__nÚnuÎ + ((1, 2, 3)); + +383
+ $±h»ad_©Œ_£t¡ack + ( +±h»ad_©Œ_t + * +__©Œ +, * +__¡ackaddr +, + +384 +size_t + +__¡acksize +è +__THROW + + `__nÚnuÎ + ((1)); + +387 #ifdeà +__USE_GNU + + +390
+ $±h»ad_©Œ_£ffš™y_Å + ( +±h»ad_©Œ_t + * +__©Œ +, + +391 +size_t + +__ýu£tsize +, + +392 +__cÚ¡ + +ýu_£t_t + * +__ýu£t +) + +393 +__THROW + + `__nÚnuÎ + ((1, 3)); + +397
+ $±h»ad_©Œ_g‘affš™y_Å + ( +__cÚ¡ + +±h»ad_©Œ_t + * +__©Œ +, + +398 +size_t + +__ýu£tsize +, + +399 +ýu_£t_t + * +__ýu£t +) + +400 +__THROW + + `__nÚnuÎ + ((1, 3)); + +406
+ $±h»ad_g‘©Œ_Å + ( +±h»ad_t + +__th +, +±h»ad_©Œ_t + * +__©Œ +) + +407 +__THROW + + `__nÚnuÎ + ((2)); + +415
+ $±h»ad_£tsched·¿m + ( +±h»ad_t + +__rg‘_th»ad +, +__pÞicy +, + +416 +__cÚ¡ + +sched_·¿m + * +__·¿m +) + +417 +__THROW + + `__nÚnuÎ + ((3)); + +420
+ $±h»ad_g‘sched·¿m + ( +±h»ad_t + +__rg‘_th»ad +, + +421 * +__»¡riù + +__pÞicy +, + +422 +sched_·¿m + * +__»¡riù + +__·¿m +) + +423 +__THROW + + `__nÚnuÎ + ((2, 3)); + +426
+ $±h»ad_£tsched´io + ( +±h»ad_t + +__rg‘_th»ad +, +__´io +) + +427 +__THROW +; + +430 #ifdeà +__USE_UNIX98 + + +432
+ $±h»ad_g‘cÚcu¼’cy + ( è +__THROW +; + +435
+ $±h»ad_£tcÚcu¼’cy + ( +__Ëv– +è +__THROW +; + +438 #ifdeà +__USE_GNU + + +443
+ $±h»ad_y›ld + ( è +__THROW +; + +448
+ $±h»ad_£ffš™y_Å + ( +±h»ad_t + +__th +, +size_t + +__ýu£tsize +, + +449 +__cÚ¡ + +ýu_£t_t + * +__ýu£t +) + +450 +__THROW + + `__nÚnuÎ + ((3)); + +453
+ $±h»ad_g‘affš™y_Å + ( +±h»ad_t + +__th +, +size_t + +__ýu£tsize +, + +454 +ýu_£t_t + * +__ýu£t +) + +455 +__THROW + + `__nÚnuÎ + ((3)); + +468
+ `±h»ad_Úû + ( +±h»ad_Úû_t + * +__Úû_cÚŒÞ +, + +469 (* +__š™_routše +è( )è + `__nÚnuÎ + ((1, 2)); + +480
+ `±h»ad_£tÿnûl¡©e + ( +__¡©e +, * +__Þd¡©e +); + +484
+ `±h»ad_£tÿnûÉy³ + ( +__ty³ +, * +__Þdty³ +); + +487
+ `±h»ad_ÿnûl + ( +±h»ad_t + +__th +); + +492
+ `±h»ad_‹¡ÿnûl + ( ); + +501 +__jmp_buf + +__ÿnûl_jmp_buf +; + +502 +__mask_was_§ved +; + +503 } +__ÿnûl_jmp_buf +[1]; + +504 * +__·d +[4]; + +505 } + t__±h»ad_unwšd_buf_t + + t__©Œibu‹__ + (( + t__®igÃd__ +)); + +508 #iâdeà +__þ—nup_fù_©Œibu‹ + + +509 + #__þ—nup_fù_©Œibu‹ + + + ) + +514 + s__±h»ad_þ—nup_äame + + +516 (* +__ÿnûl_routše +) ( *); + +517 * +__ÿnûl_¬g +; + +518 +__do_™ +; + +519 +__ÿnûl_ty³ +; + +522 #ià +defšed + +__GNUC__ + && defšed +__EXCEPTIONS + + +523 #ifdeà +__ýlu¥lus + + +525 þas + c__±h»ad_þ—nup_þass + + +527 (* +__ÿnûl_routše +) ( *); + +528 * +__ÿnûl_¬g +; + +529 +__do_™ +; + +530 +__ÿnûl_ty³ +; + +532 +public +: + +533 + `__±h»ad_þ—nup_þass + ( (* +__fù +è( *), * +__¬g +) + +534 : + `__ÿnûl_routše + ( +__fù +), + `__ÿnûl_¬g + ( +__¬g +), + $__do_™ + (1) { } + +535 ~ + $__±h»ad_þ—nup_þass + (è{ ià( +__do_™ +è + `__ÿnûl_routše + ( +__ÿnûl_¬g +); + } +} + +536 + $__£tdo™ + ( +__Ãwv® +è{ +__do_™ + = __Ãwv®; + } +} + +537 + $__deãr + (è{ + `±h»ad_£tÿnûÉy³ + ( +PTHREAD_CANCEL_DEFERRED +, + +538 & +__ÿnûl_ty³ +); + } +} + +539 + $__»¡Üe + (ècÚ¡ { + `±h»ad_£tÿnûÉy³ + ( +__ÿnûl_ty³ +, 0); + } +} + +549 + #±h»ad_þ—nup_push +( +routše +, +¬g +) \ + +551 +__±h»ad_þ—nup_þass + + `__þäame + ( +routše +, +¬g +) + + ) + +555 + #±h»ad_þ—nup_pÝ +( +execu‹ +) \ + +556 +__þäame +. + `__£tdo™ + ( +execu‹ +); \ + +557 } 0) + + ) + +559 #ifdeà +__USE_GNU + + +563 + #±h»ad_þ—nup_push_deãr_Å +( +routše +, +¬g +) \ + +565 +__±h»ad_þ—nup_þass + + `__þäame + ( +routše +, +¬g +); \ + +566 +__þäame +. + `__deãr + () + + ) + +571 + #±h»ad_þ—nup_pÝ_»¡Üe_Å +( +execu‹ +) \ + +572 +__þäame +. + `__»¡Üe + (); \ + +573 +__þäame +. + `__£tdo™ + ( +execu‹ +); \ + +574 } 0) + + ) + +581 +__ex‹º_šlše + + +582 + $__±h»ad_þ—nup_routše + ( +__±h»ad_þ—nup_äame + * +__äame +) + +584 ià( +__äame +-> +__do_™ +) + +585 +__äame +-> + `__ÿnûl_routše + (__äame-> +__ÿnûl_¬g +); + +586 + } +} + +595 + #±h»ad_þ—nup_push +( +routše +, +¬g +) \ + +597 +__±h»ad_þ—nup_äame + +__þäame + \ + +598 + `__©Œibu‹__ + (( + `__þ—nup__ + ( +__±h»ad_þ—nup_routše +))) \ + +599 ð{ . +__ÿnûl_routše + = ( +routše +), . +__ÿnûl_¬g + = ( +¬g +), \ + +600 . +__do_™ + = 1 }; + + ) + +604 + #±h»ad_þ—nup_pÝ +( +execu‹ +) \ + +605 +__þäame +. +__do_™ + = ( +execu‹ +); \ + +606 } 0) + + ) + +608 #ifdeà +__USE_GNU + + +612 + #±h»ad_þ—nup_push_deãr_Å +( +routše +, +¬g +) \ + +614 +__±h»ad_þ—nup_äame + +__þäame + \ + +615 + `__©Œibu‹__ + (( + `__þ—nup__ + ( +__±h»ad_þ—nup_routše +))) \ + +616 ð{ . +__ÿnûl_routše + = ( +routše +), . +__ÿnûl_¬g + = ( +¬g +), \ + +617 . +__do_™ + = 1 }; \ + +618 ( è + `±h»ad_£tÿnûÉy³ + ( +PTHREAD_CANCEL_DEFERRED +, \ + +619 & +__þäame +. +__ÿnûl_ty³ +) + + ) + +624 + #±h»ad_þ—nup_pÝ_»¡Üe_Å +( +execu‹ +) \ + +625 ( è + `±h»ad_£tÿnûÉy³ + ( +__þäame +. +__ÿnûl_ty³ +, +NULL +); \ + +626 +__þäame +. +__do_™ + = ( +execu‹ +); \ + +627 } 0) + + ) + +638 + #±h»ad_þ—nup_push +( +routše +, +¬g +) \ + +640 +__±h»ad_unwšd_buf_t + +__ÿnûl_buf +; \ + +641 (* +__ÿnûl_routše +è( *èð( +routše +); \ + +642 * +__ÿnûl_¬g + = ( +¬g +); \ + +643 +nÙ_fœ¡_ÿÎ + = + `__sig£tjmp + (( +__jmp_buf_g + *) ( *) \ + +644 +__ÿnûl_buf +. +__ÿnûl_jmp_buf +, 0); \ + +645 ià( + `__bužtš_ex³ù + ( +nÙ_fœ¡_ÿÎ +, 0)) \ + +647 + `__ÿnûl_routše + ( +__ÿnûl_¬g +); \ + +648 + `__±h»ad_unwšd_Ãxt + (& +__ÿnûl_buf +); \ + +652 + `__±h»ad_»gi¡”_ÿnûl + (& +__ÿnûl_buf +); \ + +653 dØ{ + + ) + +654
+__±h»ad_»gi¡”_ÿnûl + ( +__±h»ad_unwšd_buf_t + * +__buf +) + +655 +__þ—nup_fù_©Œibu‹ +; + +659 + #±h»ad_þ—nup_pÝ +( +execu‹ +) \ + +662 + `__±h»ad_uÄegi¡”_ÿnûl + (& +__ÿnûl_buf +); \ + +663 ià( +execu‹ +) \ + +664 + `__ÿnûl_routše + ( +__ÿnûl_¬g +); \ + +665 } 0) + + ) + +666
+ $__±h»ad_uÄegi¡”_ÿnûl + ( +__±h»ad_unwšd_buf_t + * +__buf +) + +667 +__þ—nup_fù_©Œibu‹ +; + +669 #ifdeà +__USE_GNU + + +673 + #±h»ad_þ—nup_push_deãr_Å +( +routše +, +¬g +) \ + +675 +__±h»ad_unwšd_buf_t + +__ÿnûl_buf +; \ + +676 (* +__ÿnûl_routše +è( *èð( +routše +); \ + +677 * +__ÿnûl_¬g + = ( +¬g +); \ + +678 +nÙ_fœ¡_ÿÎ + = + `__sig£tjmp + (( +__jmp_buf_g + *) ( *) \ + +679 +__ÿnûl_buf +. +__ÿnûl_jmp_buf +, 0); \ + +680 ià( + `__bužtš_ex³ù + ( +nÙ_fœ¡_ÿÎ +, 0)) \ + +682 + `__ÿnûl_routše + ( +__ÿnûl_¬g +); \ + +683 + `__±h»ad_unwšd_Ãxt + (& +__ÿnûl_buf +); \ + +687 + `__±h»ad_»gi¡”_ÿnûl_deãr + (& +__ÿnûl_buf +); \ + +688 dØ{ + + ) + +689
+ `__±h»ad_»gi¡”_ÿnûl_deãr + ( +__±h»ad_unwšd_buf_t + * +__buf +) + +690 +__þ—nup_fù_©Œibu‹ +; + +695 + #±h»ad_þ—nup_pÝ_»¡Üe_Å +( +execu‹ +) \ + +698 + `__±h»ad_uÄegi¡”_ÿnûl_»¡Üe + (& +__ÿnûl_buf +); \ + +699 ià( +execu‹ +) \ + +700 + `__ÿnûl_routše + ( +__ÿnûl_¬g +); \ + +701 + } +} 0) + + ) + +702
+ $__±h»ad_uÄegi¡”_ÿnûl_»¡Üe + ( +__±h»ad_unwšd_buf_t + * +__buf +) + +703 +__þ—nup_fù_©Œibu‹ +; + +707
+ $__±h»ad_unwšd_Ãxt + ( +__±h»ad_unwšd_buf_t + * +__buf +) + +708 +__þ—nup_fù_©Œibu‹ + + `__©Œibu‹__ + (( +__nÜ‘uº__ +)) + +709 #iâdeà +SHARED + + +710 + `__©Œibu‹__ + (( +__w—k__ +)) + +716 +__jmp_buf_g +; + +717
+ $__sig£tjmp + ( +__jmp_buf_g + * +__’v +, +__§vemask +è +__THROW +; + +723
+ $±h»ad_mu‹x_š™ + ( +±h»ad_mu‹x_t + * +__mu‹x +, + +724 +__cÚ¡ + +±h»ad_mu‹x©Œ_t + * +__mu‹x©Œ +) + +725 +__THROW + + `__nÚnuÎ + ((1)); + +728
+ $±h»ad_mu‹x_de¡roy + ( +±h»ad_mu‹x_t + * +__mu‹x +) + +729 +__THROW + + `__nÚnuÎ + ((1)); + +732
+ $±h»ad_mu‹x_Œylock + ( +±h»ad_mu‹x_t + * +__mu‹x +) + +733 +__THROW + + `__nÚnuÎ + ((1)); + +736
+ $±h»ad_mu‹x_lock + ( +±h»ad_mu‹x_t + * +__mu‹x +) + +737 +__THROW + + `__nÚnuÎ + ((1)); + +739 #ifdeà +__USE_XOPEN2K + + +741
+ $±h»ad_mu‹x_timedlock + ( +±h»ad_mu‹x_t + * +__»¡riù + +__mu‹x +, + +742 +__cÚ¡ + +time¥ec + * +__»¡riù + + +743 +__ab¡ime +è +__THROW + + `__nÚnuÎ + ((1, 2)); + +747
+ $±h»ad_mu‹x_uÆock + ( +±h»ad_mu‹x_t + * +__mu‹x +) + +748 +__THROW + + `__nÚnuÎ + ((1)); + +751 #ifdeà +__USE_UNIX98 + + +753
+ $±h»ad_mu‹x_g‘´ioûžšg + ( +__cÚ¡ + +±h»ad_mu‹x_t + * + +754 +__»¡riù + +__mu‹x +, + +755 * +__»¡riù + +__´ioûžšg +) + +756 +__THROW + + `__nÚnuÎ + ((1, 2)); + +760
+ $±h»ad_mu‹x_£rioûžšg + ( +±h»ad_mu‹x_t + * +__»¡riù + +__mu‹x +, + +761 +__´ioûžšg +, + +762 * +__»¡riù + +__Þd_ûžšg +) + +763 +__THROW + + `__nÚnuÎ + ((1, 3)); + +767 #ifdeà +__USE_XOPEN2K8 + + +769
+ $±h»ad_mu‹x_cÚsi¡’t_Å + ( +±h»ad_mu‹x_t + * +__mu‹x +) + +770 +__THROW + + `__nÚnuÎ + ((1)); + +771 #ifdeà +__USE_GNU + + +772
+ $±h»ad_mu‹x_cÚsi¡’t_Å + ( +±h»ad_mu‹x_t + * +__mu‹x +) + +773 +__THROW + + `__nÚnuÎ + ((1)); + +782
+ $±h»ad_mu‹x©Œ_š™ + ( +±h»ad_mu‹x©Œ_t + * +__©Œ +) + +783 +__THROW + + `__nÚnuÎ + ((1)); + +786
+ $±h»ad_mu‹x©Œ_de¡roy + ( +±h»ad_mu‹x©Œ_t + * +__©Œ +) + +787 +__THROW + + `__nÚnuÎ + ((1)); + +790
+ $±h»ad_mu‹x©Œ_g‘psh¬ed + ( +__cÚ¡ + +±h»ad_mu‹x©Œ_t + * + +791 +__»¡riù + +__©Œ +, + +792 * +__»¡riù + +__psh¬ed +) + +793 +__THROW + + `__nÚnuÎ + ((1, 2)); + +796
+ $±h»ad_mu‹x©Œ_£sh¬ed + ( +±h»ad_mu‹x©Œ_t + * +__©Œ +, + +797 +__psh¬ed +) + +798 +__THROW + + `__nÚnuÎ + ((1)); + +800 #ifdeà +__USE_UNIX98 + + +802
+ $±h»ad_mu‹x©Œ_g‘ty³ + ( +__cÚ¡ + +±h»ad_mu‹x©Œ_t + * +__»¡riù + + +803 +__©Œ +, * +__»¡riù + +__kšd +) + +804 +__THROW + + `__nÚnuÎ + ((1, 2)); + +809
+ $±h»ad_mu‹x©Œ_£‰y³ + ( +±h»ad_mu‹x©Œ_t + * +__©Œ +, +__kšd +) + +810 +__THROW + + `__nÚnuÎ + ((1)); + +813
+ $±h»ad_mu‹x©Œ_g‘´ÙocÞ + ( +__cÚ¡ + +±h»ad_mu‹x©Œ_t + * + +814 +__»¡riù + +__©Œ +, + +815 * +__»¡riù + +__´ÙocÞ +) + +816 +__THROW + + `__nÚnuÎ + ((1, 2)); + +820
+ $±h»ad_mu‹x©Œ_£rÙocÞ + ( +±h»ad_mu‹x©Œ_t + * +__©Œ +, + +821 +__´ÙocÞ +) + +822 +__THROW + + `__nÚnuÎ + ((1)); + +825
+ $±h»ad_mu‹x©Œ_g‘´ioûžšg + ( +__cÚ¡ + +±h»ad_mu‹x©Œ_t + * + +826 +__»¡riù + +__©Œ +, + +827 * +__»¡riù + +__´ioûžšg +) + +828 +__THROW + + `__nÚnuÎ + ((1, 2)); + +831
+ $±h»ad_mu‹x©Œ_£rioûžšg + ( +±h»ad_mu‹x©Œ_t + * +__©Œ +, + +832 +__´ioûžšg +) + +833 +__THROW + + `__nÚnuÎ + ((1)); + +836 #ifdeà +__USE_XOPEN2K + + +838
+ $±h»ad_mu‹x©Œ_g‘robu¡ + ( +__cÚ¡ + +±h»ad_mu‹x©Œ_t + * +__©Œ +, + +839 * +__robu¡Ãss +) + +840 +__THROW + + `__nÚnuÎ + ((1, 2)); + +841 #ifdeà +__USE_GNU + + +842
+ $±h»ad_mu‹x©Œ_g‘robu¡_Å + ( +__cÚ¡ + +±h»ad_mu‹x©Œ_t + * +__©Œ +, + +843 * +__robu¡Ãss +) + +844 +__THROW + + `__nÚnuÎ + ((1, 2)); + +848
+ $±h»ad_mu‹x©Œ_£Œobu¡ + ( +±h»ad_mu‹x©Œ_t + * +__©Œ +, + +849 +__robu¡Ãss +) + +850 +__THROW + + `__nÚnuÎ + ((1)); + +851 #ifdeà +__USE_GNU + + +852
+ $±h»ad_mu‹x©Œ_£Œobu¡_Å + ( +±h»ad_mu‹x©Œ_t + * +__©Œ +, + +853 +__robu¡Ãss +) + +854 +__THROW + + `__nÚnuÎ + ((1)); + +859 #ià +defšed + +__USE_UNIX98 + || defšed +__USE_XOPEN2K + + +864
+ $±h»ad_rwlock_š™ + ( +±h»ad_rwlock_t + * +__»¡riù + +__rwlock +, + +865 +__cÚ¡ + +±h»ad_rwlock©Œ_t + * +__»¡riù + + +866 +__©Œ +è +__THROW + + `__nÚnuÎ + ((1)); + +869
+ $±h»ad_rwlock_de¡roy + ( +±h»ad_rwlock_t + * +__rwlock +) + +870 +__THROW + + `__nÚnuÎ + ((1)); + +873
+ $±h»ad_rwlock_rdlock + ( +±h»ad_rwlock_t + * +__rwlock +) + +874 +__THROW + + `__nÚnuÎ + ((1)); + +877
+ $±h»ad_rwlock_Œyrdlock + ( +±h»ad_rwlock_t + * +__rwlock +) + +878 +__THROW + + `__nÚnuÎ + ((1)); + +880 #ifdeà +__USE_XOPEN2K + + +882
+ $±h»ad_rwlock_timedrdlock + ( +±h»ad_rwlock_t + * +__»¡riù + +__rwlock +, + +883 +__cÚ¡ + +time¥ec + * +__»¡riù + + +884 +__ab¡ime +è +__THROW + + `__nÚnuÎ + ((1, 2)); + +888
+ $±h»ad_rwlock_w¾ock + ( +±h»ad_rwlock_t + * +__rwlock +) + +889 +__THROW + + `__nÚnuÎ + ((1)); + +892
+ $±h»ad_rwlock_Œyw¾ock + ( +±h»ad_rwlock_t + * +__rwlock +) + +893 +__THROW + + `__nÚnuÎ + ((1)); + +895 #ifdeà +__USE_XOPEN2K + + +897
+ $±h»ad_rwlock_timedw¾ock + ( +±h»ad_rwlock_t + * +__»¡riù + +__rwlock +, + +898 +__cÚ¡ + +time¥ec + * +__»¡riù + + +899 +__ab¡ime +è +__THROW + + `__nÚnuÎ + ((1, 2)); + +903
+ $±h»ad_rwlock_uÆock + ( +±h»ad_rwlock_t + * +__rwlock +) + +904 +__THROW + + `__nÚnuÎ + ((1)); + +910
+ $±h»ad_rwlock©Œ_š™ + ( +±h»ad_rwlock©Œ_t + * +__©Œ +) + +911 +__THROW + + `__nÚnuÎ + ((1)); + +914
+ $±h»ad_rwlock©Œ_de¡roy + ( +±h»ad_rwlock©Œ_t + * +__©Œ +) + +915 +__THROW + + `__nÚnuÎ + ((1)); + +918
+ $±h»ad_rwlock©Œ_g‘psh¬ed + ( +__cÚ¡ + +±h»ad_rwlock©Œ_t + * + +919 +__»¡riù + +__©Œ +, + +920 * +__»¡riù + +__psh¬ed +) + +921 +__THROW + + `__nÚnuÎ + ((1, 2)); + +924
+ $±h»ad_rwlock©Œ_£sh¬ed + ( +±h»ad_rwlock©Œ_t + * +__©Œ +, + +925 +__psh¬ed +) + +926 +__THROW + + `__nÚnuÎ + ((1)); + +929
+ $±h»ad_rwlock©Œ_g‘kšd_Å + ( +__cÚ¡ + +±h»ad_rwlock©Œ_t + * + +930 +__»¡riù + +__©Œ +, + +931 * +__»¡riù + +__´ef +) + +932 +__THROW + + `__nÚnuÎ + ((1, 2)); + +935
+ $±h»ad_rwlock©Œ_£tkšd_Å + ( +±h»ad_rwlock©Œ_t + * +__©Œ +, + +936 +__´ef +è +__THROW + + `__nÚnuÎ + ((1)); + +944
+ $±h»ad_cÚd_š™ + ( +±h»ad_cÚd_t + * +__»¡riù + +__cÚd +, + +945 +__cÚ¡ + +±h»ad_cÚd©Œ_t + * +__»¡riù + + +946 +__cÚd_©Œ +è +__THROW + + `__nÚnuÎ + ((1)); + +949
+ $±h»ad_cÚd_de¡roy + ( +±h»ad_cÚd_t + * +__cÚd +) + +950 +__THROW + + `__nÚnuÎ + ((1)); + +953
+ $±h»ad_cÚd_sigÇl + ( +±h»ad_cÚd_t + * +__cÚd +) + +954 +__THROW + + `__nÚnuÎ + ((1)); + +957
+ $±h»ad_cÚd_brßdÿ¡ + ( +±h»ad_cÚd_t + * +__cÚd +) + +958 +__THROW + + `__nÚnuÎ + ((1)); + +965
+ $±h»ad_cÚd_wa™ + ( +±h»ad_cÚd_t + * +__»¡riù + +__cÚd +, + +966 +±h»ad_mu‹x_t + * +__»¡riù + +__mu‹x +) + +967 + `__nÚnuÎ + ((1, 2)); + +976
+ $±h»ad_cÚd_timedwa™ + ( +±h»ad_cÚd_t + * +__»¡riù + +__cÚd +, + +977 +±h»ad_mu‹x_t + * +__»¡riù + +__mu‹x +, + +978 +__cÚ¡ + +time¥ec + * +__»¡riù + + +979 +__ab¡ime +è + `__nÚnuÎ + ((1, 2, 3)); + +984
+ $±h»ad_cÚd©Œ_š™ + ( +±h»ad_cÚd©Œ_t + * +__©Œ +) + +985 +__THROW + + `__nÚnuÎ + ((1)); + +988
+ $±h»ad_cÚd©Œ_de¡roy + ( +±h»ad_cÚd©Œ_t + * +__©Œ +) + +989 +__THROW + + `__nÚnuÎ + ((1)); + +992
+ $±h»ad_cÚd©Œ_g‘psh¬ed + ( +__cÚ¡ + +±h»ad_cÚd©Œ_t + * + +993 +__»¡riù + +__©Œ +, + +994 * +__»¡riù + +__psh¬ed +) + +995 +__THROW + + `__nÚnuÎ + ((1, 2)); + +998
+ $±h»ad_cÚd©Œ_£sh¬ed + ( +±h»ad_cÚd©Œ_t + * +__©Œ +, + +999 +__psh¬ed +è +__THROW + + `__nÚnuÎ + ((1)); + +1001 #ifdeà +__USE_XOPEN2K + + +1003
+ $±h»ad_cÚd©Œ_g‘þock + ( +__cÚ¡ + +±h»ad_cÚd©Œ_t + * + +1004 +__»¡riù + +__©Œ +, + +1005 +__þockid_t + * +__»¡riù + +__þock_id +) + +1006 +__THROW + + `__nÚnuÎ + ((1, 2)); + +1009
+ $±h»ad_cÚd©Œ_£tþock + ( +±h»ad_cÚd©Œ_t + * +__©Œ +, + +1010 +__þockid_t + +__þock_id +) + +1011 +__THROW + + `__nÚnuÎ + ((1)); + +1015 #ifdeà +__USE_XOPEN2K + + +1020
+ $±h»ad_¥š_š™ + ( +±h»ad_¥šlock_t + * +__lock +, +__psh¬ed +) + +1021 +__THROW + + `__nÚnuÎ + ((1)); + +1024
+ $±h»ad_¥š_de¡roy + ( +±h»ad_¥šlock_t + * +__lock +) + +1025 +__THROW + + `__nÚnuÎ + ((1)); + +1028
+ $±h»ad_¥š_lock + ( +±h»ad_¥šlock_t + * +__lock +) + +1029 +__THROW + + `__nÚnuÎ + ((1)); + +1032
+ $±h»ad_¥š_Œylock + ( +±h»ad_¥šlock_t + * +__lock +) + +1033 +__THROW + + `__nÚnuÎ + ((1)); + +1036
+ $±h»ad_¥š_uÆock + ( +±h»ad_¥šlock_t + * +__lock +) + +1037 +__THROW + + `__nÚnuÎ + ((1)); + +1044
+ $±h»ad_b¬r›r_š™ + ( +±h»ad_b¬r›r_t + * +__»¡riù + +__b¬r›r +, + +1045 +__cÚ¡ + +±h»ad_b¬r›¿‰r_t + * +__»¡riù + + +1046 +__©Œ +, +__couÁ +) + +1047 +__THROW + + `__nÚnuÎ + ((1)); + +1050
+ $±h»ad_b¬r›r_de¡roy + ( +±h»ad_b¬r›r_t + * +__b¬r›r +) + +1051 +__THROW + + `__nÚnuÎ + ((1)); + +1054
+ $±h»ad_b¬r›r_wa™ + ( +±h»ad_b¬r›r_t + * +__b¬r›r +) + +1055 +__THROW + + `__nÚnuÎ + ((1)); + +1059
+ $±h»ad_b¬r›¿‰r_š™ + ( +±h»ad_b¬r›¿‰r_t + * +__©Œ +) + +1060 +__THROW + + `__nÚnuÎ + ((1)); + +1063
+ $±h»ad_b¬r›¿‰r_de¡roy + ( +±h»ad_b¬r›¿‰r_t + * +__©Œ +) + +1064 +__THROW + + `__nÚnuÎ + ((1)); + +1067
+ $±h»ad_b¬r›¿‰r_g‘psh¬ed + ( +__cÚ¡ + +±h»ad_b¬r›¿‰r_t + * + +1068 +__»¡riù + +__©Œ +, + +1069 * +__»¡riù + +__psh¬ed +) + +1070 +__THROW + + `__nÚnuÎ + ((1, 2)); + +1073
+ $±h»ad_b¬r›¿‰r_£sh¬ed + ( +±h»ad_b¬r›¿‰r_t + * +__©Œ +, + +1074 +__psh¬ed +) + +1075 +__THROW + + `__nÚnuÎ + ((1)); + +1087
+ `±h»ad_key_ü—‹ + ( +±h»ad_key_t + * +__key +, + +1088 (* +__de¡r_funùiÚ +) ( *)) + +1089 +__THROW + + `__nÚnuÎ + ((1)); + +1092
+ $±h»ad_key_d–‘e + ( +±h»ad_key_t + +__key +è +__THROW +; + +1095
* + $±h»ad_g‘¥ecific + ( +±h»ad_key_t + +__key +è +__THROW +; + +1098
+ $±h»ad_£t¥ecific + ( +±h»ad_key_t + +__key +, + +1099 +__cÚ¡ + * +__poš‹r +è +__THROW + ; + +1102 #ifdeà +__USE_XOPEN2K + + +1104
+ $±h»ad_g‘ýuþockid + ( +±h»ad_t + +__th»ad_id +, + +1105 +__þockid_t + * +__þock_id +) + +1106 +__THROW + + `__nÚnuÎ + ((2)); + +1121
+ `±h»ad_©fÜk + ( (* +__´•¬e +) ( ), + +1122 (* +__·»Á +) ( ), + +1123 (* +__chžd +è( )è +__THROW +; + +1126 #ifdeà +__USE_EXTERN_INLINES + + +1128 +__ex‹º_šlše + + +1129 + `__NTH + ( + $±h»ad_equ® + ( +±h»ad_t + +__th»ad1 +,…th»ad_ˆ +__th»ad2 +)) + +1131 +__th»ad1 + =ð +__th»ad2 +; + +1132 + } +} + +1135 + g__END_DECLS + + + @/usr/include/sys/select.h + +22 #iâdeà +_SYS_SELECT_H + + +23 + #_SYS_SELECT_H + 1 + + ) + +25 + ~<ã©u»s.h +> + +28 + ~<b™s/ty³s.h +> + +31 + ~<b™s/£Ëù.h +> + +34 + ~<b™s/sig£t.h +> + +36 #iâdeà +__sig£t_t_defšed + + +37 + #__sig£t_t_defšed + + + ) + +38 +__sig£t_t + + tsig£t_t +; + +42 + #__Ãed_time_t + + + ) + +43 + #__Ãed_time¥ec + + + ) + +44 + ~<time.h +> + +45 + #__Ãed_timev® + + + ) + +46 + ~<b™s/time.h +> + +48 #iâdeà +__su£cÚds_t_defšed + + +49 +__su£cÚds_t + + tsu£cÚds_t +; + +50 + #__su£cÚds_t_defšed + + + ) + +55 + t__fd_mask +; + +58 #undeà +__NFDBITS + + +59 #undeà +__FDELT + + +60 #undeà +__FDMASK + + +62 + #__NFDBITS + (8 * (è ( +__fd_mask +)) + + ) + +63 + #__FDELT +( +d +è((dè/ +__NFDBITS +) + + ) + +64 + #__FDMASK +( +d +è(( +__fd_mask +è1 << ((dè% +__NFDBITS +)) + + ) + +71 #ifdeà +__USE_XOPEN + + +72 +__fd_mask + + mfds_b™s +[ +__FD_SETSIZE + / +__NFDBITS +]; + +73 + #__FDS_BITS +( +£t +è((£t)-> +fds_b™s +) + + ) + +75 +__fd_mask + + m__fds_b™s +[ +__FD_SETSIZE + / +__NFDBITS +]; + +76 + #__FDS_BITS +( +£t +è((£t)-> +__fds_b™s +) + + ) + +78 } + tfd_£t +; + +81 + #FD_SETSIZE + +__FD_SETSIZE + + + ) + +83 #ifdeà +__USE_MISC + + +85 +__fd_mask + + tfd_mask +; + +88 + #NFDBITS + +__NFDBITS + + + ) + +93 + #FD_SET +( +fd +, +fd£ +è + `__FD_SET + (fd, fd£) + + ) + +94 + #FD_CLR +( +fd +, +fd£ +è + `__FD_CLR + (fd, fd£) + + ) + +95 + #FD_ISSET +( +fd +, +fd£ +è + `__FD_ISSET + (fd, fd£) + + ) + +96 + #FD_ZERO +( +fd£ +è + `__FD_ZERO + (fd£) + + ) + +99 +__BEGIN_DECLS + + +109
+£Ëù + ( +__nfds +, +fd_£t + * +__»¡riù + +__»adfds +, + +110 +fd_£t + * +__»¡riù + +__wr™efds +, + +111 +fd_£t + * +__»¡riù + +__exû±fds +, + +112 +timev® + * +__»¡riù + +__timeout +); + +114 #ifdeà +__USE_XOPEN2K + + +121
+p£Ëù + ( +__nfds +, +fd_£t + * +__»¡riù + +__»adfds +, + +122 +fd_£t + * +__»¡riù + +__wr™efds +, + +123 +fd_£t + * +__»¡riù + +__exû±fds +, + +124 cÚ¡ +time¥ec + * +__»¡riù + +__timeout +, + +125 cÚ¡ +__sig£t_t + * +__»¡riù + +__sigmask +); + +128 + g__END_DECLS + + + @/usr/include/sys/sysmacros.h + +21 #iâdeà +_SYS_SYSMACROS_H + + +22 + #_SYS_SYSMACROS_H + 1 + + ) + +24 + ~<ã©u»s.h +> + +29 #ifdeà +__GLIBC_HAVE_LONG_LONG + + +30 +__ex‹nsiÚ__ + + +31
+ $gnu_dev_majÜ + ( +__dev +) + +32 +__THROW +; + +33 +__ex‹nsiÚ__ + + +34
+ $gnu_dev_mšÜ + ( +__dev +) + +35 +__THROW +; + +36 +__ex‹nsiÚ__ + + +37
+ $gnu_dev_makedev + ( +__majÜ +, + +38 +__mšÜ +) + +39 +__THROW +; + +41 #ià +defšed + +__GNUC__ + && __GNUC__ >ð2 && defšed +__USE_EXTERN_INLINES + + +42 +__ex‹nsiÚ__ + +__ex‹º_šlše + + +43 + `__NTH + ( + $gnu_dev_majÜ + ( +__dev +)) + +45 (( +__dev + >> 8) & 0xfff) | (( ) (__dev >> 32) & ~0xfff); + +46 + } +} + +48 +__ex‹nsiÚ__ + +__ex‹º_šlše + + +49 +__NTH + ( + $gnu_dev_mšÜ + ( +__dev +)) + +51 ( +__dev + & 0xff) | (( ) (__dev >> 12) & ~0xff); + +52 + } +} + +54 +__ex‹nsiÚ__ + +__ex‹º_šlše + + +55 +__NTH + ( + $gnu_dev_makedev + ( +__majÜ +, +__mšÜ +)) + +57 (( +__mšÜ + & 0xffè| (( +__majÜ + & 0xfff) << 8) + +58 | ((( è( +__mšÜ + & ~0xff)) << 12) + +59 | ((( è( +__majÜ + & ~0xfff)) << 32)); + +60 + } +} + +65 + #majÜ +( +dev +è + `gnu_dev_majÜ + (dev) + + ) + +66 + #mšÜ +( +dev +è + `gnu_dev_mšÜ + (dev) + + ) + +67 + #makedev +( +maj +, +mš +è + `gnu_dev_makedev + (maj, mš) + + ) + + @/usr/include/time.h + +23 #iâdef +_TIME_H + + +25 #ià(! +defšed + +__Ãed_time_t + && !defšed +__Ãed_þock_t + && \ + +26 ! +defšed + + g__Ãed_time¥ec +) + +27 + #_TIME_H + 1 + + ) + +28 + ~<ã©u»s.h +> + +30 + g__BEGIN_DECLS + + +34 #ifdef +_TIME_H + + +36 + #__Ãed_size_t + + + ) + +37 + #__Ãed_NULL + + + ) + +38 + ~<¡ddef.h +> + +42 + ~<b™s/time.h +> + +45 #ià! +defšed + +__STRICT_ANSI__ + && !defšed +__USE_XOPEN2K + + +46 #iâdeà +CLK_TCK + + +47 + #CLK_TCK + +CLOCKS_PER_SEC + + + ) + +53 #ià! +defšed + +__þock_t_defšed + && (defšed +_TIME_H + || defšed +__Ãed_þock_t +) + +54 + #__þock_t_defšed + 1 + + ) + +56 + ~<b™s/ty³s.h +> + +58 +__BEGIN_NAMESPACE_STD + + +60 +__þock_t + + tþock_t +; + +61 + g__END_NAMESPACE_STD + + +62 #ià +defšed + +__USE_XOPEN + || defšed +__USE_POSIX + || defšed +__USE_MISC + + +63 + $__USING_NAMESPACE_STD +( +þock_t +) + +67 #undeà +__Ãed_þock_t + + +69 #ià! +defšed + +__time_t_defšed + && (defšed +_TIME_H + || defšed +__Ãed_time_t +) + +70 + #__time_t_defšed + 1 + + ) + +72 + ~<b™s/ty³s.h +> + +74 +__BEGIN_NAMESPACE_STD + + +76 +__time_t + + ttime_t +; + +77 +__END_NAMESPACE_STD + + +78 #ià +defšed + +__USE_POSIX + || defšed +__USE_MISC + || defšed +__USE_SVID + + +79 + $__USING_NAMESPACE_STD +( +time_t +) + +83 #undeà +__Ãed_time_t + + +85 #ià! +defšed + +__þockid_t_defšed + && \ + +86 (( +defšed + +_TIME_H + && defšed +__USE_POSIX199309 +è|| defšed +__Ãed_þockid_t +) + +87 + #__þockid_t_defšed + 1 + + ) + +89 + ~<b™s/ty³s.h +> + +92 +__þockid_t + + tþockid_t +; + +95 #undeà +__þockid_time_t + + +97 #ià! +defšed + +__tim”_t_defšed + && \ + +98 (( +defšed + +_TIME_H + && defšed +__USE_POSIX199309 +è|| defšed +__Ãed_tim”_t +) + +99 + #__tim”_t_defšed + 1 + + ) + +101 + ~<b™s/ty³s.h +> + +104 +__tim”_t + + ttim”_t +; + +107 #undeà +__Ãed_tim”_t + + +110 #ià! +defšed + +__time¥ec_defšed + && \ + +111 (( +defšed + +_TIME_H + && \ + +112 ( +defšed + +__USE_POSIX199309 + || defšed +__USE_MISC +)) || \ + +113 +defšed + +__Ãed_time¥ec +) + +114 + #__time¥ec_defšed + 1 + + ) + +116 + ~<b™s/ty³s.h +> + +120 + stime¥ec + + +122 +__time_t + +tv_£c +; + +123 +tv_n£c +; + +127 #undeà +__Ãed_time¥ec + + +130 #ifdef +_TIME_H + + +131 +__BEGIN_NAMESPACE_STD + + +133 + stm + + +135 +tm_£c +; + +136 +tm_mš +; + +137 +tm_hour +; + +138 +tm_mday +; + +139 +tm_mÚ +; + +140 +tm_y—r +; + +141 +tm_wday +; + +142 +tm_yday +; + +143 +tm_isd¡ +; + +145 #ifdef +__USE_BSD + + +146 +tm_gmtoff +; + +147 +__cÚ¡ + * +tm_zÚe +; + +149 +__tm_gmtoff +; + +150 +__cÚ¡ + * +__tm_zÚe +; + +153 +__END_NAMESPACE_STD + + +154 #ià +defšed + +__USE_XOPEN + || defšed +__USE_POSIX + || defšed +__USE_MISC + + +155 + $__USING_NAMESPACE_STD +( +tm +) + +159 #ifdeà +__USE_POSIX199309 + + +161 + s™im”¥ec + + +163 +time¥ec + +™_š‹rv® +; + +164 +time¥ec + +™_v®ue +; + +168 +sigev’t +; + +172 #ifdeà +__USE_XOPEN2K + + +173 #iâdeà +__pid_t_defšed + + +174 +__pid_t + + tpid_t +; + +175 + #__pid_t_defšed + + + ) + +180 +__BEGIN_NAMESPACE_STD + + +183
+þock_t + + $þock + ( è +__THROW +; + +186
+time_t + + $time + ( +time_t + * +__tim” +è +__THROW +; + +189
+ $difáime + ( +time_t + +__time1 +,ime_ˆ +__time0 +) + +190 +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)); + +193
+time_t + + $mktime + ( +tm + * +__ +è +__THROW +; + +199
+size_t + + $¡ráime + (* +__»¡riù + +__s +, +size_t + +__maxsize +, + +200 +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +201 +__cÚ¡ + +tm + * +__»¡riù + +__ +è +__THROW +; + +202 +__END_NAMESPACE_STD + + +204 #ifdeà +__USE_XOPEN + + +207
* + $¡½time + ( +__cÚ¡ + * +__»¡riù + +__s +, + +208 +__cÚ¡ + * +__»¡riù + +__fmt +, +tm + * +__ +) + +209 +__THROW +; + +212 #ifdeà +__USE_XOPEN2K8 + + +215 + ~<xloÿË.h +> + +217
+size_t + + $¡ráime_l + (* +__»¡riù + +__s +, +size_t + +__maxsize +, + +218 +__cÚ¡ + * +__»¡riù + +__fÜm© +, + +219 +__cÚ¡ + +tm + * +__»¡riù + +__ +, + +220 +__loÿË_t + +__loc +è +__THROW +; + +223 #ifdeà +__USE_GNU + + +224
* + $¡½time_l + ( +__cÚ¡ + * +__»¡riù + +__s +, + +225 +__cÚ¡ + * +__»¡riù + +__fmt +, +tm + * +__ +, + +226 +__loÿË_t + +__loc +è +__THROW +; + +230 +__BEGIN_NAMESPACE_STD + + +233
+tm + * + $gmtime + ( +__cÚ¡ + +time_t + * +__tim” +è +__THROW +; + +237
+tm + * + $loÿÉime + ( +__cÚ¡ + +time_t + * +__tim” +è +__THROW +; + +238 +__END_NAMESPACE_STD + + +240 #ià +defšed + +__USE_POSIX + || defšed +__USE_MISC + + +243
+tm + * + $gmtime_r + ( +__cÚ¡ + +time_t + * +__»¡riù + +__tim” +, + +244 +tm + * +__»¡riù + +__ +è +__THROW +; + +248
+tm + * + $loÿÉime_r + ( +__cÚ¡ + +time_t + * +__»¡riù + +__tim” +, + +249 +tm + * +__»¡riù + +__ +è +__THROW +; + +252 +__BEGIN_NAMESPACE_STD + + +255
* + $asùime + ( +__cÚ¡ + +tm + * +__ +è +__THROW +; + +258
* + $ùime + ( +__cÚ¡ + +time_t + * +__tim” +è +__THROW +; + +259 +__END_NAMESPACE_STD + + +261 #ià +defšed + +__USE_POSIX + || defšed +__USE_MISC + + +266
* + $asùime_r + ( +__cÚ¡ + +tm + * +__»¡riù + +__ +, + +267 * +__»¡riù + +__buf +è +__THROW +; + +270
* + $ùime_r + ( +__cÚ¡ + +time_t + * +__»¡riù + +__tim” +, + +271 * +__»¡riù + +__buf +è +__THROW +; + +276
* +__tzÇme +[2]; + +277
+__daylight +; + +278
+__timezÚe +; + +281 #ifdef +__USE_POSIX + + +283
* +tzÇme +[2]; + +287
+ $tz£t + ( è +__THROW +; + +290 #ià +defšed + +__USE_SVID + || defšed +__USE_XOPEN + + +291
+daylight +; + +292
+timezÚe +; + +295 #ifdeà +__USE_SVID + + +298
+ $¡ime + ( +__cÚ¡ + +time_t + * +__wh’ +è +__THROW +; + +304 + #__i¦—p +( +y—r +) \ + +305 (( +y—r +è% 4 =ð0 && ((y—rè% 100 !ð0 || (y—rè% 400 =ð0)) + + ) + +308 #ifdeà +__USE_MISC + + +313
+time_t + + $timegm + ( +tm + * +__ +è +__THROW +; + +316
+time_t + + $tim–oÿl + ( +tm + * +__ +è +__THROW +; + +319
+ $dysize + ( +__y—r +è +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)); + +323 #ifdeà +__USE_POSIX199309 + + +328
+ `Çno¦“p + ( +__cÚ¡ + +time¥ec + * +__»que¡ed_time +, + +329 +time¥ec + * +__»maššg +); + +333
+ $þock_g‘»s + ( +þockid_t + +__þock_id +, +time¥ec + * +__»s +è +__THROW +; + +336
+ $þock_g‘time + ( +þockid_t + +__þock_id +, +time¥ec + * +__ +è +__THROW +; + +339
+ $þock_£‰ime + ( +þockid_t + +__þock_id +, +__cÚ¡ + +time¥ec + * +__ +) + +340 +__THROW +; + +342 #ifdeà +__USE_XOPEN2K + + +347
+ `þock_Çno¦“p + ( +þockid_t + +__þock_id +, +__æags +, + +348 +__cÚ¡ + +time¥ec + * +__»q +, + +349 +time¥ec + * +__»m +); + +352
+ $þock_g‘ýuþockid + ( +pid_t + +__pid +, +þockid_t + * +__þock_id +è +__THROW +; + +357
+ $tim”_ü—‹ + ( +þockid_t + +__þock_id +, + +358 +sigev’t + * +__»¡riù + +__evp +, + +359 +tim”_t + * +__»¡riù + +__tim”id +è +__THROW +; + +362
+ $tim”_d–‘e + ( +tim”_t + +__tim”id +è +__THROW +; + +365
+ $tim”_£‰ime + ( +tim”_t + +__tim”id +, +__æags +, + +366 +__cÚ¡ + +™im”¥ec + * +__»¡riù + +__v®ue +, + +367 +™im”¥ec + * +__»¡riù + +__ov®ue +è +__THROW +; + +370
+ $tim”_g‘time + ( +tim”_t + +__tim”id +, +™im”¥ec + * +__v®ue +) + +371 +__THROW +; + +374
+ $tim”_g‘ov”run + ( +tim”_t + +__tim”id +è +__THROW +; + +378 #ifdeà +__USE_XOPEN_EXTENDED + + +390
+g‘d©e_”r +; + +399
+tm + * + `g‘d©e + ( +__cÚ¡ + * +__¡ršg +); + +402 #ifdeà +__USE_GNU + + +413
+ `g‘d©e_r + ( +__cÚ¡ + * +__»¡riù + +__¡ršg +, + +414 +tm + * +__»¡riù + +__»sbuå +); + +417 +__END_DECLS + + + @/usr/include/wctype.h + +24 #iâdeà +_WCTYPE_H + + +26 + ~<ã©u»s.h +> + +27 + ~<b™s/ty³s.h +> + +29 #iâdeà +__Ãed_iswxxx + + +30 + #_WCTYPE_H + 1 + + ) + +33 + #__Ãed_wšt_t + + + ) + +34 + ~<¡ddef.h +> + +38 #iâdeà +WEOF + + +39 + #WEOF + (0xffffffffu) + + ) + +42 #undeà +__Ãed_iswxxx + + +47 #iâdeà +__iswxxx_defšed + + +48 + #__iswxxx_defšed + 1 + + ) + +50 +__BEGIN_NAMESPACE_C99 + + +53 + twùy³_t +; + +54 + g__END_NAMESPACE_C99 + + +56 #iâdeà +_ISwb™ + + +61 + ~<’dŸn.h +> + +62 #ià +__BYTE_ORDER + =ð +__BIG_ENDIAN + + +63 + #_ISwb™ +( +b™ +è(1 << (b™)) + + ) + +65 + #_ISwb™ +( +b™ +) \ + +66 (( +b™ +) < 8 ? () ((1UL << (bit)) << 24) \ + +67 : (( +b™ +) < 16 ? () ((1UL << (bit)) << 8) \ + +68 : (( +b™ +) < 24 ? () ((1UL << (bit)) >> 8) \ + +69 : (è((1UL << ( +b™ +)è>> 24)))) + + ) + +74 + m__ISwuµ” + = 0, + +75 + m__ISwlow” + = 1, + +76 + m__ISw®pha + = 2, + +77 + m__ISwdig™ + = 3, + +78 + m__ISwxdig™ + = 4, + +79 + m__ISw¥aû + = 5, + +80 + m__ISw´št + = 6, + +81 + m__ISwg¿ph + = 7, + +82 + m__ISwbÏnk + = 8, + +83 + m__ISwúŒl + = 9, + +84 + m__ISwpunù + = 10, + +85 + m__ISw®num + = 11, + +87 + m_ISwuµ” + = +_ISwb™ + ( +__ISwuµ” +), + +88 + m_ISwlow” + = +_ISwb™ + ( +__ISwlow” +), + +89 + m_ISw®pha + = +_ISwb™ + ( +__ISw®pha +), + +90 + m_ISwdig™ + = +_ISwb™ + ( +__ISwdig™ +), + +91 + m_ISwxdig™ + = +_ISwb™ + ( +__ISwxdig™ +), + +92 + m_ISw¥aû + = +_ISwb™ + ( +__ISw¥aû +), + +93 + m_ISw´št + = +_ISwb™ + ( +__ISw´št +), + +94 + m_ISwg¿ph + = +_ISwb™ + ( +__ISwg¿ph +), + +95 + m_ISwbÏnk + = +_ISwb™ + ( +__ISwbÏnk +), + +96 + m_ISwúŒl + = +_ISwb™ + ( +__ISwúŒl +), + +97 + m_ISwpunù + = +_ISwb™ + ( +__ISwpunù +), + +98 + m_ISw®num + = +_ISwb™ + ( +__ISw®num +) + +103 +__BEGIN_DECLS + + +105 +__BEGIN_NAMESPACE_C99 + + +112
+ $isw®num + ( +wšt_t + +__wc +è +__THROW +; + +118
+ $isw®pha + ( +wšt_t + +__wc +è +__THROW +; + +121
+ $iswúŒl + ( +wšt_t + +__wc +è +__THROW +; + +125
+ $iswdig™ + ( +wšt_t + +__wc +è +__THROW +; + +129
+ $iswg¿ph + ( +wšt_t + +__wc +è +__THROW +; + +134
+ $iswlow” + ( +wšt_t + +__wc +è +__THROW +; + +137
+ $isw´št + ( +wšt_t + +__wc +è +__THROW +; + +142
+ $iswpunù + ( +wšt_t + +__wc +è +__THROW +; + +147
+ $isw¥aû + ( +wšt_t + +__wc +è +__THROW +; + +152
+ $iswuµ” + ( +wšt_t + +__wc +è +__THROW +; + +157
+ $iswxdig™ + ( +wšt_t + +__wc +è +__THROW +; + +162 #ifdeà +__USE_ISOC99 + + +163
+ $iswbÏnk + ( +wšt_t + +__wc +è +__THROW +; + +172
+wùy³_t + + $wùy³ + ( +__cÚ¡ + * +__´Ý”ty +è +__THROW +; + +176
+ $iswùy³ + ( +wšt_t + +__wc +, +wùy³_t + +__desc +è +__THROW +; + +177 +__END_NAMESPACE_C99 + + +184 +__BEGIN_NAMESPACE_C99 + + +187 +__cÚ¡ + + t__št32_t + * + twù¿ns_t +; + +188 +__END_NAMESPACE_C99 + + +189 #ifdeà +__USE_GNU + + +190 + $__USING_NAMESPACE_C99 +( +wù¿ns_t +) + +193 +__BEGIN_NAMESPACE_C99 + + +195
+wšt_t + + $towlow” + ( +wšt_t + +__wc +è +__THROW +; + +198
+wšt_t + + $towuµ” + ( +wšt_t + +__wc +è +__THROW +; + +199 +__END_NAMESPACE_C99 + + +201 +__END_DECLS + + +208 #ifdeà +_WCTYPE_H + + +214 +__BEGIN_DECLS + + +216 +__BEGIN_NAMESPACE_C99 + + +219
+wù¿ns_t + + $wù¿ns + ( +__cÚ¡ + * +__´Ý”ty +è +__THROW +; + +222
+wšt_t + + $towù¿ns + ( +wšt_t + +__wc +, +wù¿ns_t + +__desc +è +__THROW +; + +223 +__END_NAMESPACE_C99 + + +225 #ifdeà +__USE_XOPEN2K8 + + +227 + ~<xloÿË.h +> + +231
+ $isw®num_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +237
+ $isw®pha_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +240
+ $iswúŒl_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +244
+ $iswdig™_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +248
+ $iswg¿ph_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +253
+ $iswlow”_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +256
+ $isw´št_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +261
+ $iswpunù_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +266
+ $isw¥aû_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +271
+ $iswuµ”_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +276
+ $iswxdig™_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +281
+ $iswbÏnk_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +285
+wùy³_t + + $wùy³_l + ( +__cÚ¡ + * +__´Ý”ty +, +__loÿË_t + +__loÿË +) + +286 +__THROW +; + +290
+ $iswùy³_l + ( +wšt_t + +__wc +, +wùy³_t + +__desc +, +__loÿË_t + +__loÿË +) + +291 +__THROW +; + +299
+wšt_t + + $towlow”_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +302
+wšt_t + + $towuµ”_l + ( +wšt_t + +__wc +, +__loÿË_t + +__loÿË +è +__THROW +; + +306
+wù¿ns_t + + $wù¿ns_l + ( +__cÚ¡ + * +__´Ý”ty +, +__loÿË_t + +__loÿË +) + +307 +__THROW +; + +310
+wšt_t + + $towù¿ns_l + ( +wšt_t + +__wc +, +wù¿ns_t + +__desc +, + +311 +__loÿË_t + +__loÿË +è +__THROW +; + +315 +__END_DECLS + + + @/usr/include/bits/errno.h + +20 #ifdeà +_ERRNO_H + + +22 #undeà +EDOM + + +23 #undeà +EILSEQ + + +24 #undeà +ERANGE + + +25 + ~<lšux/”ºo.h +> + +28 + #ENOTSUP + +EOPNOTSUPP + + + ) + +31 #iâdeà +ECANCELED + + +32 + #ECANCELED + 125 + + ) + +36 #iâdeà +EOWNERDEAD + + +37 + #EOWNERDEAD + 130 + + ) + +38 + #ENOTRECOVERABLE + 131 + + ) + +41 #iâdeà +__ASSEMBLER__ + + +43
* + $__”ºo_loÿtiÚ + ( è +__THROW + + `__©Œibu‹__ + (( +__cÚ¡__ +)); + +45 #ià! +defšed + +_LIBC + || defšed +_LIBC_REENTRANT + + +47 + #”ºo + (* + `__”ºo_loÿtiÚ + ()) + + ) + +52 #ià! +defšed + +_ERRNO_H + && defšed +__Ãed_Em©h + + +56 + #EDOM + 33 + + ) + +57 + #EILSEQ + 84 + + ) + +58 + #ERANGE + 34 + + ) + + @/usr/include/bits/select.h + +19 #iâdeà +_SYS_SELECT_H + + +23 + ~<b™s/wÜdsize.h +> + +26 #ià +defšed + +__GNUC__ + && __GNUC__ >= 2 + +28 #ià +__WORDSIZE + == 64 + +29 + #__FD_ZERO_STOS + "¡osq" + + ) + +31 + #__FD_ZERO_STOS + "¡o¦" + + ) + +34 + #__FD_ZERO +( +fd¥ +) \ + +36 +__d0 +, +__d1 +; \ + +37 +__asm__ + + `__vÞ©že__ + ("þd;„•; " +__FD_ZERO_STOS + \ + +38 : "=c" ( +__d0 +), "=D" ( +__d1 +) \ + +39 : "a" (0), "0" ( ( +fd_£t +) \ + +40 / ( +__fd_mask +)), \ + +41 "1" (& + `__FDS_BITS + ( +fd¥ +)[0]) \ + +43 } 0) + + ) + +49 + #__FD_ZERO +( +£t +) \ + +51 +__i +; \ + +52 +fd_£t + * +__¬r + = ( +£t +); \ + +53 +__i + = 0; __˜< ( +fd_£t +è/ ( +__fd_mask +); ++__i) \ + +54 + `__FDS_BITS + ( +__¬r +)[ +__i +] = 0; \ + +55 } 0) + + ) + +59 + #__FD_SET +( +d +, +£t +è( + `__FDS_BITS + (£t)[ + `__FDELT + (d)] |ð + `__FDMASK + (d)) + + ) + +60 + #__FD_CLR +( +d +, +£t +è( + `__FDS_BITS + (£t)[ + `__FDELT + (d)] &ð~ + `__FDMASK + (d)) + + ) + +61 + #__FD_ISSET +( +d +, +£t +) \ + +62 (( + `__FDS_BITS + ( +£t +)[ + `__FDELT + ( +d +)] & + `__FDMASK + (d)è!ð0) + + ) + + @/usr/include/bits/setjmp.h + +20 #iâdeà +_BITS_SETJMP_H + + +21 + #_BITS_SETJMP_H + 1 + + ) + +23 #ià! +defšed + +_SETJMP_H + && !defšed +_PTHREAD_H + + +27 + ~<b™s/wÜdsize.h +> + +29 #iâdeà +_ASM + + +31 #ià +__WORDSIZE + == 64 + +32 + t__jmp_buf +[8]; + +34 + t__jmp_buf +[6]; + + @/usr/include/bits/sigset.h + +21 #iâdef +_SIGSET_H_ty³s + + +22 + #_SIGSET_H_ty³s + 1 + + ) + +24 + t__sig_©omic_t +; + +28 + #_SIGSET_NWORDS + (1024 / (8 * ( ))) + + ) + +31 + m__v® +[ +_SIGSET_NWORDS +]; + +32 } + t__sig£t_t +; + +43 #ià! +defšed + +_SIGSET_H_âs + && defšed +_SIGNAL_H + + +44 + #_SIGSET_H_âs + 1 + + ) + +46 #iâdeà +_EXTERN_INLINE + + +47 + #_EXTERN_INLINE + +__ex‹º_šlše + + + ) + +51 + #__sigmask +( +sig +) \ + +52 ((( è1è<< ((( +sig +è- 1è% (8 * ( )))) + + ) + +55 + #__sigwÜd +( +sig +è(((sigè- 1è/ (8 * ( ))) + + ) + +57 #ià +defšed + +__GNUC__ + && __GNUC__ >= 2 + +58 + #__sigem±y£t +( +£t +) \ + +59 ( + `__ex‹nsiÚ__ + ({ +__út + = +_SIGSET_NWORDS +; \ + +60 +sig£t_t + * +__£t + = ( +£t +); \ + +61 -- +__út + >ð0è +__£t +-> +__v® +[__cnt] = 0; \ + +62 0; })) + + ) + +63 + #__sigfžl£t +( +£t +) \ + +64 ( + `__ex‹nsiÚ__ + ({ +__út + = +_SIGSET_NWORDS +; \ + +65 +sig£t_t + * +__£t + = ( +£t +); \ + +66 -- +__út + >ð0è +__£t +-> +__v® +[__cnt] = ~0UL; \ + +67 0; })) + + ) + +69 #ifdeà +__USE_GNU + + +73 + #__sigi£m±y£t +( +£t +) \ + +74 ( + `__ex‹nsiÚ__ + ({ +__út + = +_SIGSET_NWORDS +; \ + +75 cÚ¡ +sig£t_t + * +__£t + = ( +£t +); \ + +76 +__»t + = +__£t +-> +__v® +[-- +__út +]; \ + +77 ! +__»t + && -- +__út + >= 0) \ + +78 +__»t + = +__£t +-> +__v® +[ +__út +]; \ + +79 +__»t + =ð0; })) + + ) + +80 + #__sigªd£t +( +de¡ +, +Ëá +, +right +) \ + +81 ( + `__ex‹nsiÚ__ + ({ +__út + = +_SIGSET_NWORDS +; \ + +82 +sig£t_t + * +__de¡ + = ( +de¡ +); \ + +83 cÚ¡ +sig£t_t + * +__Ëá + = ( +Ëá +); \ + +84 cÚ¡ +sig£t_t + * +__right + = ( +right +); \ + +85 -- +__út + >= 0) \ + +86 +__de¡ +-> +__v® +[ +__út +] = ( +__Ëá +->__val[__cnt] \ + +87 & +__right +-> +__v® +[ +__út +]); \ + +88 0; })) + + ) + +89 + #__sigÜ£t +( +de¡ +, +Ëá +, +right +) \ + +90 ( + `__ex‹nsiÚ__ + ({ +__út + = +_SIGSET_NWORDS +; \ + +91 +sig£t_t + * +__de¡ + = ( +de¡ +); \ + +92 cÚ¡ +sig£t_t + * +__Ëá + = ( +Ëá +); \ + +93 cÚ¡ +sig£t_t + * +__right + = ( +right +); \ + +94 -- +__út + >= 0) \ + +95 +__de¡ +-> +__v® +[ +__út +] = ( +__Ëá +->__val[__cnt] \ + +96 | +__right +-> +__v® +[ +__út +]); \ + +97 0; })) + + ) + +104
+__sigismemb” + ( +__cÚ¡ + +__sig£t_t + *, ); + +105
+__sigadd£t + ( +__sig£t_t + *, ); + +106
+__sigd–£t + ( +__sig£t_t + *, ); + +108 #ifdeà +__USE_EXTERN_INLINES + + +109 + #__SIGSETFN +( +NAME +, +BODY +, +CONST +) \ + +110 +_EXTERN_INLINE + \ + +111 + `NAME + ( +CONST + +__sig£t_t + * +__£t +, +__sig +) \ + +113 +__mask + = + `__sigmask + ( +__sig +); \ + +114 +__wÜd + = + `__sigwÜd + ( +__sig +); \ + +115 +BODY +; \ + +116 } + + ) + +118 +__SIGSETFN + ( +__sigismemb” +, ( +__£t +-> +__v® +[ +__wÜd +] & +__mask +è? 1 : 0, +__cÚ¡ +) + +119 +__SIGSETFN + ( +__sigadd£t +, (( +__£t +-> +__v® +[ +__wÜd +] |ð +__mask +), 0), ) + +120 +__SIGSETFN + ( +__sigd–£t +, (( +__£t +-> +__v® +[ +__wÜd +] &ð~ +__mask +), 0), ) + +122 #undeà +__SIGSETFN + + + @/usr/include/bits/time.h + +24 #iâdeà +__Ãed_timev® + + +25 #iâdeà +_BITS_TIME_H + + +26 + #_BITS_TIME_H + 1 + + ) + +34 + #CLOCKS_PER_SEC + 1000000l + + ) + +36 #ià! +defšed + +__STRICT_ANSI__ + && !defšed +__USE_XOPEN2K + + +39 + ~<b™s/ty³s.h +> + +40
+__syscÚf + (); + +41 + #CLK_TCK + (( +__þock_t +è + `__syscÚf + (2)è + + ) + +44 #ifdeà +__USE_POSIX199309 + + +46 + #CLOCK_REALTIME + 0 + + ) + +48 + #CLOCK_MONOTONIC + 1 + + ) + +50 + #CLOCK_PROCESS_CPUTIME_ID + 2 + + ) + +52 + #CLOCK_THREAD_CPUTIME_ID + 3 + + ) + +55 + #TIMER_ABSTIME + 1 + + ) + +61 #ifdeà +__Ãed_timev® + + +62 #undeà +__Ãed_timev® + + +63 #iâdeà +_STRUCT_TIMEVAL + + +64 + #_STRUCT_TIMEVAL + 1 + + ) + +65 + ~<b™s/ty³s.h +> + +69 + stimev® + + +71 +__time_t + + mtv_£c +; + +72 +__su£cÚds_t + + mtv_u£c +; + + @/usr/include/sched.h + +20 #iâdef +_SCHED_H + + +21 + #_SCHED_H + 1 + + ) + +23 + ~<ã©u»s.h +> + +26 + ~<b™s/ty³s.h +> + +28 + #__Ãed_size_t + + + ) + +29 + ~<¡ddef.h +> + +31 + #__Ãed_time¥ec + + + ) + +32 + ~<time.h +> + +35 + ~<b™s/sched.h +> + +37 + #sched_´iÜ™y + +__sched_´iÜ™y + + + ) + +40 +__BEGIN_DECLS + + +43
+ $sched_£¬am + ( +__pid_t + +__pid +, +__cÚ¡ + +sched_·¿m + * +__·¿m +) + +44 +__THROW +; + +47
+ $sched_g‘·¿m + ( +__pid_t + +__pid +, +sched_·¿m + * +__·¿m +è +__THROW +; + +50
+ $sched_£tscheduËr + ( +__pid_t + +__pid +, +__pÞicy +, + +51 +__cÚ¡ + +sched_·¿m + * +__·¿m +è +__THROW +; + +54
+ $sched_g‘scheduËr + ( +__pid_t + +__pid +è +__THROW +; + +57
+ $sched_y›ld + ( è +__THROW +; + +60
+ $sched_g‘_´iÜ™y_max + ( +__®gÜ™hm +è +__THROW +; + +63
+ $sched_g‘_´iÜ™y_mš + ( +__®gÜ™hm +è +__THROW +; + +66
+ $sched_¼_g‘_š‹rv® + ( +__pid_t + +__pid +, +time¥ec + * +__t +è +__THROW +; + +69 #ifdeà +__USE_GNU + + +71 + #CPU_SETSIZE + +__CPU_SETSIZE + + + ) + +72 + #CPU_SET +( +ýu +, +ýu£ +è + `__CPU_SET_S + (ýu, ( +ýu_£t_t +), cpu£) + + ) + +73 + #CPU_CLR +( +ýu +, +ýu£ +è + `__CPU_CLR_S + (ýu, ( +ýu_£t_t +), cpu£) + + ) + +74 + #CPU_ISSET +( +ýu +, +ýu£ +è + `__CPU_ISSET_S + (ýu, ( +ýu_£t_t +), \ + +75 +ýu£ +) + + ) + +76 + #CPU_ZERO +( +ýu£ +è + `__CPU_ZERO_S + ( ( +ýu_£t_t +), cpu£) + + ) + +77 + #CPU_COUNT +( +ýu£ +è + `__CPU_COUNT_S + ( ( +ýu_£t_t +), cpu£) + + ) + +79 + #CPU_SET_S +( +ýu +, +£tsize +, +ýu£ +è + `__CPU_SET_S + (ýu, s‘size, cpu£) + + ) + +80 + #CPU_CLR_S +( +ýu +, +£tsize +, +ýu£ +è + `__CPU_CLR_S + (ýu, s‘size, cpu£) + + ) + +81 + #CPU_ISSET_S +( +ýu +, +£tsize +, +ýu£ +è + `__CPU_ISSET_S + (cpu, setsize, \ + +82 +ýu£ +) + + ) + +83 + #CPU_ZERO_S +( +£tsize +, +ýu£ +è + `__CPU_ZERO_S + (£tsize, cpu£) + + ) + +84 + #CPU_COUNT_S +( +£tsize +, +ýu£ +è + `__CPU_COUNT_S + (£tsize, cpu£) + + ) + +86 + #CPU_EQUAL +( +ýu£1 +, +ýu£2 +) \ + +87 + `__CPU_EQUAL_S + ( ( +ýu_£t_t +), +ýu£1 +, +ýu£2 +) + + ) + +88 + #CPU_EQUAL_S +( +£tsize +, +ýu£1 +, +ýu£2 +) \ + +89 + `__CPU_EQUAL_S + ( +£tsize +, +ýu£1 +, +ýu£2 +) + + ) + +91 + #CPU_AND +( +de¡£t +, +¤c£t1 +, +¤c£t2 +) \ + +92 + `__CPU_OP_S + ( ( +ýu_£t_t +), +de¡£t +, +¤c£t1 +, +¤c£t2 +, &) + + ) + +93 + #CPU_OR +( +de¡£t +, +¤c£t1 +, +¤c£t2 +) \ + +94 + `__CPU_OP_S + ( ( +ýu_£t_t +), +de¡£t +, +¤c£t1 +, +¤c£t2 +, |) + + ) + +95 + #CPU_XOR +( +de¡£t +, +¤c£t1 +, +¤c£t2 +) \ + +96 + `__CPU_OP_S + ( ( +ýu_£t_t +), +de¡£t +, +¤c£t1 +, +¤c£t2 +, ^) + + ) + +97 + #CPU_AND_S +( +£tsize +, +de¡£t +, +¤c£t1 +, +¤c£t2 +) \ + +98 + `__CPU_OP_S + ( +£tsize +, +de¡£t +, +¤c£t1 +, +¤c£t2 +, &) + + ) + +99 + #CPU_OR_S +( +£tsize +, +de¡£t +, +¤c£t1 +, +¤c£t2 +) \ + +100 + `__CPU_OP_S + ( +£tsize +, +de¡£t +, +¤c£t1 +, +¤c£t2 +, |) + + ) + +101 + #CPU_XOR_S +( +£tsize +, +de¡£t +, +¤c£t1 +, +¤c£t2 +) \ + +102 + `__CPU_OP_S + ( +£tsize +, +de¡£t +, +¤c£t1 +, +¤c£t2 +, ^) + + ) + +104 + #CPU_ALLOC_SIZE +( +couÁ +è + `__CPU_ALLOC_SIZE + (couÁ) + + ) + +105 + #CPU_ALLOC +( +couÁ +è + `__CPU_ALLOC + (couÁ) + + ) + +106 + #CPU_FREE +( +ýu£t +è + `__CPU_FREE + (ýu£t) + + ) + +110
+ $sched_£ffš™y + ( +__pid_t + +__pid +, +size_t + +__ýu£tsize +, + +111 +__cÚ¡ + +ýu_£t_t + * +__ýu£t +è +__THROW +; + +114
+ $sched_g‘affš™y + ( +__pid_t + +__pid +, +size_t + +__ýu£tsize +, + +115 +ýu_£t_t + * +__ýu£t +è +__THROW +; + +118 +__END_DECLS + + + @/usr/include/signal.h + +23 #iâdef +_SIGNAL_H + + +25 #ià! +defšed + +__Ãed_sig_©omic_t + && !defšed +__Ãed_sig£t_t + + +26 + #_SIGNAL_H + + + ) + +29 + ~<ã©u»s.h +> + +31 + g__BEGIN_DECLS + + +33 + ~<b™s/sig£t.h +> + +37 #ià +defšed + +__Ãed_sig_©omic_t + || defšed +_SIGNAL_H + + +38 #iâdeà +__sig_©omic_t_defšed + + +39 + #__sig_©omic_t_defšed + + + ) + +40 +__BEGIN_NAMESPACE_STD + + +41 +__sig_©omic_t + + tsig_©omic_t +; + +42 + g__END_NAMESPACE_STD + + +44 #undeà +__Ãed_sig_©omic_t + + +47 #ià +defšed + +__Ãed_sig£t_t + || (defšed +_SIGNAL_H + && defšed +__USE_POSIX +) + +48 #iâdeà +__sig£t_t_defšed + + +49 + #__sig£t_t_defšed + + + ) + +50 +__sig£t_t + + tsig£t_t +; + +52 #undeà +__Ãed_sig£t_t + + +55 #ifdeà +_SIGNAL_H + + +57 + ~<b™s/ty³s.h +> + +58 + ~<b™s/signum.h +> + +60 #ià +defšed + +__USE_XOPEN + || defšed +__USE_XOPEN2K + + +61 #iâdeà +__pid_t_defšed + + +62 +__pid_t + + tpid_t +; + +63 + #__pid_t_defšed + + + ) + +65 #ifdeà +__USE_XOPEN + + +67 #iâdeà +__uid_t_defšed + + +68 +__uid_t + + tuid_t +; + +69 + #__uid_t_defšed + + + ) + +73 #ifdeà +__USE_POSIX199309 + + +75 + #__Ãed_time¥ec + + + ) + +76 + ~<time.h +> + +79 + ~<b™s/sigšfo.h +> + +84 (* + t__sighªdËr_t +) (); + +89
+__sighªdËr_t + + $__sysv_sigÇl + ( +__sig +, +__sighªdËr_t + +__hªdËr +) + +90 +__THROW +; + +91 #ifdeà +__USE_GNU + + +92
+__sighªdËr_t + + $sysv_sigÇl + ( +__sig +, +__sighªdËr_t + +__hªdËr +) + +93 +__THROW +; + +99 +__BEGIN_NAMESPACE_STD + + +100 #ifdeà +__USE_BSD + + +101
+__sighªdËr_t + + $sigÇl + ( +__sig +, +__sighªdËr_t + +__hªdËr +) + +102 +__THROW +; + +105 #ifdeà +__REDIRECT_NTH + + +106
+__sighªdËr_t + + `__REDIRECT_NTH + ( +sigÇl +, + +107 ( +__sig +, +__sighªdËr_t + +__hªdËr +), + +108 +__sysv_sigÇl +); + +110 + #sigÇl + +__sysv_sigÇl + + + ) + +113 +__END_NAMESPACE_STD + + +115 #ifdeà +__USE_XOPEN + + +118
+__sighªdËr_t + + $bsd_sigÇl + ( +__sig +, +__sighªdËr_t + +__hªdËr +) + +119 +__THROW +; + +125 #ifdeà +__USE_POSIX + + +126
+ $kžl + ( +__pid_t + +__pid +, +__sig +è +__THROW +; + +129 #ià +defšed + +__USE_BSD + || defšed +__USE_XOPEN_EXTENDED + + +133
+ $kžÍg + ( +__pid_t + +__pg½ +, +__sig +è +__THROW +; + +136 +__BEGIN_NAMESPACE_STD + + +138
+ $¿i£ + ( +__sig +è +__THROW +; + +139 +__END_NAMESPACE_STD + + +141 #ifdeà +__USE_SVID + + +143
+__sighªdËr_t + + $ssigÇl + ( +__sig +, +__sighªdËr_t + +__hªdËr +) + +144 +__THROW +; + +145
+ $gsigÇl + ( +__sig +è +__THROW +; + +148 #ià +defšed + +__USE_MISC + || defšed +__USE_XOPEN2K + + +150
+ `psigÇl + ( +__sig +, +__cÚ¡ + * +__s +); + +153 #ifdeà +__USE_XOPEN2K + + +155
+ `psigšfo + ( +__cÚ¡ + +sigšfo_t + * +__pšfo +, __cÚ¡ * +__s +); + +168
+ `__sig·u£ + ( +__sig_Ü_mask +, +__is_sig +); + +170 #ifdeà +__FAVOR_BSD + + +173
+ $sig·u£ + ( +__mask +è +__THROW + +__©Œibu‹_d•»ÿ‹d__ +; + +175 #ifdeà +__USE_XOPEN + + +176 #ifdeà +__GNUC__ + + +177
+ $sig·u£ + ( +__sig +è + `__asm__ + ("__xpg_sigpause"); + +180 + #sig·u£ +( +sig +è + `__sig·u£ + ((sig), 1) + + ) + +186 #ifdeà +__USE_BSD + + +193 + #sigmask +( +sig +è + `__sigmask +(sig) + + ) + +196
+ $sigblock + ( +__mask +è +__THROW + +__©Œibu‹_d•»ÿ‹d__ +; + +199
+ $sig£tmask + ( +__mask +è +__THROW + +__©Œibu‹_d•»ÿ‹d__ +; + +202
+ $sigg‘mask + ( è +__THROW + +__©Œibu‹_d•»ÿ‹d__ +; + +206 #ifdeà +__USE_MISC + + +207 + #NSIG + +_NSIG + + + ) + +210 #ifdeà +__USE_GNU + + +211 +__sighªdËr_t + + tsighªdËr_t +; + +215 #ifdeà +__USE_BSD + + +216 +__sighªdËr_t + + tsig_t +; + +219 #ifdeà +__USE_POSIX + + +222
+ $sigem±y£t + ( +sig£t_t + * +__£t +è +__THROW + + `__nÚnuÎ + ((1)); + +225
+ $sigfžl£t + ( +sig£t_t + * +__£t +è +__THROW + + `__nÚnuÎ + ((1)); + +228
+ $sigadd£t + ( +sig£t_t + * +__£t +, +__signo +è +__THROW + + `__nÚnuÎ + ((1)); + +231
+ $sigd–£t + ( +sig£t_t + * +__£t +, +__signo +è +__THROW + + `__nÚnuÎ + ((1)); + +234
+ $sigismemb” + ( +__cÚ¡ + +sig£t_t + * +__£t +, +__signo +) + +235 +__THROW + + `__nÚnuÎ + ((1)); + +237 #ifdeà +__USE_GNU + + +239
+ $sigi£m±y£t + ( +__cÚ¡ + +sig£t_t + * +__£t +è +__THROW + + `__nÚnuÎ + ((1)); + +242
+ $sigªd£t + ( +sig£t_t + * +__£t +, +__cÚ¡ + sig£t_ˆ* +__Ëá +, + +243 +__cÚ¡ + +sig£t_t + * +__right +è +__THROW + + `__nÚnuÎ + ((1, 2, 3)); + +246
+ $sigÜ£t + ( +sig£t_t + * +__£t +, +__cÚ¡ + sig£t_ˆ* +__Ëá +, + +247 +__cÚ¡ + +sig£t_t + * +__right +è +__THROW + + `__nÚnuÎ + ((1, 2, 3)); + +252 + ~<b™s/sigaùiÚ.h +> + +255
+ $sig´ocmask + ( +__how +, +__cÚ¡ + +sig£t_t + * +__»¡riù + +__£t +, + +256 +sig£t_t + * +__»¡riù + +__o£t +è +__THROW +; + +263
+ $sigsu¥’d + ( +__cÚ¡ + +sig£t_t + * +__£t +è + `__nÚnuÎ + ((1)); + +266
+ $sigaùiÚ + ( +__sig +, +__cÚ¡ + +sigaùiÚ + * +__»¡riù + +__aù +, + +267 +sigaùiÚ + * +__»¡riù + +__ßù +è +__THROW +; + +270
+ $sig³ndšg + ( +sig£t_t + * +__£t +è +__THROW + + `__nÚnuÎ + ((1)); + +277
+ $sigwa™ + ( +__cÚ¡ + +sig£t_t + * +__»¡riù + +__£t +, *__»¡riù +__sig +) + +278 + `__nÚnuÎ + ((1, 2)); + +280 #ifdeà +__USE_POSIX199309 + + +285
+ $sigwa™šfo + ( +__cÚ¡ + +sig£t_t + * +__»¡riù + +__£t +, + +286 +sigšfo_t + * +__»¡riù + +__šfo +è + `__nÚnuÎ + ((1)); + +293
+ $sigtimedwa™ + ( +__cÚ¡ + +sig£t_t + * +__»¡riù + +__£t +, + +294 +sigšfo_t + * +__»¡riù + +__šfo +, + +295 +__cÚ¡ + +time¥ec + * +__»¡riù + +__timeout +) + +296 + `__nÚnuÎ + ((1)); + +300
+ $sigqueue + ( +__pid_t + +__pid +, +__sig +, +__cÚ¡ + +sigv® + +__v® +) + +301 +__THROW +; + +306 #ifdeà +__USE_BSD + + +310
+__cÚ¡ + *__cÚ¡ +_sys_sigli¡ +[ +_NSIG +]; + +311
+__cÚ¡ + *__cÚ¡ +sys_sigli¡ +[ +_NSIG +]; + +314 + ssigvec + + +316 +__sighªdËr_t + +sv_hªdËr +; + +317 +sv_mask +; + +319 +sv_æags +; + +320 + #sv_Ú¡ack + +sv_æags + + + ) + +324 + #SV_ONSTACK + (1 << 0) + + ) + +325 + #SV_INTERRUPT + (1 << 1) + + ) + +326 + #SV_RESETHAND + (1 << 2) + + ) + +334
+ $sigvec + ( +__sig +, +__cÚ¡ + +sigvec + * +__vec +, + +335 +sigvec + * +__ovec +è +__THROW +; + +339 + ~<b™s/sigcÚ‹xt.h +> + +342
+ $sig»tuº + ( +sigcÚ‹xt + * +__sý +è +__THROW +; + +347 #ià +defšed + +__USE_BSD + || defšed +__USE_XOPEN_EXTENDED + + +348 + #__Ãed_size_t + + + ) + +349 + ~<¡ddef.h +> + +354
+ $sigš‹¼u± + ( +__sig +, +__š‹¼u± +è +__THROW +; + +356 + ~<b™s/sig¡ack.h +> + +357 #ifdeà +__USE_XOPEN + + +359 + ~<sys/ucÚ‹xt.h +> + +365
+ $sig¡ack + ( +sig¡ack + * +__ss +, sig¡ack * +__oss +) + +366 +__THROW + +__©Œibu‹_d•»ÿ‹d__ +; + +370
+ $sig®t¡ack + ( +__cÚ¡ + +sig®t¡ack + * +__»¡riù + +__ss +, + +371 +sig®t¡ack + * +__»¡riù + +__oss +è +__THROW +; + +375 #ifdeà +__USE_XOPEN_EXTENDED + + +379
+ $sighÞd + ( +__sig +è +__THROW +; + +382
+ $sig»l£ + ( +__sig +è +__THROW +; + +385
+ $sigignÜe + ( +__sig +è +__THROW +; + +388
+__sighªdËr_t + + $sig£t + ( +__sig +, +__sighªdËr_t + +__di¥ +è +__THROW +; + +391 #ià +defšed + +__USE_POSIX199506 + || defšed +__USE_UNIX98 + + +394 + ~<b™s/±h»adty³s.h +> + +395 + ~<b™s/sigth»ad.h +> + +402
+ $__libc_cu¼’t_sig¹mš + ( è +__THROW +; + +404
+ $__libc_cu¼’t_sig¹max + ( è +__THROW +; + +408 +__END_DECLS + + + @/usr/include/bits/sched.h + +22 #iâdeà +__Ãed_sched·¿m + + +24 #iâdeà +_SCHED_H + + +30 + #SCHED_OTHER + 0 + + ) + +31 + #SCHED_FIFO + 1 + + ) + +32 + #SCHED_RR + 2 + + ) + +33 #ifdeà +__USE_GNU + + +34 + #SCHED_BATCH + 3 + + ) + +37 #ifdeà +__USE_MISC + + +39 + #CSIGNAL + 0x000000fà + + ) + +40 + #CLONE_VM + 0x00000100 + + ) + +41 + #CLONE_FS + 0x00000200 + + ) + +42 + #CLONE_FILES + 0x00000400 + + ) + +43 + #CLONE_SIGHAND + 0x00000800 + + ) + +44 + #CLONE_PTRACE + 0x00002000 + + ) + +45 + #CLONE_VFORK + 0x00004000 + + ) + +47 + #CLONE_PARENT + 0x00008000 + + ) + +49 + #CLONE_THREAD + 0x00010000 + + ) + +50 + #CLONE_NEWNS + 0x00020000 + + ) + +51 + #CLONE_SYSVSEM + 0x00040000 + + ) + +52 + #CLONE_SETTLS + 0x00080000 + + ) + +53 + #CLONE_PARENT_SETTID + 0x00100000 + + ) + +55 + #CLONE_CHILD_CLEARTID + 0x00200000 + + ) + +57 + #CLONE_DETACHED + 0x00400000 + + ) + +58 + #CLONE_UNTRACED + 0x00800000 + + ) + +60 + #CLONE_CHILD_SETTID + 0x01000000 + + ) + +62 + #CLONE_NEWUTS + 0x04000000 + + ) + +63 + #CLONE_NEWIPC + 0x08000000 + + ) + +64 + #CLONE_NEWUSER + 0x10000000 + + ) + +65 + #CLONE_NEWPID + 0x20000000 + + ) + +66 + #CLONE_NEWNET + 0x40000000 + + ) + +67 + #CLONE_IO + 0x80000000 + + ) + +71 + ssched_·¿m + + +73 + m__sched_´iÜ™y +; + +76 + g__BEGIN_DECLS + + +78 #ifdeà +__USE_MISC + + +80
+þÚe + ((* +__â +è( * +__¬g +), * +__chžd_¡ack +, + +81 +__æags +, * +__¬g +, ...è +__THROW +; + +84
+ $unsh¬e + ( +__æags +è +__THROW +; + +87
+ $sched_g‘ýu + ( è +__THROW +; + +90 +__END_DECLS + + +94 #ià! +defšed + +__defšed_sched·¿m + \ + +95 && ( +defšed + +__Ãed_sched·¿m + || defšed +_SCHED_H +) + +96 + #__defšed_sched·¿m + 1 + + ) + +98 + s__sched_·¿m + + +100 +__sched_´iÜ™y +; + +102 #undeà +__Ãed_sched·¿m + + +106 #ià +defšed + +_SCHED_H + && !defšed +__ýu_£t_t_defšed + + +107 + #__ýu_£t_t_defšed + + + ) + +109 + #__CPU_SETSIZE + 1024 + + ) + +110 + #__NCPUBITS + (8 * ( +__ýu_mask +)) + + ) + +113 + t__ýu_mask +; + +116 + #__CPUELT +( +ýu +è((ýuè/ +__NCPUBITS +) + + ) + +117 + #__CPUMASK +( +ýu +è(( +__ýu_mask +è1 << ((ýuè% +__NCPUBITS +)) + + ) + +122 +__ýu_mask + +__b™s +[ +__CPU_SETSIZE + / +__NCPUBITS +]; + +123 } + týu_£t_t +; + +126 #ià + `__GNUC_PREREQ + (2, 91) + +127 + #__CPU_ZERO_S +( +£tsize +, +ýu£ +) \ + +128 dØ + `__bužtš_mem£t + ( +ýu£ +, '\0', +£tsize +); 0) + + ) + +130 + #__CPU_ZERO_S +( +£tsize +, +ýu£ +) \ + +132 +size_t + +__i +; \ + +133 +size_t + +__imax + = ( +£tsize +è/ ( +__ýu_mask +); \ + +134 +__ýu_mask + * +__b™s + = ( +ýu£ +)->__bits; \ + +135 +__i + = 0; __˜< +__imax +; ++__i) \ + +136 +__b™s +[ +__i +] = 0; \ + +137 + } +} 0) + + ) + +139 + #__CPU_SET_S +( +ýu +, +£tsize +, +ýu£ +) \ + +140 ( +__ex‹nsiÚ__ + \ + +141 ({ +size_t + +__ýu + = ( +ýu +); \ + +142 +__ýu + < 8 * ( +£tsize +) \ + +143 ? ((( +__ýu_mask + *è(( +ýu£ +)-> +__b™s +))[ + `__CPUELT + ( +__ýu +)] \ + +144 |ð + `__CPUMASK + ( +__ýu +)) \ + +145 : 0; })) + + ) + +146 + #__CPU_CLR_S +( +ýu +, +£tsize +, +ýu£ +) \ + +147 ( +__ex‹nsiÚ__ + \ + +148 ({ +size_t + +__ýu + = ( +ýu +); \ + +149 +__ýu + < 8 * ( +£tsize +) \ + +150 ? ((( +__ýu_mask + *è(( +ýu£ +)-> +__b™s +))[ + `__CPUELT + ( +__ýu +)] \ + +151 &ð~ + `__CPUMASK + ( +__ýu +)) \ + +152 : 0; })) + + ) + +153 + #__CPU_ISSET_S +( +ýu +, +£tsize +, +ýu£ +) \ + +154 ( +__ex‹nsiÚ__ + \ + +155 ({ +size_t + +__ýu + = ( +ýu +); \ + +156 +__ýu + < 8 * ( +£tsize +) \ + +157 ? (((( +__cÚ¡ + +__ýu_mask + *è(( +ýu£ +)-> +__b™s +))[ + `__CPUELT + ( +__ýu +)] \ + +158 & + `__CPUMASK + ( +__ýu +))) != 0 \ + +159 : 0; })) + + ) + +161 + #__CPU_COUNT_S +( +£tsize +, +ýu£ +) \ + +162 + `__sched_ýucouÁ + ( +£tsize +, +ýu£ +) + + ) + +164 #ià +__GNUC_PREREQ + (2, 91) + +165 + #__CPU_EQUAL_S +( +£tsize +, +ýu£1 +, +ýu£2 +) \ + +166 ( + `__bužtš_memcmp + ( +ýu£1 +, +ýu£2 +, +£tsize +è=ð0) + + ) + +168 + #__CPU_EQUAL_S +( +£tsize +, +ýu£1 +, +ýu£2 +) \ + +169 ( +__ex‹nsiÚ__ + \ + +170 ({ +__cÚ¡ + +__ýu_mask + * +__¬r1 + = ( +ýu£1 +)-> +__b™s +; \ + +171 +__cÚ¡ + +__ýu_mask + * +__¬r2 + = ( +ýu£2 +)-> +__b™s +; \ + +172 +size_t + +__imax + = ( +£tsize +è/ ( +__ýu_mask +); \ + +173 +size_t + +__i +; \ + +174 +__i + = 0; __˜< +__imax +; ++__i) \ + +175 ià( +__b™s +[ +__i +] != __bits[__i]) \ + +177 +__i + =ð +__imax +; })) + + ) + +180 + #__CPU_OP_S +( +£tsize +, +de¡£t +, +¤c£t1 +, +¤c£t2 +, +Ý +) \ + +181 ( +__ex‹nsiÚ__ + \ + +182 ({ +ýu_£t_t + * +__de¡ + = ( +de¡£t +); \ + +183 +__cÚ¡ + +__ýu_mask + * +__¬r1 + = ( +¤c£t1 +)-> +__b™s +; \ + +184 +__cÚ¡ + +__ýu_mask + * +__¬r2 + = ( +¤c£t2 +)-> +__b™s +; \ + +185 +size_t + +__imax + = ( +£tsize +è/ ( +__ýu_mask +); \ + +186 +size_t + +__i +; \ + +187 +__i + = 0; __˜< +__imax +; ++__i) \ + +188 (( +__ýu_mask + *è +__de¡ +-> +__b™s +)[ +__i +] = +__¬r1 +[__i] +Ý + +__¬r2 +[__i]; \ + +189 +__de¡ +; })) + + ) + +191 + #__CPU_ALLOC_SIZE +( +couÁ +) \ + +192 (((( +couÁ +è+ +__NCPUBITS + - 1è/ __NCPUBITSè* ( +__ýu_mask +)) + + ) + +193 + #__CPU_ALLOC +( +couÁ +è + `__sched_ýu®loc + (couÁ) + + ) + +194 + #__CPU_FREE +( +ýu£t +è + `__sched_ýuä“ + (ýu£t) + + ) + +196 +__BEGIN_DECLS + + +198
+ $__sched_ýucouÁ + ( +size_t + +__£tsize +, cÚ¡ +ýu_£t_t + * +__£ +) + +199 +__THROW +; + +200
+ýu_£t_t + * + $__sched_ýu®loc + ( +size_t + +__couÁ +è +__THROW + +__wur +; + +201
+ $__sched_ýuä“ + ( +ýu_£t_t + * +__£t +è +__THROW +; + +203 +__END_DECLS + + + @/usr/include/bits/sigaction.h + +20 #iâdeà +_SIGNAL_H + + +25 + ssigaùiÚ + + +28 #ifdeà +__USE_POSIX199309 + + +32 +__sighªdËr_t + + m§_hªdËr +; + +34 (* + m§_sigaùiÚ +è(, + msigšfo_t + *, *); + +36 + m__sigaùiÚ_hªdËr +; + +37 + #§_hªdËr + +__sigaùiÚ_hªdËr +. +§_hªdËr + + + ) + +38 + #§_sigaùiÚ + +__sigaùiÚ_hªdËr +. +§_sigaùiÚ + + + ) + +40 +__sighªdËr_t + + m§_hªdËr +; + +44 +__sig£t_t + + m§_mask +; + +47 + m§_æags +; + +50 (* + m§_»¡Ü” +) ( ); + +54 + #SA_NOCLDSTOP + 1 + + ) + +55 + #SA_NOCLDWAIT + 2 + + ) + +56 + #SA_SIGINFO + 4 + + ) + +58 #ià +defšed + +__USE_UNIX98 + || defšed +__USE_MISC + + +59 + #SA_ONSTACK + 0x08000000 + + ) + +60 + #SA_RESTART + 0x10000000 + + ) + +61 + #SA_NODEFER + 0x40000000 + + ) + +63 + #SA_RESETHAND + 0x80000000 + + ) + +65 #ifdeà +__USE_MISC + + +66 + #SA_INTERRUPT + 0x20000000 + + ) + +69 + #SA_NOMASK + +SA_NODEFER + + + ) + +70 + #SA_ONESHOT + +SA_RESETHAND + + + ) + +71 + #SA_STACK + +SA_ONSTACK + + + ) + +75 + #SIG_BLOCK + 0 + + ) + +76 + #SIG_UNBLOCK + 1 + + ) + +77 + #SIG_SETMASK + 2 + + ) + + @/usr/include/bits/sigcontext.h + +19 #iâdeà +_BITS_SIGCONTEXT_H + + +20 + #_BITS_SIGCONTEXT_H + 1 + + ) + +22 #ià! +defšed + +_SIGNAL_H + && !defšed +_SYS_UCONTEXT_H + + +26 + ~<b™s/wÜdsize.h +> + +28 + s_å»g + + +30 + msignifiÿnd +[4]; + +31 + mexpÚ’t +; + +34 + s_åx»g + + +36 + msignifiÿnd +[4]; + +37 + mexpÚ’t +; + +38 + m·ddšg +[3]; + +41 + s_xmm»g + + +43 +__ušt32_t + + m–em’t +[4]; + +48 #ià +__WORDSIZE + == 32 + +50 + s_å¡©e + + +53 +__ušt32_t + + mcw +; + +54 +__ušt32_t + + msw +; + +55 +__ušt32_t + + mg +; + +56 +__ušt32_t + + moff +; + +57 +__ušt32_t + + mcs£l +; + +58 +__ušt32_t + + md©aoff +; + +59 +__ušt32_t + + md©a£l +; + +60 +_å»g + + m_¡ +[8]; + +61 + m¡©us +; + +62 + mmagic +; + +65 +__ušt32_t + + m_fx¤_’v +[6]; + +66 +__ušt32_t + + mmxc¤ +; + +67 +__ušt32_t + + m»£rved +; + +68 +_åx»g + + m_fx¤_¡ +[8]; + +69 +_xmm»g + + m_xmm +[8]; + +70 +__ušt32_t + + m·ddšg +[56]; + +73 #iâdeà +sigcÚ‹xt_¡ruù + + +78 + #sigcÚ‹xt_¡ruù + +sigcÚ‹xt + + + ) + +81 + ssigcÚ‹xt + + +83 + mgs +, + m__gsh +; + +84 + mfs +, + m__fsh +; + +85 + mes +, + m__esh +; + +86 + mds +, + m__dsh +; + +87 + medi +; + +88 + mesi +; + +89 + mebp +; + +90 + me¥ +; + +91 + mebx +; + +92 + medx +; + +93 + mecx +; + +94 + m—x +; + +95 + mŒno +; + +96 + m”r +; + +97 + me +; + +98 + mcs +, + m__csh +; + +99 + meæags +; + +100 + me¥_©_sigÇl +; + +101 + mss +, + m__ssh +; + +102 +_å¡©e + * + må¡©e +; + +103 + mÞdmask +; + +104 + mü2 +; + +109 + s_å¡©e + + +112 +__ušt16_t + + mcwd +; + +113 +__ušt16_t + + mswd +; + +114 +__ušt16_t + + máw +; + +115 +__ušt16_t + + mfÝ +; + +116 +__ušt64_t + + mr +; + +117 +__ušt64_t + + mrdp +; + +118 +__ušt32_t + + mmxc¤ +; + +119 +__ušt32_t + + mmxü_mask +; + +120 +_åx»g + + m_¡ +[8]; + +121 +_xmm»g + + m_xmm +[16]; + +122 +__ušt32_t + + m·ddšg +[24]; + +125 + ssigcÚ‹xt + + +127 + mr8 +; + +128 + mr9 +; + +129 + mr10 +; + +130 + mr11 +; + +131 + mr12 +; + +132 + mr13 +; + +133 + mr14 +; + +134 + mr15 +; + +135 + mrdi +; + +136 + mrsi +; + +137 + mrbp +; + +138 + mrbx +; + +139 + mrdx +; + +140 + m¿x +; + +141 + mrcx +; + +142 + mr¥ +; + +143 + mr +; + +144 + meæags +; + +145 + mcs +; + +146 + mgs +; + +147 + mfs +; + +148 + m__·d0 +; + +149 + m”r +; + +150 + mŒno +; + +151 + mÞdmask +; + +152 + mü2 +; + +153 +_å¡©e + * + må¡©e +; + +154 + m__»£rved1 + [8]; + + @/usr/include/bits/siginfo.h + +20 #ià! +defšed + +_SIGNAL_H + && !defšed +__Ãed_sigšfo_t + \ + +21 && ! +defšed + + g__Ãed_sigev’t_t + + +25 + ~<b™s/wÜdsize.h +> + +27 #ià(! +defšed + +__have_sigv®_t + \ + +28 && ( +defšed + + g_SIGNAL_H + || defšed + g__Ãed_sigšfo_t + \ + +29 || +defšed + + g__Ãed_sigev’t_t +)) + +30 + #__have_sigv®_t + 1 + + ) + +33 + usigv® + + +35 + msiv®_št +; + +36 * + msiv®_±r +; + +37 } + tsigv®_t +; + +40 #ià(! +defšed + +__have_sigšfo_t + \ + +41 && ( +defšed + + g_SIGNAL_H + || defšed + g__Ãed_sigšfo_t +)) + +42 + #__have_sigšfo_t + 1 + + ) + +44 + #__SI_MAX_SIZE + 128 + + ) + +45 #ià +__WORDSIZE + == 64 + +46 + #__SI_PAD_SIZE + (( +__SI_MAX_SIZE + / ()è- 4) + + ) + +48 + #__SI_PAD_SIZE + (( +__SI_MAX_SIZE + / ()è- 3) + + ) + +51 + ssigšfo + + +53 + msi_signo +; + +54 + msi_”ºo +; + +56 + msi_code +; + +60 + m_·d +[ +__SI_PAD_SIZE +]; + +65 +__pid_t + + msi_pid +; + +66 +__uid_t + + msi_uid +; + +67 } + m_kžl +; + +72 + msi_tid +; + +73 + msi_ov”run +; + +74 +sigv®_t + + msi_sigv® +; + +75 } + m_tim” +; + +80 +__pid_t + + msi_pid +; + +81 +__uid_t + + msi_uid +; + +82 +sigv®_t + + msi_sigv® +; + +83 } + m_¹ +; + +88 +__pid_t + + msi_pid +; + +89 +__uid_t + + msi_uid +; + +90 + msi_¡©us +; + +91 +__þock_t + + msi_utime +; + +92 +__þock_t + + msi_¡ime +; + +93 } + m_sigchld +; + +98 * + msi_addr +; + +99 } + m_sigçuÉ +; + +104 + msi_bªd +; + +105 + msi_fd +; + +106 } + m_sigpÞl +; + +107 } + m_sif›lds +; + +108 } + tsigšfo_t +; + +112 + #si_pid + +_sif›lds +. +_kžl +. +si_pid + + + ) + +113 + #si_uid + +_sif›lds +. +_kžl +. +si_uid + + + ) + +114 + #si_tim”id + +_sif›lds +. +_tim” +. +si_tid + + + ) + +115 + #si_ov”run + +_sif›lds +. +_tim” +. +si_ov”run + + + ) + +116 + #si_¡©us + +_sif›lds +. +_sigchld +. +si_¡©us + + + ) + +117 + #si_utime + +_sif›lds +. +_sigchld +. +si_utime + + + ) + +118 + #si_¡ime + +_sif›lds +. +_sigchld +. +si_¡ime + + + ) + +119 + #si_v®ue + +_sif›lds +. +_¹ +. +si_sigv® + + + ) + +120 + #si_št + +_sif›lds +. +_¹ +. +si_sigv® +. +siv®_št + + + ) + +121 + #si_±r + +_sif›lds +. +_¹ +. +si_sigv® +. +siv®_±r + + + ) + +122 + #si_addr + +_sif›lds +. +_sigçuÉ +. +si_addr + + + ) + +123 + #si_bªd + +_sif›lds +. +_sigpÞl +. +si_bªd + + + ) + +124 + #si_fd + +_sif›lds +. +_sigpÞl +. +si_fd + + + ) + +131 + mSI_ASYNCNL + = -60, + +132 + #SI_ASYNCNL + +SI_ASYNCNL + + + ) + +133 + mSI_TKILL + = -6, + +134 + #SI_TKILL + +SI_TKILL + + + ) + +135 + mSI_SIGIO +, + +136 + #SI_SIGIO + +SI_SIGIO + + + ) + +137 + mSI_ASYNCIO +, + +138 + #SI_ASYNCIO + +SI_ASYNCIO + + + ) + +139 + mSI_MESGQ +, + +140 + #SI_MESGQ + +SI_MESGQ + + + ) + +141 + mSI_TIMER +, + +142 + #SI_TIMER + +SI_TIMER + + + ) + +143 + mSI_QUEUE +, + +144 + #SI_QUEUE + +SI_QUEUE + + + ) + +145 + mSI_USER +, + +146 + #SI_USER + +SI_USER + + + ) + +147 + mSI_KERNEL + = 0x80 + +148 + #SI_KERNEL + +SI_KERNEL + + + ) + +155 + mILL_ILLOPC + = 1, + +156 + #ILL_ILLOPC + +ILL_ILLOPC + + + ) + +157 + mILL_ILLOPN +, + +158 + #ILL_ILLOPN + +ILL_ILLOPN + + + ) + +159 + mILL_ILLADR +, + +160 + #ILL_ILLADR + +ILL_ILLADR + + + ) + +161 + mILL_ILLTRP +, + +162 + #ILL_ILLTRP + +ILL_ILLTRP + + + ) + +163 + mILL_PRVOPC +, + +164 + #ILL_PRVOPC + +ILL_PRVOPC + + + ) + +165 + mILL_PRVREG +, + +166 + #ILL_PRVREG + +ILL_PRVREG + + + ) + +167 + mILL_COPROC +, + +168 + #ILL_COPROC + +ILL_COPROC + + + ) + +169 + mILL_BADSTK + + +170 + #ILL_BADSTK + +ILL_BADSTK + + + ) + +176 + mFPE_INTDIV + = 1, + +177 + #FPE_INTDIV + +FPE_INTDIV + + + ) + +178 + mFPE_INTOVF +, + +179 + #FPE_INTOVF + +FPE_INTOVF + + + ) + +180 + mFPE_FLTDIV +, + +181 + #FPE_FLTDIV + +FPE_FLTDIV + + + ) + +182 + mFPE_FLTOVF +, + +183 + #FPE_FLTOVF + +FPE_FLTOVF + + + ) + +184 + mFPE_FLTUND +, + +185 + #FPE_FLTUND + +FPE_FLTUND + + + ) + +186 + mFPE_FLTRES +, + +187 + #FPE_FLTRES + +FPE_FLTRES + + + ) + +188 + mFPE_FLTINV +, + +189 + #FPE_FLTINV + +FPE_FLTINV + + + ) + +190 + mFPE_FLTSUB + + +191 + #FPE_FLTSUB + +FPE_FLTSUB + + + ) + +197 + mSEGV_MAPERR + = 1, + +198 + #SEGV_MAPERR + +SEGV_MAPERR + + + ) + +199 + mSEGV_ACCERR + + +200 + #SEGV_ACCERR + +SEGV_ACCERR + + + ) + +206 + mBUS_ADRALN + = 1, + +207 + #BUS_ADRALN + +BUS_ADRALN + + + ) + +208 + mBUS_ADRERR +, + +209 + #BUS_ADRERR + +BUS_ADRERR + + + ) + +210 + mBUS_OBJERR + + +211 + #BUS_OBJERR + +BUS_OBJERR + + + ) + +217 + mTRAP_BRKPT + = 1, + +218 + #TRAP_BRKPT + +TRAP_BRKPT + + + ) + +219 + mTRAP_TRACE + + +220 + #TRAP_TRACE + +TRAP_TRACE + + + ) + +226 + mCLD_EXITED + = 1, + +227 + #CLD_EXITED + +CLD_EXITED + + + ) + +228 + mCLD_KILLED +, + +229 + #CLD_KILLED + +CLD_KILLED + + + ) + +230 + mCLD_DUMPED +, + +231 + #CLD_DUMPED + +CLD_DUMPED + + + ) + +232 + mCLD_TRAPPED +, + +233 + #CLD_TRAPPED + +CLD_TRAPPED + + + ) + +234 + mCLD_STOPPED +, + +235 + #CLD_STOPPED + +CLD_STOPPED + + + ) + +236 + mCLD_CONTINUED + + +237 + #CLD_CONTINUED + +CLD_CONTINUED + + + ) + +243 + mPOLL_IN + = 1, + +244 + #POLL_IN + +POLL_IN + + + ) + +245 + mPOLL_OUT +, + +246 + #POLL_OUT + +POLL_OUT + + + ) + +247 + mPOLL_MSG +, + +248 + #POLL_MSG + +POLL_MSG + + + ) + +249 + mPOLL_ERR +, + +250 + #POLL_ERR + +POLL_ERR + + + ) + +251 + mPOLL_PRI +, + +252 + #POLL_PRI + +POLL_PRI + + + ) + +253 + mPOLL_HUP + + +254 + #POLL_HUP + +POLL_HUP + + + ) + +257 #undeà +__Ãed_sigšfo_t + + +261 #ià( +defšed + +_SIGNAL_H + || defšed +__Ãed_sigev’t_t +) \ + +262 && ! +defšed + + g__have_sigev’t_t + + +263 + #__have_sigev’t_t + 1 + + ) + +266 + #__SIGEV_MAX_SIZE + 64 + + ) + +267 #ià +__WORDSIZE + == 64 + +268 + #__SIGEV_PAD_SIZE + (( +__SIGEV_MAX_SIZE + / ()è- 4) + + ) + +270 + #__SIGEV_PAD_SIZE + (( +__SIGEV_MAX_SIZE + / ()è- 3) + + ) + +273 + ssigev’t + + +275 +sigv®_t + + msigev_v®ue +; + +276 + msigev_signo +; + +277 + msigev_nÙify +; + +281 + m_·d +[ +__SIGEV_PAD_SIZE +]; + +285 +__pid_t + + m_tid +; + +289 (* + m_funùiÚ +è( + msigv®_t +); + +290 * + m_©Œibu‹ +; + +291 } + m_sigev_th»ad +; + +292 } + m_sigev_un +; + +293 } + tsigev’t_t +; + +296 + #sigev_nÙify_funùiÚ + +_sigev_un +. +_sigev_th»ad +. +_funùiÚ + + + ) + +297 + #sigev_nÙify_©Œibu‹s + +_sigev_un +. +_sigev_th»ad +. +_©Œibu‹ + + + ) + +302 + mSIGEV_SIGNAL + = 0, + +303 + #SIGEV_SIGNAL + +SIGEV_SIGNAL + + + ) + +304 + mSIGEV_NONE +, + +305 + #SIGEV_NONE + +SIGEV_NONE + + + ) + +306 + mSIGEV_THREAD +, + +307 + #SIGEV_THREAD + +SIGEV_THREAD + + + ) + +309 + mSIGEV_THREAD_ID + = 4 + +310 + #SIGEV_THREAD_ID + +SIGEV_THREAD_ID + + + ) + + @/usr/include/bits/signum.h + +20 #ifdef +_SIGNAL_H + + +23 + #SIG_ERR + (( +__sighªdËr_t +è-1è + + ) + +24 + #SIG_DFL + (( +__sighªdËr_t +è0è + + ) + +25 + #SIG_IGN + (( +__sighªdËr_t +è1è + + ) + +27 #ifdeà +__USE_UNIX98 + + +28 + #SIG_HOLD + (( +__sighªdËr_t +è2è + + ) + +33 + #SIGHUP + 1 + + ) + +34 + #SIGINT + 2 + + ) + +35 + #SIGQUIT + 3 + + ) + +36 + #SIGILL + 4 + + ) + +37 + #SIGTRAP + 5 + + ) + +38 + #SIGABRT + 6 + + ) + +39 + #SIGIOT + 6 + + ) + +40 + #SIGBUS + 7 + + ) + +41 + #SIGFPE + 8 + + ) + +42 + #SIGKILL + 9 + + ) + +43 + #SIGUSR1 + 10 + + ) + +44 + #SIGSEGV + 11 + + ) + +45 + #SIGUSR2 + 12 + + ) + +46 + #SIGPIPE + 13 + + ) + +47 + #SIGALRM + 14 + + ) + +48 + #SIGTERM + 15 + + ) + +49 + #SIGSTKFLT + 16 + + ) + +50 + #SIGCLD + +SIGCHLD + + + ) + +51 + #SIGCHLD + 17 + + ) + +52 + #SIGCONT + 18 + + ) + +53 + #SIGSTOP + 19 + + ) + +54 + #SIGTSTP + 20 + + ) + +55 + #SIGTTIN + 21 + + ) + +56 + #SIGTTOU + 22 + + ) + +57 + #SIGURG + 23 + + ) + +58 + #SIGXCPU + 24 + + ) + +59 + #SIGXFSZ + 25 + + ) + +60 + #SIGVTALRM + 26 + + ) + +61 + #SIGPROF + 27 + + ) + +62 + #SIGWINCH + 28 + + ) + +63 + #SIGPOLL + +SIGIO + + + ) + +64 + #SIGIO + 29 + + ) + +65 + #SIGPWR + 30 + + ) + +66 + #SIGSYS + 31 + + ) + +67 + #SIGUNUSED + 31 + + ) + +69 + #_NSIG + 65 + + ) + +72 + #SIGRTMIN + ( + `__libc_cu¼’t_sig¹mš + ()) + + ) + +73 + #SIGRTMAX + ( + `__libc_cu¼’t_sig¹max + ()) + + ) + +77 + #__SIGRTMIN + 32 + + ) + +78 + #__SIGRTMAX + ( +_NSIG + - 1) + + ) + + @/usr/include/bits/sigstack.h + +20 #iâdeà +_SIGNAL_H + + +26 + ssig¡ack + + +28 * + mss_¥ +; + +29 + mss_Ú¡ack +; + +36 + mSS_ONSTACK + = 1, + +37 + #SS_ONSTACK + +SS_ONSTACK + + + ) + +38 + mSS_DISABLE + + +39 + #SS_DISABLE + +SS_DISABLE + + + ) + +43 + #MINSIGSTKSZ + 2048 + + ) + +46 + #SIGSTKSZ + 8192 + + ) + +50 + ssig®t¡ack + + +52 * + mss_¥ +; + +53 + mss_æags +; + +54 +size_t + + mss_size +; + +55 } + t¡ack_t +; + + @/usr/include/bits/sigthread.h + +20 #iâdeà +_BITS_SIGTHREAD_H + + +21 + #_BITS_SIGTHREAD_H + 1 + + ) + +23 #ià! +defšed + +_SIGNAL_H + && !defšed +_PTHREAD_H + + +31
+ $±h»ad_sigmask + ( +__how +, + +32 +__cÚ¡ + +__sig£t_t + * +__»¡riù + +__Ãwmask +, + +33 +__sig£t_t + * +__»¡riù + +__Þdmask +) +__THROW +; + +36
+ $±h»ad_kžl + ( +±h»ad_t + +__th»adid +, +__signo +è +__THROW +; + +38 #ifdeà +__USE_GNU + + +40
+ $±h»ad_sigqueue + ( +±h»ad_t + +__th»adid +, +__signo +, + +41 cÚ¡ +sigv® + +__v®ue +è +__THROW +; + + @/usr/include/linux/errno.h + +1 #iâdeà +_LINUX_ERRNO_H + + +2 + #_LINUX_ERRNO_H + + + ) + +4 + ~<asm/”ºo.h +> + + @/usr/include/sys/ucontext.h + +19 #iâdeà +_SYS_UCONTEXT_H + + +20 + #_SYS_UCONTEXT_H + 1 + + ) + +22 + ~<ã©u»s.h +> + +23 + ~<sigÇl.h +> + +24 + ~<b™s/wÜdsize.h +> + +28 + ~<b™s/sigcÚ‹xt.h +> + +30 #ià +__WORDSIZE + == 64 + +33 + tg»g_t +; + +36 + #NGREG + 23 + + ) + +39 +g»g_t + + tg»g£t_t +[ +NGREG +]; + +41 #ifdeà +__USE_GNU + + +45 + mREG_R8 + = 0, + +46 + #REG_R8 + +REG_R8 + + + ) + +47 + mREG_R9 +, + +48 + #REG_R9 + +REG_R9 + + + ) + +49 + mREG_R10 +, + +50 + #REG_R10 + +REG_R10 + + + ) + +51 + mREG_R11 +, + +52 + #REG_R11 + +REG_R11 + + + ) + +53 + mREG_R12 +, + +54 + #REG_R12 + +REG_R12 + + + ) + +55 + mREG_R13 +, + +56 + #REG_R13 + +REG_R13 + + + ) + +57 + mREG_R14 +, + +58 + #REG_R14 + +REG_R14 + + + ) + +59 + mREG_R15 +, + +60 + #REG_R15 + +REG_R15 + + + ) + +61 + mREG_RDI +, + +62 + #REG_RDI + +REG_RDI + + + ) + +63 + mREG_RSI +, + +64 + #REG_RSI + +REG_RSI + + + ) + +65 + mREG_RBP +, + +66 + #REG_RBP + +REG_RBP + + + ) + +67 + mREG_RBX +, + +68 + #REG_RBX + +REG_RBX + + + ) + +69 + mREG_RDX +, + +70 + #REG_RDX + +REG_RDX + + + ) + +71 + mREG_RAX +, + +72 + #REG_RAX + +REG_RAX + + + ) + +73 + mREG_RCX +, + +74 + #REG_RCX + +REG_RCX + + + ) + +75 + mREG_RSP +, + +76 + #REG_RSP + +REG_RSP + + + ) + +77 + mREG_RIP +, + +78 + #REG_RIP + +REG_RIP + + + ) + +79 + mREG_EFL +, + +80 + #REG_EFL + +REG_EFL + + + ) + +81 + mREG_CSGSFS +, + +82 + #REG_CSGSFS + +REG_CSGSFS + + + ) + +83 + mREG_ERR +, + +84 + #REG_ERR + +REG_ERR + + + ) + +85 + mREG_TRAPNO +, + +86 + #REG_TRAPNO + +REG_TRAPNO + + + ) + +87 + mREG_OLDMASK +, + +88 + #REG_OLDMASK + +REG_OLDMASK + + + ) + +89 + mREG_CR2 + + +90 + #REG_CR2 + +REG_CR2 + + + ) + +94 + s_libc_åx»g + + +96 + msignifiÿnd +[4]; + +97 + mexpÚ’t +; + +98 + m·ddšg +[3]; + +101 + s_libc_xmm»g + + +103 +__ušt32_t + + m–em’t +[4]; + +106 + s_libc_å¡©e + + +109 +__ušt16_t + + mcwd +; + +110 +__ušt16_t + + mswd +; + +111 +__ušt16_t + + máw +; + +112 +__ušt16_t + + mfÝ +; + +113 +__ušt64_t + + mr +; + +114 +__ušt64_t + + mrdp +; + +115 +__ušt32_t + + mmxc¤ +; + +116 +__ušt32_t + + mmxü_mask +; + +117 +_libc_åx»g + + m_¡ +[8]; + +118 +_libc_xmm»g + + m_xmm +[16]; + +119 +__ušt32_t + + m·ddšg +[24]; + +123 +_libc_å¡©e + * + tå»g£t_t +; + +128 +g»g£t_t + + mg»gs +; + +130 +å»g£t_t + + må»gs +; + +131 + m__»£rved1 + [8]; + +132 } + tmcÚ‹xt_t +; + +135 + sucÚ‹xt + + +137 + muc_æags +; + +138 +ucÚ‹xt + * + muc_lšk +; + +139 +¡ack_t + + muc_¡ack +; + +140 +mcÚ‹xt_t + + muc_mcÚ‹xt +; + +141 +__sig£t_t + + muc_sigmask +; + +142 +_libc_å¡©e + + m__å»gs_mem +; + +143 } + tucÚ‹xt_t +; + +148 + tg»g_t +; + +151 + #NGREG + 19 + + ) + +154 +g»g_t + + tg»g£t_t +[ +NGREG +]; + +156 #ifdeà +__USE_GNU + + +160 + mREG_GS + = 0, + +161 + #REG_GS + +REG_GS + + + ) + +162 + mREG_FS +, + +163 + #REG_FS + +REG_FS + + + ) + +164 + mREG_ES +, + +165 + #REG_ES + +REG_ES + + + ) + +166 + mREG_DS +, + +167 + #REG_DS + +REG_DS + + + ) + +168 + mREG_EDI +, + +169 + #REG_EDI + +REG_EDI + + + ) + +170 + mREG_ESI +, + +171 + #REG_ESI + +REG_ESI + + + ) + +172 + mREG_EBP +, + +173 + #REG_EBP + +REG_EBP + + + ) + +174 + mREG_ESP +, + +175 + #REG_ESP + +REG_ESP + + + ) + +176 + mREG_EBX +, + +177 + #REG_EBX + +REG_EBX + + + ) + +178 + mREG_EDX +, + +179 + #REG_EDX + +REG_EDX + + + ) + +180 + mREG_ECX +, + +181 + #REG_ECX + +REG_ECX + + + ) + +182 + mREG_EAX +, + +183 + #REG_EAX + +REG_EAX + + + ) + +184 + mREG_TRAPNO +, + +185 + #REG_TRAPNO + +REG_TRAPNO + + + ) + +186 + mREG_ERR +, + +187 + #REG_ERR + +REG_ERR + + + ) + +188 + mREG_EIP +, + +189 + #REG_EIP + +REG_EIP + + + ) + +190 + mREG_CS +, + +191 + #REG_CS + +REG_CS + + + ) + +192 + mREG_EFL +, + +193 + #REG_EFL + +REG_EFL + + + ) + +194 + mREG_UESP +, + +195 + #REG_UESP + +REG_UESP + + + ) + +196 + mREG_SS + + +197 + #REG_SS + +REG_SS + + + ) + +202 + s_libc_å»g + + +204 + msignifiÿnd +[4]; + +205 + mexpÚ’t +; + +208 + s_libc_å¡©e + + +210 + mcw +; + +211 + msw +; + +212 + mg +; + +213 + moff +; + +214 + mcs£l +; + +215 + md©aoff +; + +216 + md©a£l +; + +217 +_libc_å»g + + m_¡ +[8]; + +218 + m¡©us +; + +222 +_libc_å¡©e + * + tå»g£t_t +; + +227 +g»g£t_t + + mg»gs +; + +230 +å»g£t_t + + må»gs +; + +231 + mÞdmask +; + +232 + mü2 +; + +233 } + tmcÚ‹xt_t +; + +236 + sucÚ‹xt + + +238 + muc_æags +; + +239 +ucÚ‹xt + * + muc_lšk +; + +240 +¡ack_t + + muc_¡ack +; + +241 +mcÚ‹xt_t + + muc_mcÚ‹xt +; + +242 +__sig£t_t + + muc_sigmask +; + +243 +_libc_å¡©e + + m__å»gs_mem +; + +244 } + tucÚ‹xt_t +; + + @/usr/include/asm/errno.h + +1 + ~<asm-g’”ic/”ºo.h +> + + @/usr/include/asm-generic/errno.h + +1 #iâdeà +_ASM_GENERIC_ERRNO_H + + +2 + #_ASM_GENERIC_ERRNO_H + + + ) + +4 + ~<asm-g’”ic/”ºo-ba£.h +> + +6 + #EDEADLK + 35 + + ) + +7 + #ENAMETOOLONG + 36 + + ) + +8 + #ENOLCK + 37 + + ) + +9 + #ENOSYS + 38 + + ) + +10 + #ENOTEMPTY + 39 + + ) + +11 + #ELOOP + 40 + + ) + +12 + #EWOULDBLOCK + +EAGAIN + + + ) + +13 + #ENOMSG + 42 + + ) + +14 + #EIDRM + 43 + + ) + +15 + #ECHRNG + 44 + + ) + +16 + #EL2NSYNC + 45 + + ) + +17 + #EL3HLT + 46 + + ) + +18 + #EL3RST + 47 + + ) + +19 + #ELNRNG + 48 + + ) + +20 + #EUNATCH + 49 + + ) + +21 + #ENOCSI + 50 + + ) + +22 + #EL2HLT + 51 + + ) + +23 + #EBADE + 52 + + ) + +24 + #EBADR + 53 + + ) + +25 + #EXFULL + 54 + + ) + +26 + #ENOANO + 55 + + ) + +27 + #EBADRQC + 56 + + ) + +28 + #EBADSLT + 57 + + ) + +30 + #EDEADLOCK + +EDEADLK + + + ) + +32 + #EBFONT + 59 + + ) + +33 + #ENOSTR + 60 + + ) + +34 + #ENODATA + 61 + + ) + +35 + #ETIME + 62 + + ) + +36 + #ENOSR + 63 + + ) + +37 + #ENONET + 64 + + ) + +38 + #ENOPKG + 65 + + ) + +39 + #EREMOTE + 66 + + ) + +40 + #ENOLINK + 67 + + ) + +41 + #EADV + 68 + + ) + +42 + #ESRMNT + 69 + + ) + +43 + #ECOMM + 70 + + ) + +44 + #EPROTO + 71 + + ) + +45 + #EMULTIHOP + 72 + + ) + +46 + #EDOTDOT + 73 + + ) + +47 + #EBADMSG + 74 + + ) + +48 + #EOVERFLOW + 75 + + ) + +49 + #ENOTUNIQ + 76 + + ) + +50 + #EBADFD + 77 + + ) + +51 + #EREMCHG + 78 + + ) + +52 + #ELIBACC + 79 + + ) + +53 + #ELIBBAD + 80 + + ) + +54 + #ELIBSCN + 81 + + ) + +55 + #ELIBMAX + 82 + + ) + +56 + #ELIBEXEC + 83 + + ) + +57 + #EILSEQ + 84 + + ) + +58 + #ERESTART + 85 + + ) + +59 + #ESTRPIPE + 86 + + ) + +60 + #EUSERS + 87 + + ) + +61 + #ENOTSOCK + 88 + + ) + +62 + #EDESTADDRREQ + 89 + + ) + +63 + #EMSGSIZE + 90 + + ) + +64 + #EPROTOTYPE + 91 + + ) + +65 + #ENOPROTOOPT + 92 + + ) + +66 + #EPROTONOSUPPORT + 93 + + ) + +67 + #ESOCKTNOSUPPORT + 94 + + ) + +68 + #EOPNOTSUPP + 95 + + ) + +69 + #EPFNOSUPPORT + 96 + + ) + +70 + #EAFNOSUPPORT + 97 + + ) + +71 + #EADDRINUSE + 98 + + ) + +72 + #EADDRNOTAVAIL + 99 + + ) + +73 + #ENETDOWN + 100 + + ) + +74 + #ENETUNREACH + 101 + + ) + +75 + #ENETRESET + 102 + + ) + +76 + #ECONNABORTED + 103 + + ) + +77 + #ECONNRESET + 104 + + ) + +78 + #ENOBUFS + 105 + + ) + +79 + #EISCONN + 106 + + ) + +80 + #ENOTCONN + 107 + + ) + +81 + #ESHUTDOWN + 108 + + ) + +82 + #ETOOMANYREFS + 109 + + ) + +83 + #ETIMEDOUT + 110 + + ) + +84 + #ECONNREFUSED + 111 + + ) + +85 + #EHOSTDOWN + 112 + + ) + +86 + #EHOSTUNREACH + 113 + + ) + +87 + #EALREADY + 114 + + ) + +88 + #EINPROGRESS + 115 + + ) + +89 + #ESTALE + 116 + + ) + +90 + #EUCLEAN + 117 + + ) + +91 + #ENOTNAM + 118 + + ) + +92 + #ENAVAIL + 119 + + ) + +93 + #EISNAM + 120 + + ) + +94 + #EREMOTEIO + 121 + + ) + +95 + #EDQUOT + 122 + + ) + +97 + #ENOMEDIUM + 123 + + ) + +98 + #EMEDIUMTYPE + 124 + + ) + +99 + #ECANCELED + 125 + + ) + +100 + #ENOKEY + 126 + + ) + +101 + #EKEYEXPIRED + 127 + + ) + +102 + #EKEYREVOKED + 128 + + ) + +103 + #EKEYREJECTED + 129 + + ) + +106 + #EOWNERDEAD + 130 + + ) + +107 + #ENOTRECOVERABLE + 131 + + ) + +109 + #ERFKILL + 132 + + ) + + @/usr/include/asm-generic/errno-base.h + +1 #iâdeà +_ASM_GENERIC_ERRNO_BASE_H + + +2 + #_ASM_GENERIC_ERRNO_BASE_H + + + ) + +4 + #EPERM + 1 + + ) + +5 + #ENOENT + 2 + + ) + +6 + #ESRCH + 3 + + ) + +7 + #EINTR + 4 + + ) + +8 + #EIO + 5 + + ) + +9 + #ENXIO + 6 + + ) + +10 + #E2BIG + 7 + + ) + +11 + #ENOEXEC + 8 + + ) + +12 + #EBADF + 9 + + ) + +13 + #ECHILD + 10 + + ) + +14 + #EAGAIN + 11 + + ) + +15 + #ENOMEM + 12 + + ) + +16 + #EACCES + 13 + + ) + +17 + #EFAULT + 14 + + ) + +18 + #ENOTBLK + 15 + + ) + +19 + #EBUSY + 16 + + ) + +20 + #EEXIST + 17 + + ) + +21 + #EXDEV + 18 + + ) + +22 + #ENODEV + 19 + + ) + +23 + #ENOTDIR + 20 + + ) + +24 + #EISDIR + 21 + + ) + +25 + #EINVAL + 22 + + ) + +26 + #ENFILE + 23 + + ) + +27 + #EMFILE + 24 + + ) + +28 + #ENOTTY + 25 + + ) + +29 + #ETXTBSY + 26 + + ) + +30 + #EFBIG + 27 + + ) + +31 + #ENOSPC + 28 + + ) + +32 + #ESPIPE + 29 + + ) + +33 + #EROFS + 30 + + ) + +34 + #EMLINK + 31 + + ) + +35 + #EPIPE + 32 + + ) + +36 + #EDOM + 33 + + ) + +37 + #ERANGE + 34 + + ) + + @ +1 +. +1 +/usr/include +87 +2228 +CG.cc +CG_roseBuilder.cc +CG_roseRepr.cc +CG_stringBuilder.cc +CG_stringRepr.cc +CG_suifBuilder.cc +CG_suifRepr.cc +code_gen.cc +output_repr.cc +/usr/include/math.h +/usr/include/stdio.h +/usr/include/string.h +/usr/include/bits/huge_val.h +/usr/include/bits/huge_valf.h +/usr/include/bits/huge_vall.h +/usr/include/bits/inf.h +/usr/include/bits/mathcalls.h +/usr/include/bits/mathdef.h +/usr/include/bits/mathinline.h +/usr/include/bits/nan.h +/usr/include/bits/stdio-ldbl.h +/usr/include/bits/stdio.h +/usr/include/bits/stdio2.h +/usr/include/bits/stdio_lim.h +/usr/include/bits/string.h +/usr/include/bits/string2.h +/usr/include/bits/string3.h +/usr/include/bits/sys_errlist.h +/usr/include/bits/types.h +/usr/include/features.h +/usr/include/getopt.h +/usr/include/libio.h +/usr/include/xlocale.h +/usr/include/_G_config.h +/usr/include/bits/libio-ldbl.h +/usr/include/bits/predefs.h +/usr/include/bits/stdio-lock.h +/usr/include/bits/typesizes.h +/usr/include/bits/wordsize.h +/usr/include/ctype.h +/usr/include/endian.h +/usr/include/gnu/stubs.h +/usr/include/stdlib.h +/usr/include/sys/cdefs.h +/usr/include/alloca.h +/usr/include/bits/byteswap.h +/usr/include/bits/endian.h +/usr/include/bits/libc-lock.h +/usr/include/bits/stdlib-ldbl.h +/usr/include/bits/stdlib.h +/usr/include/bits/waitflags.h +/usr/include/bits/waitstatus.h +/usr/include/gconv.h +/usr/include/gnu/stubs-32.h +/usr/include/gnu/stubs-64.h +/usr/include/sys/types.h +/usr/include/wchar.h +/usr/include/bits/pthreadtypes.h +/usr/include/bits/wchar-ldbl.h +/usr/include/bits/wchar.h +/usr/include/bits/wchar2.h +/usr/include/errno.h +/usr/include/gnu/option-groups.h +/usr/include/pthread.h +/usr/include/sys/select.h +/usr/include/sys/sysmacros.h +/usr/include/time.h +/usr/include/wctype.h +/usr/include/bits/errno.h +/usr/include/bits/select.h +/usr/include/bits/setjmp.h +/usr/include/bits/sigset.h +/usr/include/bits/time.h +/usr/include/sched.h +/usr/include/signal.h +/usr/include/bits/sched.h +/usr/include/bits/sigaction.h +/usr/include/bits/sigcontext.h +/usr/include/bits/siginfo.h +/usr/include/bits/signum.h +/usr/include/bits/sigstack.h +/usr/include/bits/sigthread.h +/usr/include/linux/errno.h +/usr/include/sys/ucontext.h +/usr/include/asm/errno.h +/usr/include/asm-generic/errno.h +/usr/include/asm-generic/errno-base.h diff --git a/omegalib/code_gen/src/output_repr.cc b/omegalib/code_gen/src/output_repr.cc new file mode 100644 index 0000000..955cc14 --- /dev/null +++ b/omegalib/code_gen/src/output_repr.cc @@ -0,0 +1,1931 @@ +/***************************************************************************** + Copyright (C) 1994-2000 University of Maryland + Copyright (C) 2008 University of Southern California + Copyright (C) 2009-2010 University of Utah + All Rights Reserved. + + Purpose: + utility functions for outputing CG_outputReprs + + Notes: + + History: + 07/30/10 collect various code outputing into one place, by Chun Chen +*****************************************************************************/ + +#include <omega.h> +#include <code_gen/CG_stringBuilder.h> +#include <code_gen/output_repr.h> +#include <basic/omega_error.h> +#include <math.h> +#include <stack> +#include <typeinfo> + +namespace omega { + +extern Tuple<Tuple<Relation> > projected_nIS; +int var_substitution_threshold = 100; +//protonu. +extern int upperBoundForLevel; +extern int lowerBoundForLevel; +extern bool fillInBounds; +//end--protonu. + +} + + +namespace omega { + +std::pair<EQ_Handle, int> find_simplest_assignment(const Relation &R_, Variable_ID v, const std::vector<CG_outputRepr *> &assigned_on_the_fly); + + +namespace { + + + + +void get_stride(const Constraint_Handle &h, Variable_ID &wc, coef_t &step){ + wc = 0; + for(Constr_Vars_Iter i(h,true); i; i++) { + assert(wc == 0); + wc = (*i).var; + step = ((*i).coef); + } +} + +} + +CG_outputRepr* outputIdent(CG_outputBuilder* ocg, const Relation &R_, Variable_ID v, const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + Relation &R = const_cast<Relation &>(R_); + + switch (v->kind()) { + case Set_Var: { + int pos = v->get_position(); + if (assigned_on_the_fly[pos-1] != NULL) + return assigned_on_the_fly[pos-1]->clone(); + else + return ocg->CreateIdent(v->name()); + break; + } + case Global_Var: { + if (v->get_global_var()->arity() == 0) + return ocg->CreateIdent(v->name()); + else { + /* This should be improved to take into account the possible elimination + of the set variables. */ + int arity = v->get_global_var()->arity(); + //assert(arity <= last_level); + Tuple<CG_outputRepr *> argList; + // Relation R = Relation::True(arity); + + // name_codegen_vars(R); // easy way to make sure the names are correct. + for(int i = 1; i <= arity; i++) + argList.append(ocg->CreateIdent(R.set_var(i)->name())); + CG_outputRepr *call = ocg->CreateInvoke(v->get_global_var()->base_name(), argList); + return call; + } + break; + } + default: + throw std::invalid_argument("wrong variable type"); + } +} + + +//---------------------------------------------------------------------------- +// Translate equality constraints to if-condition and assignment. +// return.first is right-hand-side of assignment, return.second +// is true if assignment is required. +// -- by chun 07/29/2010 +// ---------------------------------------------------------------------------- +std::pair<CG_outputRepr *, bool> outputAssignment(CG_outputBuilder *ocg, const Relation &R_, Variable_ID v, Relation &enforced, CG_outputRepr *&if_repr, const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + Relation &R = const_cast<Relation &>(R_); + + Conjunct *c = R.query_DNF()->single_conjunct(); + + // check whether to generate if-conditions from equality constraints + for (EQ_Iterator ei(c); ei; ei++) + if (!(*ei).has_wildcards() && abs((*ei).get_coef(v)) > 1) { + Relation r(R.n_set()); + F_And *f_super_root = r.add_and(); + F_Exists *fe = f_super_root->add_exists(); + Variable_ID e = fe->declare(); + F_And *f_root = fe->add_and(); + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(*ei); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + if ((*cvi).var == v) + h.update_coef(e, (*cvi).coef); + else + h.update_coef(r.set_var((*cvi).var->get_position()), (*cvi).coef); + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r.get_local(g); + else + v2 = r.get_local(g, (*cvi).var->function_of()); + h.update_coef(v2, (*cvi).coef); + break; + } + default: + assert(0); + } + h.update_const((*ei).get_const()); + + r.copy_names(R); + r.setup_names(); + + // need if-condition to make sure this loop variable has integer value + if (!Gist(r, copy(enforced), 1).is_obvious_tautology()) { + coef_t coef = (*ei).get_coef(v); + coef_t sign = -((coef>0)?1:-1); + coef = abs(coef); + + CG_outputRepr *term = NULL; + for (Constr_Vars_Iter cvi(*ei); cvi; cvi++) + if ((*cvi).var != v) { + CG_outputRepr *varRepr = outputIdent(ocg, R, (*cvi).var, assigned_on_the_fly); + coef_t t = sign*(*cvi).coef; + if (t == 1) + term = ocg->CreatePlus(term, varRepr); + else if (t == -1) + term = ocg->CreateMinus(term, varRepr); + else if (t > 0) + term = ocg->CreatePlus(term, ocg->CreateTimes(ocg->CreateInt(t), varRepr)); + else if (t < 0) + term = ocg->CreateMinus(term, ocg->CreateTimes(ocg->CreateInt(-t), varRepr)); + } + coef_t t = sign*(*ei).get_const(); + if (t > 0) + term = ocg->CreatePlus(term, ocg->CreateInt(t)); + else if (t < 0) + term = ocg->CreateMinus(term, ocg->CreateInt(-t)); + + term = ocg->CreateIntegerMod(term, ocg->CreateInt(coef)); + term = ocg->CreateEQ(term, ocg->CreateInt(0)); + + if_repr = ocg->CreateAnd(if_repr, term); + } + + enforced.and_with_EQ(*ei); + enforced.simplify(); + } + + // find the simplest assignment + std::pair<EQ_Handle, int> a = find_simplest_assignment(R, v, assigned_on_the_fly); + + // now generate assignment + if (a.second < INT_MAX) { + EQ_Handle eq = a.first; + CG_outputRepr *rop_repr = NULL; + + coef_t divider = eq.get_coef(v); + int sign = 1; + if (divider < 0) { + divider = -divider; + sign = -1; + } + + for (Constr_Vars_Iter cvi(eq); cvi; cvi++) + if ((*cvi).var != v) { + CG_outputRepr *var_repr = outputIdent(ocg, R, (*cvi).var, assigned_on_the_fly); + coef_t coef = (*cvi).coef; + if (-sign * coef == -1) + rop_repr = ocg->CreateMinus(rop_repr, var_repr); + else if (-sign * coef < -1) + rop_repr = ocg->CreateMinus(rop_repr, ocg->CreateTimes(ocg->CreateInt(sign * coef), var_repr)); + else if (-sign * coef == 1) + rop_repr = ocg->CreatePlus(rop_repr, var_repr); + else // -sign * coef > 1 + rop_repr = ocg->CreatePlus(rop_repr, ocg->CreateTimes(ocg->CreateInt(-sign * coef), var_repr)); + } + + coef_t c_term = -(eq.get_const() * sign); + + if (c_term > 0) + rop_repr = ocg->CreatePlus(rop_repr, ocg->CreateInt(c_term)); + else if (c_term < 0) + rop_repr = ocg->CreateMinus(rop_repr, ocg->CreateInt(-c_term)); + else if (rop_repr == NULL) + rop_repr = ocg->CreateInt(0); + + if (divider != 1) + rop_repr = ocg->CreateIntegerDivide(rop_repr, ocg->CreateInt(divider)); + + enforced.and_with_EQ(eq); + enforced.simplify(); + + if (a.second > var_substitution_threshold) + return std::make_pair(rop_repr, true); + else + return std::make_pair(rop_repr, false); + } + else + return std::make_pair(static_cast<CG_outputRepr *>(NULL), false); +} + + +//---------------------------------------------------------------------------- +// Don't use Substitutions class since it can't handle integer +// division. Instead, use relation mapping to a single output +// variable to get substitution. -- by chun, 07/19/2007 +//---------------------------------------------------------------------------- +Tuple<CG_outputRepr*> outputSubstitution(CG_outputBuilder* ocg, const Relation &R_, const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + Relation &R = const_cast<Relation &>(R_); + + const int n = R.n_out(); + Tuple<CG_outputRepr*> oReprList; + + // Find substitution for each output variable + for (int i = 1; i <= n; i++) { + Relation mapping(n, 1); + F_And *f_root = mapping.add_and(); + EQ_Handle h = f_root->add_EQ(); + h.update_coef(mapping.output_var(1), 1); + h.update_coef(mapping.input_var(i), -1); + + Relation S = Composition(mapping, copy(R)); + + std::pair<EQ_Handle, int> a = find_simplest_assignment(S, S.output_var(1), assigned_on_the_fly); + + if (a.second < INT_MAX) { + while (a.second > 0) { + EQ_Handle eq = a.first; + std::set<int> candidates; + for (Constr_Vars_Iter cvi(eq); cvi; cvi++) + if ((*cvi).var->kind() == Input_Var) + candidates.insert((*cvi).var->get_position()); + + bool changed = false; + for (std::set<int>::iterator j = candidates.begin(); j != candidates.end(); j++) { + Relation S2 = Project(copy(S), *j, Input_Var); + std::pair<EQ_Handle, int> a2 = find_simplest_assignment(S2, S2.output_var(1), assigned_on_the_fly); + if (a2.second <= a.second) { + S = S2; + a = a2; + changed = true; + break; + } + } + if (!changed) + break; + } + } + + if (a.second < INT_MAX) { + CG_outputRepr *repr = NULL; + EQ_Handle eq = a.first; + Variable_ID v = S.output_var(1); + + for (int j = 1; j <= S.n_inp(); j++) + S.name_input_var(j, R.input_var(j)->name()); + S.setup_names(); + + int d = eq.get_coef(v); + assert(d != 0); + int sign = (d>0)?-1:1; + d = -sign * d; + for (Constr_Vars_Iter cvi(eq); cvi; cvi++) + if ((*cvi).var != v) { + int coef = sign * (*cvi).coef; + CG_outputRepr *op = outputIdent(ocg, S, (*cvi).var, assigned_on_the_fly); + if (coef > 1) + op = ocg->CreateTimes(ocg->CreateInt(coef), op); + else if (coef < -1) + op = ocg->CreateTimes(ocg->CreateInt(-coef), op); + if (coef > 0) + repr = ocg->CreatePlus(repr, op); + else if (coef < 0) + repr = ocg->CreateMinus(repr, op); + } + + int c = sign * eq.get_const(); + if (c > 0) + repr = ocg->CreatePlus(repr, ocg->CreateInt(c)); + else if (c < 0) + repr = ocg->CreateMinus(repr, ocg->CreateInt(-c)); + else if (repr == NULL) + repr = ocg->CreateInt(0); + + if (d != 1) + repr = ocg->CreateIntegerDivide(repr, ocg->CreateInt(d)); + + oReprList.append(repr); + } + else + oReprList.append(NULL); + } + + return oReprList; +} + +namespace { + +Relation create_stride_on_bound(int n, const std::map<Variable_ID, coef_t> &lb, coef_t stride) { + Relation result(n); + F_And *f_root = result.add_and(); + EQ_Handle h = f_root->add_stride(stride); + + for (std::map<Variable_ID, coef_t>::const_iterator i = lb.begin(); i != lb.end(); i++) { + if (i->first == NULL) + h.update_const(i->second); + else { + switch(i->first->kind()) { + case Input_Var: { + int pos = i->first->get_position(); + h.update_coef(result.set_var(pos), i->second); + break; + } + case Global_Var: { + Global_Var_ID g = i->first->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = result.get_local(g); + else + v = result.get_local(g, i->first->function_of()); + h.update_coef(v, i->second); + break; + } + default: + assert(0); + } + } + } + + return result; +} + +} + +//---------------------------------------------------------------------------- +// Find the most restrictive common stride constraint for a set of +// relations. -- by chun, 05/20/09 +// ---------------------------------------------------------------------------- +Relation greatest_common_step(const Tuple<Relation> &I, const Tuple<int> &active, int level, const Relation &known) { + assert(I.size() == active.size()); + int n = 0; + + std::vector<Relation> I1, I2; + for (int i = 1; i <= I.size(); i++) + if (active[i]) { + if (n == 0) + n = I[i].n_set(); + + Relation r1; + if (known.is_null()) + r1 = copy(I[i]); + else { + r1 = Intersection(copy(I[i]), copy(known)); + r1.simplify(); + } + I1.push_back(r1); + Relation r2 = Gist(copy(I[i]), copy(known)); + assert(r2.is_upper_bound_satisfiable()); + if (r2.is_obvious_tautology()) + return Relation::True(n); + I2.push_back(r2); + } + + std::vector<bool> is_exact(I2.size(), true); + std::vector<coef_t> step(I2.size(), 0); + std::vector<coef_t> messy_step(I2.size(), 0); + Variable_ID t_col = set_var(level); + std::map<Variable_ID, coef_t> lb; + + // first check all clean strides: t_col = ... (mod step) + for (size_t i = 0; i < I2.size(); i++) { + Conjunct *c = I2[i].query_DNF()->single_conjunct(); + + bool is_degenerated = false; + for (EQ_Iterator e = c->EQs(); e; e++) { + coef_t coef = abs((*e).get_coef(t_col)); + if (coef != 0 && !(*e).has_wildcards()) { + is_degenerated = true; + break; + } + } + if (is_degenerated) + continue; + + for (EQ_Iterator e = c->EQs(); e; e++) { + if ((*e).has_wildcards()) { + coef_t coef = abs((*e).get_coef(t_col)); + if (coef == 0) + continue; + if (coef != 1) { + is_exact[i] = false; + continue; + } + + coef_t this_step = abs(Constr_Vars_Iter(*e, true).curr_coef()); + assert(this_step != 1); + + if (lb.size() != 0) { + Relation test = create_stride_on_bound(n, lb, this_step); + if (Gist(test, copy(I1[i])).is_obvious_tautology()) { + if (step[i] == 0) + step[i] = this_step; + else + step[i] = lcm(step[i], this_step); + } + else + is_exact[i] = false; + } + else { + // try to find a lower bound that hits on stride + Conjunct *c = I2[i].query_DNF()->single_conjunct(); + for (GEQ_Iterator ge = c->GEQs(); ge; ge++) { + if ((*ge).has_wildcards() || (*ge).get_coef(t_col) != 1) + continue; + + std::map<Variable_ID, coef_t> cur_lb; + for (Constr_Vars_Iter cv(*ge); cv; cv++) + cur_lb[cv.curr_var()] = cv.curr_coef(); + cur_lb[NULL] = (*ge).get_const(); + + Relation test = create_stride_on_bound(n, cur_lb, this_step); + if (Gist(test, copy(I1[i])).is_obvious_tautology()) { + if (step[i] == 0) + step[i] = this_step; + else + step[i] = lcm(step[i], this_step); + + lb = cur_lb; + break; + } + } + + // no clean lower bound, thus we use this modular constraint as is + if (lb.size() == 0) { + std::map<Variable_ID, coef_t> cur_lb; + int wild_count = 0; + for (Constr_Vars_Iter cv(*e); cv; cv++) + if (cv.curr_var()->kind() == Wildcard_Var) + wild_count++; + else + cur_lb[cv.curr_var()] = cv.curr_coef(); + cur_lb[NULL] = (*e).get_const(); + + if (wild_count == 1) { + lb = cur_lb; + if (step[i] == 0) + step[i] = this_step; + else + step[i] = lcm(step[i], this_step); + } + } + + if (lb.size() == 0) + is_exact[i] = false; + } + } + } + } + + // aggregate all exact steps + coef_t global_step = 0; + for (size_t i = 0; i < is_exact.size(); i++) + if (is_exact[i]) + global_step = gcd(global_step, step[i]); + if (global_step == 1) + return Relation::True(n); + + // now check all messy strides: a*t_col = ... (mod step) + for (size_t i = 0; i < I2.size(); i++) + if (!is_exact[i]) { + Conjunct *c = I2[i].query_DNF()->single_conjunct(); + for (EQ_Iterator e = c->EQs(); e; e++) { + coef_t coef = abs((*e).get_coef(t_col)); + if (coef == 0 || coef == 1) + continue; + + // make a guess for messy stride condition -- by chun 07/27/2007 + coef_t this_step = abs(Constr_Vars_Iter(*e, true).curr_coef()); + this_step /= gcd(this_step, coef); + this_step = gcd(global_step, this_step); + if (this_step == 1) + continue; + + if (lb.size() != 0) { + Relation test = create_stride_on_bound(n, lb, this_step); + if (Gist(test, copy(I1[i])).is_obvious_tautology()) { + if (step[i] == 0) + step[i] = this_step; + else + step[i] = lcm(step[i], this_step); + } + } + else { + // try to find a lower bound that hits on stride + Conjunct *c = I2[i].query_DNF()->single_conjunct(); + for (GEQ_Iterator ge = c->GEQs(); ge; ge++) { + if ((*ge).has_wildcards() || (*ge).get_coef(t_col) != 1) + continue; + + std::map<Variable_ID, coef_t> cur_lb; + + for (Constr_Vars_Iter cv(*ge); cv; cv++) + cur_lb[cv.curr_var()] = cv.curr_coef(); + + cur_lb[NULL] = (*ge).get_const(); + + Relation test = create_stride_on_bound(n, cur_lb, this_step); + if (Gist(test, copy(I1[i])).is_obvious_tautology()) { + if (step[i] == 0) + step[i] = this_step; + else + step[i] = lcm(step[i], this_step); + + lb = cur_lb; + break; + } + } + } + } + } + + // aggregate all non-exact steps + for (size_t i = 0; i < is_exact.size(); i++) + if (!is_exact[i]) + global_step = gcd(global_step, step[i]); + if (global_step == 1 || global_step == 0) + return Relation::True(n); + + Relation result = create_stride_on_bound(n, lb, global_step); + + // check for statements that haven't been factored into global step + for (size_t i = 0; i < I1.size(); i++) + if (step[i] == 0) { + if (!Gist(copy(result), copy(I1[i])).is_obvious_tautology()) + return Relation::True(n); + } + + return result; +} + + +//----------------------------------------------------------------------------- +// Substitute variables in a statement according to mapping function. +//----------------------------------------------------------------------------- +CG_outputRepr* outputStatement(CG_outputBuilder *ocg, CG_outputRepr *stmt, int indent, const Relation &mapping_, const Relation &known_, const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + Relation mapping = copy(mapping_); + Relation known = copy(known_); + Tuple<std::string> loop_vars; + + for (int i = 1; i <= mapping.n_inp(); i++) + loop_vars.append(mapping.input_var(i)->name()); + + // discard non-existant variables from iteration spaces -- by chun 12/31/2008 + if (known.n_set() > mapping.n_out()) { + Relation r(known.n_set(), mapping.n_out()); + F_And *f_root = r.add_and(); + for (int i = 1; i <= mapping.n_out(); i++) { + EQ_Handle h = f_root->add_EQ(); + h.update_coef(r.input_var(i), 1); + h.update_coef(r.output_var(i), -1); + } + known = Range(Restrict_Domain(r, known)); + known.simplify(); + } + + // remove modular constraints from known to simplify mapping process -- by chun 11/10/2008 + Relation k(known.n_set()); + F_And *f_root = k.add_and(); + Conjunct *c = known.query_DNF()->single_conjunct(); + for (EQ_Iterator e = c->EQs(); e; e++) { + if (!(*e).has_wildcards()) + f_root->add_EQ(*e); + } + k.simplify(); + + // get variable substituion list + Relation Inv_mapping = Restrict_Domain(Inverse(mapping), k); + Tuple<CG_outputRepr*> sList = outputSubstitution(ocg, Inv_mapping, assigned_on_the_fly); + + return ocg->CreatePlaceHolder(indent, stmt, sList, loop_vars); +} + + +// find floor definition for variable such as m-3 <= 4v <= m +bool findFloorInequality(Relation &r, Variable_ID v, GEQ_Handle &h, Variable_ID excluded) { + Conjunct *c = r.single_conjunct(); + + std::set<Variable_ID> var_checked; + std::stack<Variable_ID> var_checking; + var_checking.push(v); + + while (!var_checking.empty()) { + Variable_ID v2 = var_checking.top(); + var_checking.pop(); + + bool is_floor = false; + for (GEQ_Iterator gi(c); gi; gi++) { + if (excluded != NULL && (*gi).get_coef(excluded) != 0) + continue; + + coef_t a = (*gi).get_coef(v2); + if (a < 0) { + for (GEQ_Iterator gi2(c); gi2; gi2++) { + coef_t b = (*gi2).get_coef(v2); + if (b == -a && (*gi).get_const()+(*gi2).get_const() < -a) { + bool match = true; + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + if ((*gi2).get_coef((*cvi).var) != -(*cvi).coef) { + match = false; + break; + } + if (!match) + continue; + for (Constr_Vars_Iter cvi(*gi2); cvi; cvi++) + if ((*gi).get_coef((*cvi).var) != -(*cvi).coef) { + match = false; + break; + } + if (match) { + var_checked.insert(v2); + is_floor = true; + if (v == v2) + h = *gi; + + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + if (((*cvi).var->kind() == Exists_Var || (*cvi).var->kind() == Wildcard_Var) && + var_checked.find((*cvi).var) == var_checked.end()) + var_checking.push((*cvi).var); + + break; + } + } + } + if (is_floor) + break; + } + } + if (!is_floor) + return false; + } + return true; +} + + + + +//----------------------------------------------------------------------------- +// Output a reqular equality or inequality to conditions. +// e.g. (i=5*j) +//----------------------------------------------------------------------------- +CG_outputRepr* output_as_guard(CG_outputBuilder* ocg, const Relation &guards_in, Constraint_Handle e, bool is_equality, const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + Relation &guards = const_cast<Relation &>(guards_in); + if (e.has_wildcards()) + throw std::invalid_argument("constraint must not have wildcard"); + + Variable_ID v = (*Constr_Vars_Iter(e)).var; + + coef_t saved_coef = ((e).get_coef(v)); + int sign = saved_coef < 0 ? -1 : 1; + + (e).update_coef_during_simplify(v, -saved_coef+sign); + CG_outputRepr* rop = outputEasyBoundAsRepr(ocg, guards, e, v, false, 0, assigned_on_the_fly); + (e).update_coef_during_simplify(v,saved_coef-sign); + + CG_outputRepr* lop = outputIdent(ocg, guards, v, assigned_on_the_fly); + if (abs(saved_coef) != 1) + lop = ocg->CreateTimes(ocg->CreateInt(abs(saved_coef)), lop); + + + if (is_equality) { + return ocg->CreateEQ(lop, rop); + } + else { + if (saved_coef < 0) + return ocg->CreateLE(lop, rop); + else + return ocg->CreateGE(lop, rop); + } +} + + +//----------------------------------------------------------------------------- +// Output stride conditions from equalities. +// e.g. (exists alpha: i = 5*alpha) +//----------------------------------------------------------------------------- +CG_outputRepr *output_EQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + Relation guards = const_cast<Relation &>(guards_in); + Conjunct *c = guards.single_conjunct(); + + CG_outputRepr *eqRepr = NULL; + + for (EQ_Iterator ei(c->EQs()); ei; ei++) { + Variable_ID wc = NULL; + for (Constr_Vars_Iter cvi((*ei), true); cvi; cvi++) { + if (wc != NULL) + throw codegen_error("Can't generate equality condition with multiple wildcards"); + else + wc = (*cvi).var; + } + if (wc == NULL) + continue; + + coef_t step = (*ei).get_coef(wc); + + (*ei).update_coef_during_simplify(wc, 1-step); + CG_outputRepr* lop = outputEasyBoundAsRepr(ocg, guards, (*ei), wc, false, 0, assigned_on_the_fly); + (*ei).update_coef_during_simplify(wc, step-1); + + CG_outputRepr* rop = ocg->CreateInt(abs(step)); + CG_outputRepr* intMod = ocg->CreateIntegerMod(lop, rop); + CG_outputRepr* eqNode = ocg->CreateEQ(intMod, ocg->CreateInt(0)); + + eqRepr = ocg->CreateAnd(eqRepr, eqNode); + } + + return eqRepr; +} + + + +//----------------------------------------------------------------------------- +// Output hole conditions created by inequalities involving wildcards. +// e.g. (exists alpha: 4*alpha <= i <= 5*alpha) +// Collect wildcards +// For each whildcard +// collect lower and upper bounds in which wildcard appears +// For each lower bound +// create constraint with each upper bound +//----------------------------------------------------------------------------- +CG_outputRepr *output_GEQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + Relation guards = const_cast<Relation &>(guards_in); + Conjunct *c = guards.single_conjunct(); + + CG_outputRepr* geqRepr = NULL; + + std::set<Variable_ID> non_orphan_wildcard; + for (GEQ_Iterator gi(c); gi; gi++) { + int num_wild = 0; + Variable_ID first_one; + for (Constr_Vars_Iter cvi(*gi, true); cvi; cvi++) { + num_wild++; + if (num_wild == 1) + first_one = (*cvi).var; + else + non_orphan_wildcard.insert((*cvi).var); + } + if (num_wild > 1) + non_orphan_wildcard.insert(first_one); + } + + for (int i = 1; i <= (*(c->variables())).size(); i++) { + Variable_ID wc = (*(c->variables()))[i]; + if (wc->kind() == Wildcard_Var && non_orphan_wildcard.find(wc) == non_orphan_wildcard.end()) { + Tuple<GEQ_Handle> lower, upper; + for (GEQ_Iterator gi(c); gi; gi++) { + if((*gi).get_coef(wc) > 0) + lower.append(*gi); + else if((*gi).get_coef(wc) < 0) + upper.append(*gi); + } + + // low: c*alpha - x >= 0 + // up: -d*alpha + y >= 0 + for (Tuple_Iterator<GEQ_Handle> low(lower); low; low++) { + for (Tuple_Iterator<GEQ_Handle> up(upper); up; up++) { + coef_t low_coef = (*low).get_coef(wc); + coef_t up_coef = (*up).get_coef(wc); + + (*low).update_coef_during_simplify(wc, 1-low_coef); + CG_outputRepr* lowExpr = outputEasyBoundAsRepr(ocg, guards, *low, wc, false, 0, assigned_on_the_fly); + (*low).update_coef_during_simplify(wc, low_coef-1); + + (*up).update_coef_during_simplify(wc, -1-up_coef); + CG_outputRepr* upExpr = outputEasyBoundAsRepr(ocg, guards, *up, wc, false, 0, assigned_on_the_fly); + (*up).update_coef_during_simplify(wc, up_coef+1); + + CG_outputRepr* intDiv = ocg->CreateIntegerDivide(upExpr, ocg->CreateInt(-up_coef)); + CG_outputRepr* rop = ocg->CreateTimes(ocg->CreateInt(low_coef), intDiv); + CG_outputRepr* geqNode = ocg->CreateLE(lowExpr, rop); + + geqRepr = ocg->CreateAnd(geqRepr, geqNode); + } + } + } + } + + if (non_orphan_wildcard.size() > 0) { + // e.g. c*alpha - x >= 0 (*) + // -d*alpha + y >= 0 (*) + // e1*alpha + f1*beta + g1 >= 0 (**) + // e2*alpha + f2*beta + g2 >= 0 (**) + // ... + // TODO: should generate a testing loop for alpha using its lower and + // upper bounds from (*) constraints and do the same if-condition test + // for beta from each pair of opposite (**) constraints as above, + // and exit the loop when if-condition satisfied. + throw codegen_error("Can't generate multiple wildcard GEQ guards right now"); + } + + return geqRepr; +} + + +//----------------------------------------------------------------------------- +// Translate all constraints in a relation to guard conditions. +//----------------------------------------------------------------------------- +CG_outputRepr *outputGuard(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + Relation &guards = const_cast<Relation &>(guards_in); + if (guards.is_null() || guards.is_obvious_tautology()) + return NULL; + + CG_outputRepr* nodeRepr = NULL; + + CG_outputRepr *eqStrideRepr = output_EQ_strides(ocg, guards, assigned_on_the_fly); + nodeRepr = ocg->CreateAnd(nodeRepr, eqStrideRepr); + + CG_outputRepr *geqStrideRepr = output_GEQ_strides(ocg, guards, assigned_on_the_fly); + nodeRepr = ocg->CreateAnd(nodeRepr, geqStrideRepr); + + Conjunct *c = guards.single_conjunct(); + for(EQ_Iterator ei(c->EQs()); ei; ei++) + if (!(*ei).has_wildcards()) { + CG_outputRepr *eqRepr = output_as_guard(ocg, guards, (*ei), true, assigned_on_the_fly); + nodeRepr = ocg->CreateAnd(nodeRepr, eqRepr); + } + for(GEQ_Iterator gi(c->GEQs()); gi; gi++) + if (!(*gi).has_wildcards()) { + CG_outputRepr *geqRepr = output_as_guard(ocg, guards, (*gi), false, assigned_on_the_fly); + nodeRepr = ocg->CreateAnd(nodeRepr, geqRepr); + } + + return nodeRepr; +} + + +//----------------------------------------------------------------------------- +// one is 1 for LB +// this function is overloaded should replace the original one +//----------------------------------------------------------------------------- +CG_outputRepr *outputLBasRepr(CG_outputBuilder* ocg, const GEQ_Handle &g, + Relation &bounds, Variable_ID v, + coef_t stride, const EQ_Handle &strideEQ, + Relation known, const std::vector<CG_outputRepr *> &assigned_on_the_fly) { +#if ! defined NDEBUG + coef_t v_coef; + assert((v_coef = g.get_coef(v)) > 0); +#endif + + std::string s; + CG_outputRepr *lbRepr; + if (stride == 1) { + lbRepr = outputEasyBoundAsRepr(ocg, bounds, g, v, false, 1, assigned_on_the_fly); + } + else { + if (!boundHitsStride(g,v,strideEQ,stride,known)) { + bounds.setup_names(); // boundsHitsStride resets variable names + + CG_stringBuilder oscg; + std::string c = GetString(outputEasyBoundAsRepr(&oscg, bounds, strideEQ, v, true, 0, assigned_on_the_fly)); + CG_outputRepr *cRepr = NULL; + if (c != std::string("0")) + cRepr = outputEasyBoundAsRepr(ocg, bounds, strideEQ, v, true, 0, assigned_on_the_fly); + std::string LoverM = GetString(outputEasyBoundAsRepr(&oscg, bounds, g, v, false, 1, assigned_on_the_fly)); + CG_outputRepr *LoverMRepr = NULL; + if (LoverM != std::string("0")) + LoverMRepr = outputEasyBoundAsRepr(ocg, bounds, g, v, false, 1, assigned_on_the_fly); + + if (code_gen_debug > 2) { + fprintf(DebugFile,"::: LoverM is %s\n", LoverM.c_str()); + fprintf(DebugFile,"::: c is %s\n", c.c_str()); + } + + int complexity1 = 0, complexity2 = 0; + for (size_t i = 0; i < c.length(); i++) + if (c[i] == '+' || c[i] == '-' || c[i] == '*' || c[i] == '/') + complexity1++; + else if (c[i] == ',') + complexity1 += 2; + for (size_t i = 0; i < LoverM.length(); i++) + if (LoverM[i] == '+' || LoverM[i] == '-' || LoverM[i] == '*' || LoverM[i] == '/') + complexity2++; + else if (LoverM[i] == ',') + complexity2 += 2; + + if (complexity1 < complexity2) { + CG_outputRepr *idUp = LoverMRepr; + CG_outputRepr *c1Repr = ocg->CreateCopy(cRepr); + idUp = ocg->CreateMinus(idUp, c1Repr); + idUp = ocg->CreatePlus(idUp, ocg->CreateInt(stride-1)); + CG_outputRepr *idLow = ocg->CreateInt(stride); + lbRepr = ocg->CreateTimes(ocg->CreateInt(stride), + ocg->CreateIntegerDivide(idUp, idLow)); + lbRepr = ocg->CreatePlus(lbRepr, cRepr); + } + else { + CG_outputRepr *LoverM1Repr = ocg->CreateCopy(LoverMRepr); + CG_outputRepr *imUp = ocg->CreateMinus(cRepr, LoverM1Repr); + CG_outputRepr *imLow = ocg->CreateInt(stride); + CG_outputRepr *intMod = ocg->CreateIntegerMod(imUp, imLow); + lbRepr = ocg->CreatePlus(LoverMRepr, intMod); + } + } + else { + // boundsHitsStride resets variable names + bounds.setup_names(); + lbRepr = outputEasyBoundAsRepr(ocg, bounds, g, v, false, 0, assigned_on_the_fly); + } + } + + return lbRepr; +} + +//----------------------------------------------------------------------------- +// one is -1 for UB +// this function is overloaded should replace the original one +//----------------------------------------------------------------------------- +CG_outputRepr *outputUBasRepr(CG_outputBuilder* ocg, const GEQ_Handle &g, + Relation & bounds, + Variable_ID v, + coef_t /*stride*/, // currently unused + const EQ_Handle &/*strideEQ*/, //currently unused + const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + assert(g.get_coef(v) < 0); + CG_outputRepr* upRepr = outputEasyBoundAsRepr(ocg, bounds, g, v, false, 0, assigned_on_the_fly); + return upRepr; +} + +//----------------------------------------------------------------------------- +// Print the expression for the variable given as v. Works for both +// GEQ's and EQ's, but produces intDiv (not intMod) when v has a nonunit +// coefficient. So it is OK for loop bounds, but for checking stride +// constraints, you want to make sure the coef of v is 1, and insert the +// intMod yourself. +// +// original name is outputEasyBound +//----------------------------------------------------------------------------- +CG_outputRepr* outputEasyBoundAsRepr(CG_outputBuilder* ocg, Relation &bounds, + const Constraint_Handle &g, Variable_ID v, + bool ignoreWC, + int ceiling, + const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + // assert ignoreWC => g is EQ + // rewrite constraint as foo (== or <= or >=) v, return foo as string + + CG_outputRepr* easyBoundRepr = NULL; + + coef_t v_coef = g.get_coef(v); + int v_sign = v_coef > 0 ? 1 : -1; + v_coef *= v_sign; + assert(v_coef > 0); + // foo is (-constraint)/v_sign/v_coef + + int sign_adj = -v_sign; + + //---------------------------------------------------------------------- + // the following generates +- cf*varName + //---------------------------------------------------------------------- + for(Constr_Vars_Iter c2(g, false); c2; c2++) { + if ((*c2).var != v && (!ignoreWC || (*c2).var->kind()!=Wildcard_Var)) { + + coef_t cf = (*c2).coef*sign_adj; + assert(cf != 0); + + CG_outputRepr *varName; + if ((*c2).var->kind() == Wildcard_Var) { + GEQ_Handle h; + if (!findFloorInequality(bounds, (*c2).var, h, v)) { + if (easyBoundRepr != NULL) { + easyBoundRepr->clear(); + delete easyBoundRepr; + } + return NULL; + } + varName = outputEasyBoundAsRepr(ocg, bounds, h, (*c2).var, false, 0, assigned_on_the_fly); + } + else { + varName = outputIdent(ocg, bounds, (*c2).var, assigned_on_the_fly); + } + CG_outputRepr *cfRepr = NULL; + + if (cf > 1) { + cfRepr = ocg->CreateInt(cf); + CG_outputRepr* rbRepr = ocg->CreateTimes(cfRepr, varName); + easyBoundRepr = ocg->CreatePlus(easyBoundRepr, rbRepr); + } + else if (cf < -1) { + cfRepr = ocg->CreateInt(-cf); + CG_outputRepr* rbRepr = ocg->CreateTimes(cfRepr, varName); + easyBoundRepr = ocg->CreateMinus(easyBoundRepr, rbRepr); + } + else if (cf == 1) { + easyBoundRepr = ocg->CreatePlus(easyBoundRepr, varName); + } + else if (cf == -1) { + easyBoundRepr = ocg->CreateMinus(easyBoundRepr, varName); + } + } + } + + if (g.get_const()) { + coef_t cf = g.get_const()*sign_adj; + assert(cf != 0); + if (cf > 0) { + easyBoundRepr = ocg->CreatePlus(easyBoundRepr, ocg->CreateInt(cf)); + } + else { + easyBoundRepr = ocg->CreateMinus(easyBoundRepr, ocg->CreateInt(-cf)); + } + } + else { + if(easyBoundRepr == NULL) { + easyBoundRepr = ocg->CreateInt(0); + } + } + + if (v_coef > 1) { + assert(ceiling >= 0); + if (ceiling) { + easyBoundRepr= ocg->CreatePlus(easyBoundRepr, ocg->CreateInt(v_coef-1)); + } + easyBoundRepr = ocg->CreateIntegerDivide(easyBoundRepr, ocg->CreateInt(v_coef)); + } + + return easyBoundRepr; +} + + +//---------------------------------------------------------------------------- +// Translate inequality constraints to loop or assignment. +// if return.second is true, return.first is loop structure, +// otherwise it is assignment. +// ---------------------------------------------------------------------------- +std::pair<CG_outputRepr *, bool> outputBounds(CG_outputBuilder* ocg, const Relation &bounds, Variable_ID v, int indent, Relation &enforced, const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + Relation b = copy(bounds); + Conjunct *c = b.query_DNF()->single_conjunct(); + + // Elaborate stride simplification which is complementary to gist function + // since we further target the specific loop variable. -- by chun 08/07/2008 + Relation r1 = Relation::True(b.n_set()), r2 = Relation::True(b.n_set()); + for (EQ_Iterator ei(c); ei; ei++) { + if ((*ei).get_coef(v) != 0 && (*ei).has_wildcards()) { // stride condition found + coef_t sign; + if ((*ei).get_coef(v) > 0) + sign = 1; + else + sign = -1; + + coef_t stride = 0; + for (Constr_Vars_Iter cvi(*ei, true); cvi; cvi++) + if ((*cvi).var->kind() == Wildcard_Var) { + stride = abs((*cvi).coef); + break; + } + + // check if stride hits lower bound + bool found_match = false; + if (abs((*ei).get_coef(v)) != 1) { // expensive matching for non-clean stride condition + coef_t d = stride / gcd(abs((*ei).get_coef(v)), stride); + Relation r3 = Relation::True(b.n_set()); + r3.and_with_EQ(*ei); + + for (GEQ_Iterator gi(c); gi; gi++) { + if ((*gi).get_coef(v) == 1 && !(*gi).has_wildcards()) { + Relation r4(b.n_set()); + F_And *f_root = r4.add_and(); + Stride_Handle h = f_root->add_stride(d); + + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + int pos = (*cvi).var->get_position(); + h.update_coef(r4.set_var(pos), (*cvi).coef); + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = r4.get_local(g); + else + v = r4.get_local(g, (*cvi).var->function_of()); + h.update_coef(v, (*cvi).coef); + break; + } + default: + fprintf(DebugFile, "can't deal with the variable type in lower bound\n"); + return std::make_pair(static_cast<CG_outputRepr *>(NULL), false); + } + h.update_const((*gi).get_const()); + + Relation r5 = Gist(copy(r3), Intersection(copy(r4), copy(enforced))); + + // replace original stride condition with striding from this lower bound + if (r5.is_obvious_tautology()) { + r1 = Intersection(r1, r4); + found_match = true; + break; + } + } + } + } + else { + for (GEQ_Iterator gi(c); gi; gi++) { + if ((*gi).get_coef(v) == abs((*ei).get_coef(v)) && !(*gi).has_wildcards()) { // potential matching lower bound found + Relation r(b.n_set()); + Stride_Handle h = r.add_and()->add_stride(stride); + + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + int pos = (*cvi).var->get_position(); + if ((*cvi).var != v) { + int t1 = int_mod((*cvi).coef, stride); + if (t1 != 0) { + coef_t t2 = enforced.query_variable_mod(enforced.set_var(pos), stride); + if (t2 != posInfinity) + h.update_const(t1*t2); + else + h.update_coef(r.set_var(pos), t1); + } + } + else + h.update_coef(r.set_var(pos), (*cvi).coef); + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = enforced.get_local(g); + else + v = enforced.get_local(g, (*cvi).var->function_of()); + coef_t t = enforced.query_variable_mod(v, stride); + if (t != posInfinity) + h.update_const(t*(*cvi).coef); + else { + Variable_ID v2; + if (g->arity() == 0) + v2 = r.get_local(g); + else + v2 = r.get_local(g, (*cvi).var->function_of()); + h.update_coef(v2, (*cvi).coef); + } + break; + } + default: + fprintf(DebugFile, "can't deal with the variable type in lower bound\n"); + return std::make_pair(static_cast<CG_outputRepr *>(NULL), false); + } + h.update_const((*gi).get_const()); + + bool t = true; + { + Conjunct *c2 = r.query_DNF()->single_conjunct(); + EQ_Handle h2; + for (EQ_Iterator ei2(c2); ei2; ei2++) { + h2 = *ei2; + break; + } + + int sign; + if (h2.get_coef(v) == (*ei).get_coef(v)) + sign = 1; + else + sign = -1; + + t = int_mod(h2.get_const() - sign * (*ei).get_const(), stride) == 0; + + if (t != false) + for (Constr_Vars_Iter cvi(h2); cvi; cvi++) + if ((*cvi).var->kind() != Wildcard_Var && + int_mod((*cvi).coef - sign * (*ei).get_coef((*cvi).var), stride) != 0) { + t = false; + break; + } + + if (t != false) + for (Constr_Vars_Iter cvi(*ei); cvi; cvi++) + if ((*cvi).var->kind() != Wildcard_Var && + int_mod((*cvi).coef - sign * h2.get_coef((*cvi).var), stride) != 0) { + t = false; + break; + } + + } + + if (t) { + // replace original stride condition with striding from this lower bound + F_And *f_root = r1.and_with_and(); + Stride_Handle h = f_root->add_stride(stride); + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + h.update_coef(r1.set_var((*cvi).var->get_position()), (*cvi).coef); + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = r1.get_local(g); + else + v = r1.get_local(g, (*cvi).var->function_of()); + h.update_coef(v, (*cvi).coef); + break; + } + default: + fprintf(DebugFile, "can't deal with the variable type in lower bound\n"); + return std::make_pair(static_cast<CG_outputRepr *>(NULL), false); + } + h.update_const((*gi).get_const()); + + found_match = true; + break; + } + } + } + } + + if (!found_match) + r1.and_with_EQ(*ei); + } + else if ((*ei).get_coef(v) == 0) { + Relation r3 = Relation::True(b.n_set()); + r3.and_with_EQ(*ei); + Relation r4 = Gist(r3, copy(enforced)); + if (!r4.is_obvious_tautology()) + r2.and_with_EQ(*ei); + } + else + r2.and_with_EQ(*ei); + } + + // restore remaining inequalities + { + std::map<Variable_ID, Variable_ID> exists_mapping; + F_Exists *fe = r2.and_with_and()->add_exists(); + F_And *f_root = fe->add_and(); + for (GEQ_Iterator gi(c); gi; gi++) { + GEQ_Handle h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: { + int pos = v->get_position(); + h.update_coef(r2.set_var(pos), cvi.curr_coef()); + break; + } + case Exists_Var: + case Wildcard_Var: { + std::map<Variable_ID, Variable_ID>::iterator p = exists_mapping.find(v); + Variable_ID e; + if (p == exists_mapping.end()) { + e = fe->declare(); + exists_mapping[v] = e; + } + else + e = (*p).second; + h.update_coef(e, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r2.get_local(g); + else + v2 = r2.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(0); + } + } + h.update_const((*gi).get_const()); + } + } + + // overwrite original bounds + { + r1.simplify(); + r2.simplify(); + Relation b2 = Intersection(r1, r2); + b2.simplify(); + for (int i = 1; i <= b.n_set(); i++) + b2.name_set_var(i, b.set_var(i)->name()); + b2.setup_names(); + b = b2; + c = b.query_DNF()->single_conjunct(); + } + + + // get loop strides + EQ_Handle strideEQ; + bool foundStride = false; // stride that can be translated to loop + bool foundSimpleStride = false; // stride that starts from const value + coef_t step = 1; + int num_stride = 0; + + for (EQ_Iterator ei(c); ei; ei++) { + if ((*ei).get_coef(v) != 0 && (*ei).has_wildcards()) { + num_stride++; + + if (abs((*ei).get_coef(v)) != 1) + continue; + + bool t = true; + coef_t d = 1; + for (Constr_Vars_Iter cvi(*ei); cvi; cvi++) + if ((*cvi).var->kind() == Wildcard_Var) { + assert(d==1); + d = abs((*cvi).coef); + } + else if ((*cvi).var->kind() == Input_Var) { + if ((*cvi).var != v) + t = false; + } + else + t = false; + + if (d > step) { + step = d; + foundSimpleStride = t; + strideEQ = *ei; + foundStride = true; + } + } + } + + // More than one stride or complex stride found, we should move all + // but strideEQ to body's guard condition. alas, not implemented. + if (!(num_stride == 0 || (num_stride == 1 && foundStride))) + return std::make_pair(static_cast<CG_outputRepr *>(NULL), false); + + // get loop bounds + int lower_bounds = 0, upper_bounds = 0; + Tuple<CG_outputRepr *> lbList; + Tuple<CG_outputRepr *> ubList; + coef_t const_lb = negInfinity, const_ub = posInfinity; + for (GEQ_Iterator g(c); g; g++) { + coef_t coef = (*g).get_coef(v); + if (coef == 0) + continue; + else if (coef > 0) { // lower bound + lower_bounds++; + if ((*g).is_const(v) && !foundStride) { + //no variables but v in constr + coef_t L,m; + L = -((*g).get_const()); + + m = (*g).get_coef(v); + coef_t sb = (int) (ceil(((float) L) /m)); + set_max(const_lb, sb); + } + else if ((*g).is_const(v) && foundSimpleStride) { + // no variables but v in constr + //make LB fit the stride constraint + coef_t L,m,s,c; + L = -((*g).get_const()); + m = (*g).get_coef(v); + s = step; + c = strideEQ.get_const(); + coef_t sb = (s * (int) (ceil( (float) (L - (c * m)) /(s*m))))+ c; + set_max(const_lb, sb); + } + else + lbList.append(outputLBasRepr(ocg, *g, b, v, step, strideEQ, enforced, assigned_on_the_fly)); + } + else { // upper bound + upper_bounds++; + if ((*g).is_const(v)) { + // no variables but v in constraint + set_min(const_ub,-(*g).get_const()/(*g).get_coef(v)); + } + else + ubList.append(outputUBasRepr(ocg, *g, b, v, step, strideEQ, assigned_on_the_fly)); + } + } + + CG_outputRepr *lbRepr = NULL; + CG_outputRepr *ubRepr = NULL; + if (const_lb != negInfinity) + lbList.append(ocg->CreateInt(const_lb)); + if (lbList.size() > 1) + lbRepr = ocg->CreateInvoke("max", lbList); + else if (lbList.size() == 1) + lbRepr = lbList[1]; + + //protonu + if(fillInBounds && lbList.size() == 1 && const_lb != negInfinity) + lowerBoundForLevel = const_lb; + //end-protonu + + if (const_ub != posInfinity) + ubList.append(ocg->CreateInt(const_ub)); + if (ubList.size() > 1) + ubRepr = ocg->CreateInvoke("min", ubList); + else if (ubList.size() == 1) + ubRepr = ubList[1]; + + //protonu + if(fillInBounds && const_ub != posInfinity) + upperBoundForLevel = const_ub; + //end-protonu + + if (upper_bounds == 0 || lower_bounds == 0) { + return std::make_pair(static_cast<CG_outputRepr *>(NULL), false); + } + else { + // bookkeeping catched constraints in new_knwon + F_Exists *fe = enforced.and_with_and()->add_exists(); + F_And *f_root = fe->add_and(); + std::map<Variable_ID, Variable_ID> exists_mapping; + std::stack<std::pair<GEQ_Handle, Variable_ID> > floor_geq_stack; + std::set<Variable_ID> floor_var_set; + + if (foundStride) { + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(strideEQ); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + int pos = (*cvi).var->get_position(); + h.update_coef(enforced.set_var(pos), (*cvi).coef); + break; + } + case Exists_Var: + case Wildcard_Var: { + std::map<Variable_ID, Variable_ID>::iterator p = exists_mapping.find((*cvi).var); + Variable_ID e; + if (p == exists_mapping.end()) { + e = fe->declare(); + exists_mapping[(*cvi).var] = e; + } + else + e = (*p).second; + h.update_coef(e, (*cvi).coef); + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID e; + if (g->arity() == 0) + e = enforced.get_local(g); + else + e = enforced.get_local(g, (*cvi).var->function_of()); + h.update_coef(e, (*cvi).coef); + break; + } + default: + assert(0); + } + h.update_const(strideEQ.get_const()); + } + + for (GEQ_Iterator gi(c); gi; gi++) + if ((*gi).get_coef(v) != 0) { + GEQ_Handle h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + int pos = (*cvi).var->get_position(); + h.update_coef(enforced.set_var(pos), (*cvi).coef); + break; + } + case Exists_Var: + case Wildcard_Var: { + std::map<Variable_ID, Variable_ID>::iterator p = exists_mapping.find((*cvi).var); + Variable_ID e; + if (p == exists_mapping.end()) { + e = fe->declare(); + exists_mapping[(*cvi).var] = e; + } + else + e = (*p).second; + h.update_coef(e, (*cvi).coef); + + if (floor_var_set.find((*cvi).var) == floor_var_set.end()) { + GEQ_Handle h2; + findFloorInequality(b, (*cvi).var, h2, v); + floor_geq_stack.push(std::make_pair(h2, (*cvi).var)); + floor_var_set.insert((*cvi).var); + } + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID e; + if (g->arity() == 0) + e = enforced.get_local(g); + else + e = enforced.get_local(g, (*cvi).var->function_of()); + h.update_coef(e, (*cvi).coef); + break; + } + default: + assert(0); + } + h.update_const((*gi).get_const()); + } + + // add floor definition involving variables appeared in bounds + while (!floor_geq_stack.empty()) { + std::pair<GEQ_Handle, Variable_ID> p = floor_geq_stack.top(); + floor_geq_stack.pop(); + + GEQ_Handle h1 = f_root->add_GEQ(); + GEQ_Handle h2 = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(p.first); cvi; cvi++) { + switch ((*cvi).var->kind()) { + case Input_Var: { + int pos = (*cvi).var->get_position(); + h1.update_coef(enforced.input_var(pos), (*cvi).coef); + h2.update_coef(enforced.input_var(pos), -(*cvi).coef); + break; + } + case Exists_Var: + case Wildcard_Var: { + std::map<Variable_ID, Variable_ID>::iterator p2 = exists_mapping.find((*cvi).var); + Variable_ID e; + if (p2 == exists_mapping.end()) { + e = fe->declare(); + exists_mapping[(*cvi).var] = e; + } + else + e = (*p2).second; + h1.update_coef(e, (*cvi).coef); + h2.update_coef(e, -(*cvi).coef); + + if (floor_var_set.find((*cvi).var) == floor_var_set.end()) { + GEQ_Handle h3; + findFloorInequality(b, (*cvi).var, h3, v); + floor_geq_stack.push(std::make_pair(h3, (*cvi).var)); + floor_var_set.insert((*cvi).var); + } + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID e; + if (g->arity() == 0) + e = enforced.get_local(g); + else + e = enforced.get_local(g, (*cvi).var->function_of()); + h1.update_coef(e, (*cvi).coef); + h2.update_coef(e, -(*cvi).coef); + break; + } + default: + assert(0); + } + } + h1.update_const(p.first.get_const()); + h2.update_const(-p.first.get_const()); + h2.update_const(-p.first.get_coef(p.second)-1); + } + enforced.simplify(); + + CG_outputRepr *stRepr = NULL; + if (step != 1) + stRepr = ocg->CreateInt(abs(step)); + CG_outputRepr *indexRepr = outputIdent(ocg, b, v, assigned_on_the_fly); + CG_outputRepr *ctrlRepr = ocg->CreateInductive(indexRepr, lbRepr, ubRepr, stRepr); + + return std::make_pair(ctrlRepr, true); + } +} + + +Relation project_onto_levels(Relation R, int last_level, bool wildcards) { + assert(last_level >= 0 && R.is_set() && last_level <= R.n_set()); + if (last_level == R.n_set()) return R; + + int orig_vars = R.n_set(); + int num_projected = orig_vars - last_level; + R = Extend_Set(R,num_projected + ); // Project out vars numbered > last_level + Mapping m1 = Mapping::Identity(R.n_set()); // now orig_vars+num_proj + + for(int i=last_level+1; i <= orig_vars; i++) { + m1.set_map(Set_Var, i, Exists_Var, i); + m1.set_map(Set_Var, i+num_projected, Set_Var, i); + } + + MapRel1(R, m1, Comb_Id); + R.finalize(); + R.simplify(); + if (!wildcards) + R = Approximate(R,1); + assert(R.is_set()); + return R; +} + + +// Check if the lower bound already enforces the stride by +// (Where m is coef of v in g and L is the bound on m*v): +// Check if m divides L evenly and Check if this l.bound on v implies strideEQ +bool boundHitsStride(const GEQ_Handle &g, Variable_ID v, + const EQ_Handle &strideEQ, + coef_t /*stride*/, // currently unused + Relation known) { +/* m = coef of v in g; + L = bound on v part of g; +*/ + // Check if m divides L evenly + coef_t m = g.get_coef(v); + Relation test(known.n_set()); + F_Exists *e = test.add_exists(); // g is "L >= mv" + Variable_ID alpha = e->declare(); // want: "l = m alpha" + F_And *a = e->add_and(); + EQ_Handle h = a->add_EQ(); + for(Constr_Vars_Iter I(g,false); I; I++) + if((*I).var != v) { + if((*I).var->kind() != Global_Var) + h.update_coef((*I).var, (*I).coef); + else + h.update_coef(test.get_local((*I).var->get_global_var()), (*I).coef); + } + + h.update_const(g.get_const()); + h.update_coef(alpha,m); // set alpha's coef to m + if (!(Gist(test,copy(known)).is_obvious_tautology())) + return false; + // Check if this lower bound on v implies the strideEQ + Relation boundRel = known; // want: "known and l = m v" + boundRel.and_with_EQ(g); // add in l = mv + Relation strideRel(known.n_set()); + strideRel.and_with_EQ(strideEQ); + return Gist(strideRel, boundRel).is_obvious_tautology(); +} + + +// // Return true if there are no variables in g except wildcards & v +bool isSimpleStride(const EQ_Handle &g, Variable_ID v) { + EQ_Handle gg = g; // should not be necessary, but iterators are + // a bit brain-dammaged + bool is_simple=true; + for(Constr_Vars_Iter cvi(gg, false); cvi && is_simple; cvi++) + is_simple = ((*cvi).coef == 0 || (*cvi).var == v + || (*cvi).var->kind() == Wildcard_Var); + return is_simple; +} + + +int countStrides(Conjunct *c, Variable_ID v, EQ_Handle &strideEQ, + bool &simple) { + int strides=0; + for(EQ_Iterator G(c); G; G++) + for(Constr_Vars_Iter I(*G, true); I; I++) + if (((*I).coef != 0) && (*G).get_coef(v) != 0) { + strides++; + simple = isSimpleStride(*G,v); + strideEQ = *G; + break; + } + return strides; +} + +namespace { + +bool hasEQ(Relation r, int level) { + r.simplify(); + Variable_ID v = set_var(level); + Conjunct *s_conj = r.single_conjunct(); + for(EQ_Iterator G(s_conj); G; G++) + if ((*G).get_coef(v)) + return true; + return false; +} + + + +static Relation pickEQ(Relation r, int level) { + r.simplify(); + Variable_ID v = set_var(level); + Conjunct *s_conj = r.single_conjunct(); + for(EQ_Iterator E(s_conj); E; E++) + if ((*E).get_coef(v)) { + Relation test_rel(r.n_set()); + test_rel.and_with_EQ(*E); + return test_rel; + } + assert(0); + return r; +} + +/* pickBound will return an EQ as a GEQ if it finds one */ +Relation pickBound(Relation r, int level, int UB) { + r.simplify(); + Variable_ID v = set_var(level); + Conjunct *s_conj = r.single_conjunct(); + for(GEQ_Iterator G(s_conj); G; G++) { + if ((UB && (*G).get_coef(v) < 0) + || (!UB && (*G).get_coef(v) > 0) ) { + Relation test_rel(r.n_set()); + test_rel.and_with_GEQ(*G); + return test_rel; + } + } + for(EQ_Iterator E(s_conj); E; E++) { + if ((*E).get_coef(v)) { + Relation test_rel(r.n_set()); + test_rel.and_with_GEQ(*E); + if ((UB && (*E).get_coef(v) > 0) + || (!UB && (*E).get_coef(v) < 0) ) + test_rel = Complement(test_rel); + return test_rel; + } + } + assert(0); + return r; +} + +} + +Relation pickOverhead(Relation r, int liftTo) { + r.simplify(); + Conjunct *s_conj = r.single_conjunct(); + for(GEQ_Iterator G(s_conj); G; G++) { + Relation test_rel(r.n_set()); + test_rel.and_with_GEQ(*G); + Variable_ID v; + coef_t pos = -1; + coef_t c= 0; + for(Constr_Vars_Iter cvi(*G, false); cvi; cvi++) + if ((*cvi).coef && (*cvi).var->kind() == Input_Var + && (*cvi).var->get_position() > pos) { + v = (*cvi).var; + pos = (*cvi).var->get_position(); + c = (*cvi).coef; + } +#if 0 + fprintf(DebugFile,"Coef = %d, constraint = %s\n", + c,(const char *)test_rel.print_formula_to_string()); +#endif + return test_rel; + } + for(EQ_Iterator E(s_conj); E; E++) { + assert(liftTo >= 1); + int pos = max((*E).max_tuple_pos(),max_fs_arity(*E)+1); + +/* Pick stride constraints only when the variables with stride are outer + loop variables */ + if ((*E).has_wildcards() && pos < liftTo) { + Relation test_rel(r.n_set()); + test_rel.and_with_EQ(*E); + return test_rel; + } + else if (!(*E).has_wildcards() && pos <= liftTo) { + Relation test_rel(r.n_set()); + test_rel.and_with_EQ(*E); + test_rel.simplify(); + test_rel = EQs_to_GEQs(test_rel,true); + return pickOverhead(test_rel,liftTo); + } + } + if (code_gen_debug>1) { + fprintf(DebugFile,"Could not find overhead:\n"); + r.prefix_print(DebugFile); + } + return Relation::True(r.n_set()); +} + + + +bool hasBound(Relation r, int level, int UB) { + r.simplify(); + Variable_ID v = set_var(level); + Conjunct *s_conj = r.single_conjunct(); + for(GEQ_Iterator G(s_conj); G; G++) { + if (UB && (*G).get_coef(v) < 0) return true; + if (!UB && (*G).get_coef(v) > 0) return true; + } + for(EQ_Iterator E(s_conj); E; E++) { + if ((*E).get_coef(v)) return true; + } + return false; +} + +bool find_any_constraint(int s, int level, Relation &kr, int direction, + Relation &S, bool approx) { + /* If we don't intersect I with restrictions, the combination + of S and restrictions can be unsatisfiable, which means that + the new split node gets pruned away and we still don't have + finite bounds -> infinite recursion. */ + + Relation I = projected_nIS[level][s]; + I = Gist(I,copy(kr)); + if(approx) I = Approximate(I); + if (hasBound(I,level,direction)) { + Relation pickfrom; + if(has_nonstride_EQ(I,level)) + pickfrom = pickEQ(I,level); + else + pickfrom = pickBound(I,level,direction); + S = pickOverhead(pickfrom,level); + if(S.is_obvious_tautology()) S = Relation::Null(); + return !S.is_null(); + } + return false; +} + + +bool has_nonstride_EQ(Relation r, int level) { + r.simplify(); + Variable_ID v = set_var(level); + Conjunct *s_conj = r.single_conjunct(); + for(EQ_Iterator G(s_conj); G; G++) + if ((*G).get_coef(v) && !(*G).has_wildcards()) + return true; + return false; +} + + +Relation minMaxOverhead(Relation r, int level) { + r.finalize(); + r.simplify(); + Conjunct *s_conj = r.single_conjunct(); + GEQ_Handle LBs[50],UBs[50]; + int numLBs = 0; + int numUBs = 0; + Variable_ID v = set_var(level); + for(GEQ_Iterator G(s_conj); G; G++) if ((*G).get_coef(v)) { + GEQ_Handle g = *G; + if (g.get_coef(v) > 0) LBs[numLBs++] = g; + else UBs[numUBs++] = g; + } + if (numLBs <= 1 && numUBs <= 1) { + return Relation::True(r.n_set()); + } + Relation r1(r.n_set()); + Relation r2(r.n_set()); + if (numLBs > 1) { + // remove a max in lower bound + r1.and_with_GEQ(LBs[0]); + r2.and_with_GEQ(LBs[1]); + r1 = project_onto_levels(Difference(r1,r2),level-1,0); + } + else { + // remove a min in upper bound + r1.and_with_GEQ(UBs[0]); + r2.and_with_GEQ(UBs[1]); + r1 = project_onto_levels(Difference(r1,r2),level-1,0); + } +#if 0 + fprintf(DebugFile,"Testing %s\n",(const char *)r1.print_formula_to_string()); + fprintf(DebugFile,"will removed overhead on bounds of t%d: %s\n",level, + (const char *)r.print_formula_to_string()); +#endif + + return pickOverhead(r1, -1); +} + +std::pair<EQ_Handle, int> find_simplest_assignment(const Relation &R_, Variable_ID v, const std::vector<CG_outputRepr *> &assigned_on_the_fly) { + Relation &R = const_cast<Relation &>(R_); + Conjunct *c = R.single_conjunct(); + + int min_cost = INT_MAX; + EQ_Handle eq; + for (EQ_Iterator ei(c->EQs()); ei; ei++) + if (!(*ei).has_wildcards() && (*ei).get_coef(v) != 0) { + int cost = 0; + + if (abs((*ei).get_coef(v)) != 1) + cost += 4; // divide cost + + int num_var = 0; + for (Constr_Vars_Iter cvi(*ei); cvi; cvi++) + if ((*cvi).var != v) { + num_var++; + if ((*cvi).var->kind() == Global_Var && (*cvi).var->get_global_var()->arity() > 0) { + cost += 10; // function cost + } + if (abs((*cvi).coef) != 1) + cost += 2; // multiply cost + if ((*cvi).var->kind() == Input_Var && assigned_on_the_fly[(*cvi).var->get_position()-1] != NULL) { + cost += 5; // substituted variable cost + } + } + if ((*ei).get_const() != 0) + num_var++; + if (num_var > 1) + cost += num_var - 1; // addition cost + + if (cost < min_cost) { + min_cost = cost; + eq = *ei; + } + } + + return std::make_pair(eq, min_cost); +} + +int max_fs_arity(const Constraint_Handle &c) { + int max_arity=0; + for(Constr_Vars_Iter cv(c); cv; cv++) + if((*cv).var->kind() == Global_Var) + max_arity = max(max_arity,(*cv).var->get_global_var()->arity()); + return max_arity; +} + +} diff --git a/omegalib/code_gen/src/rose_attributes.cc b/omegalib/code_gen/src/rose_attributes.cc new file mode 100644 index 0000000..bb9681c --- /dev/null +++ b/omegalib/code_gen/src/rose_attributes.cc @@ -0,0 +1,183 @@ +#include <code_gen/rose_attributes.h> + +namespace omega { + +CodeInsertionAttribute* getOrCreateCodeInsertionAttribute(SgNode* node) { + CodeInsertionAttribute* attr; + if(node->attributeExists("code_insertion")) + return static_cast<CodeInsertionAttribute*>(node->getAttribute("code_insertion")); + attr = new CodeInsertionAttribute(); + node->setAttribute("code_insertion", attr); + return attr; +} + +void postProcessRoseCodeInsertion(SgProject* proj) { + //generatePDF(*proj); + CodeInsertionVisitor visitor = CodeInsertionVisitor(); + visitor.initialize(); + visitor.traverseInputFiles(proj); + visitor.insertCode(); +} + +// Swap a code insertion from one node (sn) to another (dn) +// -- note that this function does not currently remove the insertion from the sn node +void moveCodeInsertion(SgNode* sn, CodeInsertion* ci, SgNode* dn) { + CodeInsertionAttribute* new_attr; + // TODO in the near future: replace the above statement with 'new_attr = getOrCreateCodeInsertionAttribute(...)' + CodeInsertionAttribute* old_attr = static_cast<CodeInsertionAttribute*>(sn->getAttribute("code_insertion")); + if(dn->attributeExists("code_insertion")) { + new_attr = static_cast<CodeInsertionAttribute*>(dn->getAttribute("code_insertion")); + } + else { + new_attr = new CodeInsertionAttribute(); + dn->setAttribute("code_insertion", new_attr); + } + new_attr->add(ci); +} + +// A function that copies a specific attribute from one node to another +// this function exists to get around a ROSE limitation that does not +// copy attributes +void copyAttribute(std::string attr_name, SgNode* s, SgNode* d) { + if(s->attributeExists(attr_name)) { + d->setAttribute(attr_name,s->getAttribute(attr_name)); + } +} + +// TODO: find all existng attributes and iterate over them instead of doing them +// individually +void copyAttributes(SgNode* s, SgNode* d) { + copyAttribute("code_insertion", s, d); + //...any other attributes... +} + +void CodeInsertionVisitor::initialize() { + this->loop_level = 0; + this->ci_marks = std::vector<CodeInsertionMark*>(); +} + +void CodeInsertionVisitor::markStmt(SgStatement* stmt, CodeInsertion* ci) { + // this check prevents multiple copies of stmts + // -- may be changed in the future + if(!ci->marked) { + CodeInsertionMark* pos = new CodeInsertionMark(); + pos->stmt = stmt; + pos->ci = ci; + this->ci_marks.push_back(pos); + ci->marked = true; + } +} + +// increase loop_level as the visitor descends +void CodeInsertionVisitor::preOrderVisit(SgNode* n) { + if (isSgForStatement(n)) { + this->loop_level++; + } +} + +void CodeInsertionVisitor::postOrderVisit(SgNode* n) { + if(isSgForStatement(n)) { + this->loop_level--; + } + if(isSgStatement(n)) { + if(n->attributeExists("code_insertion")) { + CodeInsertionAttribute *attr = static_cast<CodeInsertionAttribute*>(n->getAttribute("code_insertion")); + for(CodeInsertionPtrListItr itr = attr->begin(); itr != attr->end(); ++itr) { + CodeInsertion *insertion = *itr; + // check loop level -- if it is equivelent, mark statement for insertion + // -- else, move attribute up to parent + if(insertion->loop_level != this->loop_level) { + moveCodeInsertion(n, insertion, n->get_parent()); + } + else { + this->markStmt(isSgStatement(n), insertion); + } + } + } + } +} + +// final stage of algorithm that inserts marked statements +void CodeInsertionVisitor::insertCode() { + for(std::vector<CodeInsertionMark*>::iterator itr = this->ci_marks.begin(); itr != this->ci_marks.end(); ++itr) { + CodeInsertionMark* mark = *itr; + SgScopeStatement* scope = static_cast<SgScopeStatement*>(mark->stmt->get_parent()); + SageInterface::insertStatementBefore(mark->stmt, mark->ci->getStatement(scope)); + } +} + +SgStatement* PragmaInsertion::getStatement(SgScopeStatement* scopeStmt) { + SgStatement* stmt = SageBuilder::buildPragmaDeclaration(this->name); + return stmt; +} + +//SgStatement* MMPrefetchInsertion::getStatement(SgScopeStatement* scopeStmt) { +// const SgName& name = SgName("_mm_prefetch"); +// SgType* rtype = SageBuilder::buildVoidType(); +// SgExpression* arr_arg = SageBuilder::buildVarRefExp(this->arrName); +// SgExpression* hint_arg = SageBuilder::buildShortVal(this->cacheHint); +// SgExprListExp* args = SageBuilder::buildExprListExp(arr_arg,hint_arg); +// SgStatement* stmt = SageBuilder::buildFunctionCallStmt(name, rtype, args, scopeStmt); +// return stmt; +//} + +SgStatement* MMPrefetchInsertion::getStatement(SgScopeStatement* scopeStmt) { + const SgName fname = SgName("_mm_prefetch"); + SgType* rtype = SageBuilder::buildVoidType(); + SgExpression* arr_arg = this->buildArrArg(scopeStmt); + SgExpression* hint_arg = SageBuilder::buildShortVal(this->cacheHint); + SgExprListExp* args = SageBuilder::buildExprListExp(arr_arg, hint_arg); + return SageBuilder::buildFunctionCallStmt(fname, rtype, args, scopeStmt); +} + +SgExpression* MMPrefetchInsertion::buildArrArg(SgScopeStatement* scopeStmt) { + // if there are no index arguments given, just return a variable reference + if(this->indexCount == 0) { + const SgName aname = SgName(this->arrName); + return SageBuilder::buildVarRefExp(aname, scopeStmt); + } + std::vector<SgExpression*> argList = std::vector<SgExpression*>(); + // foreach dimension + for(int i = 0; i < this->indexCount; i++) { + argList.push_back(this->makeIndexExp(i, scopeStmt)); + } + return SageBuilder::buildExprListExp(argList); +} + +SgExpression* MMPrefetchInsertion::makeIndexExp(int dim, SgScopeStatement* scopeStmt) { + //(i + offset) or (offset) or (i) + std::string* indexer = this->indecies.at(dim); + int offset = this->offsets.at(dim); + if(indexer == NULL) { + return SageBuilder::buildIntVal(offset); + } + else { + const SgName name = SgName(*indexer); + SgVarRefExp* iref = SageBuilder::buildVarRefExp(name, scopeStmt); + if(offset == 0) { + return iref; + } + else { + return SageBuilder::buildAddOp(iref, SageBuilder::buildIntVal(offset)); + } + } +} + +void MMPrefetchInsertion::initialize(const std::string& arrName, int hint) { + this->arrName = std::string(arrName); + this->cacheHint = hint; + this->indecies = std::vector<std::string*>(); + this->offsets = std::vector<int>(); + this->indexCount = 0; +} +void MMPrefetchInsertion::addDim(int offset) { + this->offsets.push_back(offset); + this->indecies.push_back(NULL); + this->indexCount++; +} +void MMPrefetchInsertion::addDim(int offset, const std::string& indexer) { + this->offsets.push_back(offset); + this->indecies.push_back(new std::string(indexer)); + this->indexCount++; +} +} diff --git a/omegalib/code_gen/src/tags b/omegalib/code_gen/src/tags new file mode 100644 index 0000000..a69c38b --- /dev/null +++ b/omegalib/code_gen/src/tags @@ -0,0 +1,158 @@ +!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/ +!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/ +!_TAG_PROGRAM_AUTHOR Darren Hiebert /dhiebert@users.sourceforge.net/ +!_TAG_PROGRAM_NAME Exuberant Ctags // +!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/ +!_TAG_PROGRAM_VERSION 5.8 // +CG_split CG.cc /^CG_split::CG_split(IntTuple &active, int lvl, const Relation &cond_, CG_result *T, CG_result *F) { $/;" f class:omega::CG_split +CG_stringRepr CG_stringRepr.cc /^CG_stringRepr::CG_stringRepr() {$/;" f class:omega::CG_stringRepr +CG_stringRepr CG_stringRepr.cc /^CG_stringRepr::CG_stringRepr(const std::string& _s) : s(_s) {$/;" f class:omega::CG_stringRepr +CG_suifRepr CG_suifRepr.cc /^CG_suifRepr::CG_suifRepr(): tnl_(NULL), op_() {$/;" f class:omega::CG_suifRepr +CG_suifRepr CG_suifRepr.cc /^CG_suifRepr::CG_suifRepr(operand op): tnl_(NULL), op_(op) {$/;" f class:omega::CG_suifRepr +CG_suifRepr CG_suifRepr.cc /^CG_suifRepr::CG_suifRepr(tree_node_list *tnl): tnl_(tnl),op_() {$/;" f class:omega::CG_suifRepr +CreateAnd CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateAnd(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateAnd CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateAnd(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateAssignment CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateAssignment(int indent, $/;" f class:omega::CG_stringBuilder +CreateAssignment CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateAssignment(int, CG_outputRepr *lhs,$/;" f class:omega::CG_suifBuilder +CreateComment CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateComment(int indent, const std::string &commentText) const {$/;" f class:omega::CG_stringBuilder +CreateComment CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateComment(int, const std::string &commentText) const {$/;" f class:omega::CG_suifBuilder +CreateEQ CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateEQ(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateEQ CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateEQ(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateGE CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateGE(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateGE CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateGE(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateIdent CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateIdent(const std::string &_s) const {$/;" f class:omega::CG_stringBuilder +CreateIdent CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateIdent(const std::string &_s) const {$/;" f class:omega::CG_suifBuilder +CreateIf CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateIf(int indent, CG_outputRepr* guardList,$/;" f class:omega::CG_stringBuilder +CreateIf CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateIf(int, CG_outputRepr *guardList,$/;" f class:omega::CG_suifBuilder +CreateInductive CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateInductive(CG_outputRepr* index,$/;" f class:omega::CG_stringBuilder +CreateInductive CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateInductive(CG_outputRepr *index,$/;" f class:omega::CG_suifBuilder +CreateInt CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateInt(int _i) const {$/;" f class:omega::CG_stringBuilder +CreateInt CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateInt(int _i) const {$/;" f class:omega::CG_suifBuilder +CreateIntegerCeil CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateIntegerCeil(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateIntegerDivide CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateIntegerDivide(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateIntegerDivide CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateIntegerDivide(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateIntegerMod CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateIntegerMod(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateIntegerMod CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateIntegerMod(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateInvoke CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateInvoke(const std::string &fname,$/;" f class:omega::CG_stringBuilder +CreateInvoke CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateInvoke(const std::string &fname,$/;" f class:omega::CG_suifBuilder +CreateLE CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateLE(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateLE CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateLE(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateLoop CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateLoop(int indent, CG_outputRepr* control,$/;" f class:omega::CG_stringBuilder +CreateLoop CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateLoop(int, CG_outputRepr *control,$/;" f class:omega::CG_suifBuilder +CreateMinus CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateMinus(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateMinus CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateMinus(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreatePlaceHolder CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreatePlaceHolder(int indent, CG_outputRepr *stmt,$/;" f class:omega::CG_stringBuilder +CreatePlaceHolder CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreatePlaceHolder (int, CG_outputRepr *stmt,$/;" f class:omega::CG_suifBuilder +CreatePlus CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreatePlus(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreatePlus CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreatePlus(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateTimes CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateTimes(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateTimes CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateTimes(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +Dump CG_stringRepr.cc /^void CG_stringRepr::Dump() const {$/;" f class:omega::CG_stringRepr +Dump CG_suifRepr.cc /^void CG_suifRepr::Dump() const {$/;" f class:omega::CG_suifRepr +DumpToFile CG_stringRepr.cc /^void CG_stringRepr::DumpToFile(FILE *fp) const {$/;" f class:omega::CG_stringRepr +DumpToFile CG_suifRepr.cc /^void CG_suifRepr::DumpToFile(FILE *fp) const {$/;" f class:omega::CG_suifRepr +GetCode CG_suifRepr.cc /^tree_node_list* CG_suifRepr::GetCode() const {$/;" f class:omega::CG_suifRepr +GetExpression CG_suifRepr.cc /^operand CG_suifRepr::GetExpression() const {$/;" f class:omega::CG_suifRepr +GetIndentSpaces CG_stringBuilder.cc /^std::string GetIndentSpaces(int indent) {$/;" f namespace:omega +GetString CG_stringBuilder.cc /^std::string GetString(CG_outputRepr* repr) {$/;" f namespace:omega +GetString CG_stringRepr.cc /^std::string CG_stringRepr::GetString() const { $/;" f class:omega::CG_stringRepr +JunkStaticInit code_gen.cc /^class JunkStaticInit{ public: JunkStaticInit(){ checkLoopLevel=0; fillInBounds=false;} };$/;" c namespace:omega file: +JunkStaticInit code_gen.cc /^class JunkStaticInit{ public: JunkStaticInit(){ checkLoopLevel=0; fillInBounds=false;} };$/;" f class:omega::JunkStaticInit +MMGenerateCode code_gen.cc /^CG_outputRepr* MMGenerateCode(CG_outputBuilder* ocg, RelTuple &T, SetTuple &old_IS, $/;" f namespace:omega +MMGenerateCode code_gen.cc /^CG_outputRepr* MMGenerateCode(CG_outputBuilder* ocg, RelTuple &T, SetTuple &old_IS, const Tuple<CG_outputRepr *> &stmt_content, Relation &known, int effort) {$/;" f namespace:omega +MMGenerateCode code_gen.cc /^std::string MMGenerateCode(RelTuple &T, SetTuple &old_IS, Relation &known, int effort) {$/;" f namespace:omega +SafeguardString CG_stringBuilder.cc /^static std::string SafeguardString(const std::string &s, char op) {$/;" f namespace:omega +StmtListAppend CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::StmtListAppend(CG_outputRepr* list1, CG_outputRepr* list2) const {$/;" f class:omega::CG_stringBuilder +StmtListAppend CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::StmtListAppend(CG_outputRepr *list1, $/;" f class:omega::CG_suifBuilder +boundHitsStride output_repr.cc /^bool boundHitsStride(const GEQ_Handle &g, Variable_ID v,$/;" f namespace:omega +checkLoopLevel code_gen.cc /^int checkLoopLevel;$/;" m namespace:omega file: +clear CG_suifRepr.cc /^void CG_suifRepr::clear() {$/;" f class:omega::CG_suifRepr +clone CG_stringRepr.cc /^CG_outputRepr* CG_stringRepr::clone() {$/;" f class:omega::CG_stringRepr +clone CG_suifRepr.cc /^CG_outputRepr* CG_suifRepr::clone() {$/;" f class:omega::CG_suifRepr +code_gen_debug code_gen.cc /^int code_gen_debug=0;$/;" m namespace:omega file: +countStrides output_repr.cc /^int countStrides(Conjunct *c, Variable_ID v, EQ_Handle &strideEQ, $/;" f namespace:omega +create_stride_on_bound output_repr.cc /^Relation create_stride_on_bound(int n, const std::map<Variable_ID, coef_t> &lb, coef_t stride) {$/;" f namespace:omega::__anon2 +exit_code_gen CG_suifBuilder.cc /^void exit_code_gen(void) {$/;" f namespace:omega +extract_function_symbols code_gen.cc /^RelTuple extract_function_symbols(SetTuple &sets) {$/;" f namespace:omega +fillInBounds code_gen.cc /^bool fillInBounds;$/;" m namespace:omega file: +filter_function_symbols code_gen.cc /^SetTuple filter_function_symbols(SetTuple &sets, bool keep_fs){$/;" f namespace:omega +findFloorInequality output_repr.cc /^bool findFloorInequality(Relation &r, Variable_ID v, GEQ_Handle &h, Variable_ID excluded) {$/;" f namespace:omega +findOverhead CG.cc /^Relation CG_leaf::findOverhead(int liftTo) {$/;" f class:omega::CG_leaf +findOverhead CG.cc /^Relation CG_loop::findOverhead(int liftTo) {$/;" f class:omega::CG_loop +findOverhead CG.cc /^Relation CG_split::findOverhead(int liftTo) {$/;" f class:omega::CG_split +find_any_constraint output_repr.cc /^bool find_any_constraint(int s, int level, Relation &kr, int direction,$/;" f namespace:omega +find_simplest_assignment output_repr.cc /^std::pair<EQ_Handle, int> find_simplest_assignment(const Relation &R_, Variable_ID v, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f namespace:omega +force_finite_bounds CG.cc /^CG_result * CG_loop::force_finite_bounds() {$/;" f class:omega::CG_loop +force_finite_bounds CG.cc /^CG_result * CG_split::force_finite_bounds() {$/;" f class:omega::CG_split +gen_recursive code_gen.cc /^CG_result *gen_recursive(int level, IntTuple &isActive) {$/;" f namespace:omega +get_stride output_repr.cc /^void get_stride(const Constraint_Handle &h, Variable_ID &wc, coef_t &step){$/;" f namespace:omega::__anon1 +greatest_common_step output_repr.cc /^Relation greatest_common_step(const Tuple<Relation> &I, const Tuple<int> &active, int level, const Relation &known) {$/;" f namespace:omega +hasBound output_repr.cc /^bool hasBound(Relation r, int level, int UB) {$/;" f namespace:omega +hasEQ output_repr.cc /^bool hasEQ(Relation r, int level) {$/;" f namespace:omega::__anon3 +has_nonstride_EQ output_repr.cc /^bool has_nonstride_EQ(Relation r, int level) {$/;" f namespace:omega +hoistGuard CG.cc /^Relation CG_leaf::hoistGuard() {$/;" f class:omega::CG_leaf +hoistGuard CG.cc /^Relation CG_loop::hoistGuard() {$/;" f class:omega::CG_loop +hoistGuard CG.cc /^Relation CG_split::hoistGuard() {$/;" f class:omega::CG_split +init_code_gen CG_suifBuilder.cc /^void init_code_gen(int&, char* []) {$/;" f namespace:omega +isSimpleStride output_repr.cc /^bool isSimpleStride(const EQ_Handle &g, Variable_ID v) {$/;" f namespace:omega +junkInitInstance__ code_gen.cc /^static JunkStaticInit junkInitInstance__;$/;" m namespace:omega file: +k_ocg_comment CG_suifBuilder.cc /^char *k_ocg_comment;$/;" m namespace:omega file: +last_level code_gen.cc /^int last_level;\/\/ Should not be global, but it is.$/;" m namespace:omega file: +libcode_gen_suif_string CG_suifBuilder.cc /^const char *libcode_gen_suif_string = "";$/;" m namespace:omega file: +libcode_gen_ver_string CG_suifBuilder.cc /^const char *libcode_gen_ver_string = "";$/;" m namespace:omega file: +libcode_gen_who_string CG_suifBuilder.cc /^const char *libcode_gen_who_string = "";$/;" m namespace:omega file: +liftOverhead CG.cc /^CG_result * CG_loop::liftOverhead(int depth) {$/;" f class:omega::CG_loop +liftOverhead CG.cc /^CG_result * CG_split::liftOverhead(int depth) {$/;" f class:omega::CG_split +loopIdxNames code_gen.cc /^Tuple< Tuple<std::string> > loopIdxNames;\/\/per stmt$/;" m namespace:omega file: +lowerBoundForLevel code_gen.cc /^int lowerBoundForLevel;$/;" m namespace:omega file: +max_fs_arity output_repr.cc /^int max_fs_arity(const Constraint_Handle &c) {$/;" f namespace:omega +minMaxOverhead output_repr.cc /^Relation minMaxOverhead(Relation r, int level) {$/;" f namespace:omega +new_IS code_gen.cc /^SetTuple new_IS;$/;" m namespace:omega file: +omega CG.cc /^namespace omega {$/;" n file: +omega CG_stringBuilder.cc /^namespace omega {$/;" n file: +omega CG_stringRepr.cc /^namespace omega {$/;" n file: +omega CG_suifBuilder.cc /^namespace omega {$/;" n file: +omega CG_suifRepr.cc /^namespace omega {$/;" n file: +omega code_gen.cc /^namespace omega {$/;" n file: +omega output_repr.cc /^namespace omega {$/;" n file: +outputAssignment output_repr.cc /^std::pair<CG_outputRepr *, bool> outputAssignment(CG_outputBuilder *ocg, const Relation &R_, Variable_ID v, Relation &enforced, CG_outputRepr *&if_repr, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f namespace:omega +outputBounds output_repr.cc /^std::pair<CG_outputRepr *, bool> outputBounds(CG_outputBuilder* ocg, const Relation &bounds, Variable_ID v, int indent, Relation &enforced, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f namespace:omega +outputEasyBoundAsRepr output_repr.cc /^CG_outputRepr* outputEasyBoundAsRepr(CG_outputBuilder* ocg, Relation &bounds,$/;" f namespace:omega +outputGuard output_repr.cc /^CG_outputRepr *outputGuard(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f namespace:omega +outputIdent output_repr.cc /^CG_outputRepr* outputIdent(CG_outputBuilder* ocg, const Relation &R_, Variable_ID v, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f namespace:omega +outputLBasRepr output_repr.cc /^CG_outputRepr *outputLBasRepr(CG_outputBuilder* ocg, const GEQ_Handle &g, $/;" f namespace:omega +outputStatement output_repr.cc /^CG_outputRepr* outputStatement(CG_outputBuilder *ocg, CG_outputRepr *stmt, int indent, const Relation &mapping_, const Relation &known_, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f namespace:omega +outputSubstitution output_repr.cc /^Tuple<CG_outputRepr*> outputSubstitution(CG_outputBuilder* ocg, const Relation &R_, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f namespace:omega +outputUBasRepr output_repr.cc /^CG_outputRepr *outputUBasRepr(CG_outputBuilder* ocg, const GEQ_Handle &g, $/;" f namespace:omega +output_EQ_strides output_repr.cc /^CG_outputRepr *output_EQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f namespace:omega +output_GEQ_strides output_repr.cc /^CG_outputRepr *output_GEQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f namespace:omega +output_as_guard output_repr.cc /^CG_outputRepr* output_as_guard(CG_outputBuilder* ocg, const Relation &guards_in, Constraint_Handle e, bool is_equality, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f namespace:omega +pickBound output_repr.cc /^Relation pickBound(Relation r, int level, int UB) {$/;" f namespace:omega::__anon3 +pickEQ output_repr.cc /^static Relation pickEQ(Relation r, int level) {$/;" f namespace:omega::__anon3 +pickOverhead output_repr.cc /^Relation pickOverhead(Relation r, int liftTo) {$/;" f namespace:omega +print CG.cc /^std::string CG_result::print(int indent) {$/;" f class:omega::CG_result +printRepr CG.cc /^CG_outputRepr* CG_leaf::printRepr(CG_outputBuilder* ocg, int indent, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f class:omega::CG_leaf +printRepr CG.cc /^CG_outputRepr* CG_loop::printRepr(CG_outputBuilder* ocg, int indent, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f class:omega::CG_loop +printRepr CG.cc /^CG_outputRepr* CG_split::printRepr(CG_outputBuilder* ocg, int indent, const std::vector<CG_outputRepr *> &assigned_on_the_fly) {$/;" f class:omega::CG_split +printStructure CG.cc /^std::string CG_leaf::printStructure(int) {$/;" f class:omega::CG_leaf +printStructure CG.cc /^std::string CG_loop::printStructure(int indent) {$/;" f class:omega::CG_loop +printStructure CG.cc /^std::string CG_split::printStructure(int indent) {$/;" f class:omega::CG_split +project_onto_levels output_repr.cc /^Relation project_onto_levels(Relation R, int last_level, bool wildcards) {$/;" f namespace:omega +projected_nIS code_gen.cc /^SetTupleTuple projected_nIS;$/;" m namespace:omega file: +recompute CG.cc /^CG_result * CG_loop::recompute(const Relation &k, const Relation &r) {$/;" f class:omega::CG_loop +recompute CG.cc /^CG_result * CG_split::recompute(const Relation &k, const Relation &r) {$/;" f class:omega::CG_split +recompute CG.cc /^CG_result* CG_leaf::recompute(const Relation &k, const Relation &r) {$/;" f class:omega::CG_leaf +removeGuard CG.cc /^void CG_leaf::removeGuard() {$/;" f class:omega::CG_leaf +smtNonSplitLevels code_gen.cc /^Tuple< IntTuple > smtNonSplitLevels;$/;" m namespace:omega file: +statementInfo code_gen.cc /^Tuple<CG_outputRepr *> statementInfo;$/;" m namespace:omega file: +stmtForLoopCheck code_gen.cc /^int stmtForLoopCheck;$/;" m namespace:omega file: +strip_function_symbols code_gen.cc /^RelTuple strip_function_symbols(SetTuple &sets) {$/;" f namespace:omega +substitute CG_suifBuilder.cc /^bool substitute(instruction *in, var_sym *sym, operand expr, base_symtab *st) {$/;" f namespace:omega +substitute CG_suifBuilder.cc /^bool substitute(tree_node *tn, var_sym *sym, operand expr, base_symtab *st) {$/;" f namespace:omega +substitute CG_suifBuilder.cc /^bool substitute(tree_node_list *tnl, var_sym *sym, operand expr,$/;" f namespace:omega +syncs code_gen.cc /^std::vector< std::pair<int, std::string> > syncs;$/;" m namespace:omega file: +transformations code_gen.cc /^RelTuple transformations;$/;" m namespace:omega file: +upperBoundForLevel code_gen.cc /^int upperBoundForLevel;$/;" m namespace:omega file: +var_substitution_threshold output_repr.cc /^int var_substitution_threshold = 4;$/;" m namespace:omega file: +~CG_stringRepr CG_stringRepr.cc /^CG_stringRepr::~CG_stringRepr() {$/;" f class:omega::CG_stringRepr +~CG_suifRepr CG_suifRepr.cc /^CG_suifRepr::~CG_suifRepr() {$/;" f class:omega::CG_suifRepr |