void SymbolSlab::Builder::insert(const Symbol &S) { auto R = SymbolIndex.try_emplace(S.ID, Symbols.size()); if (R.second) { Symbols.push_back(S); own(Symbols.back(), UniqueStrings); } else { auto &Copy = Symbols[R.first->second] = S; own(Copy, UniqueStrings); } }
expressionist( const string &op, unique_ptr<const abstract_mapper_base> &lhs, unique_ptr<const abstract_mapper_base> &rhs ) : #ifdef __clang__ _op(op.c_str()), #else _op(op), #endif _lhs(own(lhs)), _rhs(own(rhs)) {}
void table_base::specify_foreign_impl( unique_ptr<const abstract_mapper_base> foreign, const binomen &target_table, unique_ptr<const abstract_mapper_base> target_mapper ) { if (_is_open) throw table_open_exception(); _foreign_specs.emplace_back( &own(foreign), target_table, &own(target_mapper) ); }
vector<const abstract_mapper_base *> abstract_expressionist::own_all(vector<unique_ptr<const abstract_mapper_base>> &&v) { return transform( std::move(v), [this](unique_ptr<const abstract_mapper_base> &m) { return &own(m); } ); }
int main(int argc, char *argv[]) { if (argc < 2) { printf("Usage: %s <iface>\n", argv[0]); exit(1); } init_globals(); initscr(); cbreak(); noecho(); nonl(); intrflush(stdscr, FALSE); keypad(stdscr, TRUE); curs_set(0); clear(); refresh(); signal(SIGINT, cleanup); signal(SIGTERM, cleanup); own(argv[1]); cleanup(0); exit(0); }
expressionist(const string &op, unique_ptr<const abstract_mapper_base> &operand) : #ifdef __clang__ _op(op.c_str()), #else _op(op), #endif _operand(own(operand)) {}
int main() { char *x = malloc(2000); own(&x); x = malloc(1000); free(x); return 0; }
void diy::Collection:: clear() { if (own()) for (size_t i = 0; i < size(); ++i) destroy(i); elements_.clear(); external_.clear(); *in_memory_.access() = 0; }
SymbolSlab SymbolSlab::Builder::build() && { Symbols = {Symbols.begin(), Symbols.end()}; // Force shrink-to-fit. // Sort symbols so the slab can binary search over them. llvm::sort(Symbols, [](const Symbol &L, const Symbol &R) { return L.ID < R.ID; }); // We may have unused strings from overwritten symbols. Build a new arena. BumpPtrAllocator NewArena; UniqueStringSaver Strings(NewArena); for (auto &S : Symbols) own(S, Strings); return SymbolSlab(std::move(NewArena), std::move(Symbols)); }
void toBrowserSynonymWidget::changeParams(QString const& schema, QString const& object, QString const& type) { int pos = object.indexOf("."); QString own("PUBLIC"); QString name(object); if (pos >= 0) { own = object.mid(0, pos); name = object.mid(pos + 1); } toBrowserBaseWidget::changeParams(own, name); }
void table_base::specify_index_impl(bool is_unique, vector<unique_ptr<const abstract_mapper_base>> &&mappers) { if (_is_open) throw table_open_exception(); const index_spec spec( transform( std::move(mappers), [this](unique_ptr<const abstract_mapper_base> &m) { return &own(m); } ), is_unique ); if (! get_database().supports_index(spec)) throw unsupported_exception(); _index_specs.push_back(spec); }
int main(int argc, char *argv[]) { struct params p; char *iface = "wlan0"; char *tap = "tap0"; int ch; memset(&p, 0, sizeof(p)); memcpy(p.mac, "\x00\x00\xde\xfa\xce\xd", 6); p.seq = getpid(); memcpy(p.mcast, "\x01\x00\x5e\x00\x00", 5); while ((ch = getopt(argc, argv, "hb:t:")) != -1) { switch (ch) { case 't': tap = optarg; break; case 'b': if (str2mac(p.ap, optarg) == -1) { printf("Can't parse BSSID\n"); exit(1); } break; case 'h': default: usage(argv[0]); break; } } if ((p.rx = open_rx(iface)) == -1) err(1, "open_rx()"); if ((p.tx = open_tx(iface)) == -1) err(1, "open_tx()"); if ((p.tap = open_tap(tap)) == -1) err(1, "open_tap()"); if (set_iface_mac(tap, p.mac) == -1) err(1, "set_iface_mac()"); p.state = S_START; while (1) own(&p); exit(0); }
std::string type_name(){ using TR = typename std::remove_reference<T>; std::unique_ptr<char, void(*)(void*)> own( #ifndef __GNU__ nullptr, #else abi::__cxa_demangle(typeid(TR).name(), nullptr, nullptr, nullptr), #endif std::free ); std::string r = own ? own.get() : typeid(TR).name(); if (std::is_const<TR>::value)r += " const"; if (std::is_volatile<TR>::value)r += " volatile"; if (std::is_lvalue_reference<TR>::value)r += "&"; else if (std::is_rvalue_reference<TR>::value)r += "&&"; return r; }
exprn_mapper_base::exprn_mapper_base(unique_ptr<const abstract_expressionist> e) : abstract_mapper_base(boost::none), column_mapper(boost::none), _expressionist(&own(e)) {}
expressionist(unique_ptr<const abstract_mapper_base> &delegate) : _delegate(own(delegate)) {}
int main(int argc, char *argv[]) { own(); exit(0); }
int main(int argc, char * argv[]) { int policy; /* replacement policy */ int current; /* current page accessed */ FILE * fp; /* The file containing the page accesses */ FILE * rp; /* output file */ char filename[30]={""}; const char * extension[] ={".fifo", ".lru", "new"}; float num_accesses = 0.0; /* total number of page accesses */ float page_faults = 0.0; unsigned victim = 0; /* page to be replaced */ /* Getting and checking the input from the command line */ if(argc != 4) { printf("usage: pager policy size filename\n"); exit(1); } policy = atoi(argv[1]); mem_size = atoi(argv[2]); if( policy < 0 || policy > 2) { printf("policy must be 0, 1, or 2\n"); exit(1); } if(mem_size <= 0 ) { printf("Size must be a positive integer.\n"); exit(1); } /* Allocate and initialize the memory */ mem = (int *)calloc(mem_size, sizeof(int)); if(!mem) { printf("Cannot allocate mem\n"); exit(1); } /* open the memory access file */ fp = fopen(argv[3], "r"); if(!fp) { printf("Cannot open file %s\n", argv[3]); exit(1); } /* Create the output file */ strcat(filename, argv[3]); strcat(filename,extension[policy]); rp = fopen(filename, "w"); if(!rp) { printf("Cannot create file %s\n", filename); exit(1); } /* The main loop of the program */ fscanf(fp,"%d", ¤t); while(!feof(fp)) { num_accesses++; if(mem_check(current) == PAGEMISS) page_faults++; switch(policy) { case 0: if( IsFull()) { victim = fifo(); mem[victim] = current; } else insert(current); break; case 1: if( IsFull()) { victim = lru(); mem[victim] = current; } else insert(current); break; case 2: if( IsFull()) { victim = own(); mem[victim] = current; } else insert(current); break; default: printf("Unknown policy ... Exiting\n"); exit(1); }/* end switch-case */ print_mem(rp); fscanf(fp,"%d", ¤t); }/* end while */ fprintf(rp,"percentage of page faults = %f", page_faults/num_accesses); /* wrap-up */ fclose(fp); fclose(rp); free(mem); return 1; }
expressionist(unique_ptr<const abstract_mapper_base> &arg, column_type_finder ctf) : _arg(own(arg)), _ctf(ctf) {}
int main(int argc, char* argv[]) { int port = 6969; struct sockaddr_in s_in; int s; int rd; int len; char buf[64]; struct timeval tv; int do_it = 0; fd_set rfds; char ip[17]; if( argc > 1) pps = atoi(argv[1]); printf("Packets per second=%d\n", pps); s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); if( s < 0) err(1, "socket()"); s_in.sin_family = PF_INET; s_in.sin_port = htons(port); s_in.sin_addr.s_addr = INADDR_ANY; if( bind(s, (struct sockaddr*)&s_in, sizeof(s_in)) < 0) { perror("bind()"); exit(1); } while(1) { assert(do_it >= 0); len = sizeof(struct sockaddr_in); memset(&tv, 0, sizeof(tv)); tv.tv_usec = 1000*10; FD_ZERO(&rfds); FD_SET(s, &rfds); rd = select(s + 1, &rfds, NULL ,NULL ,&tv); if (rd == -1) { perror("select()"); exit(1); } if (rd == 1 && FD_ISSET(s, &rfds)) { rd = recvfrom(s, buf, 64, 0, (struct sockaddr*)&s_in, &len); if(rd < 0) { perror("read died"); exit(1); } if(rd == 5 && memcmp(buf, "sorbo", 5) == 0) { sprintf(ip, "%s", inet_ntoa(s_in.sin_addr)); printf("Got signal from %s\n", ip); #ifdef INSANE do_it = 10; #else do_it = 2; #endif } } if (do_it) { printf("Sending stuff to %s\n", ip); own(s, &s_in); do_it--; if(do_it == 0) printf("Stopping send\n"); } } }
expressionist(unique_ptr<const query_base> &query) : _query(own(query)) {}