1extern crate c2rust_bitfields;
2extern crate libc;
3extern crate core;
4
5extern "C" {
6 pub type RedisModuleCommand;
7 pub type clusterSlotToKeyMapping;
8 pub type clusterState;
9 fn sdsdup(s: sds) -> sds;
10 fn sdsfree(s: sds);
11 fn sdsfromlonglong(value: libc::c_longlong) -> sds;
12 fn qsort(
13 __base: *mut libc::c_void,
14 __nmemb: size_t,
15 __size: size_t,
16 __compar: __compar_fn_t,
17 );
18 fn memcpy(
19 _: *mut libc::c_void,
20 _: *const libc::c_void,
21 _: libc::c_ulong,
22 ) -> *mut libc::c_void;
23 fn dictGetIterator(d: *mut dict) -> *mut dictIterator;
24 fn strcasecmp(__s1: *const libc::c_char, __s2: *const libc::c_char) -> libc::c_int;
25 fn dictResize(d: *mut dict) -> libc::c_int;
26 fn dictCreate(type_0: *mut dictType) -> *mut dict;
27 fn dictExpand(d: *mut dict, size: libc::c_ulong) -> libc::c_int;
28 fn dictAdd(
29 d: *mut dict,
30 key: *mut libc::c_void,
31 val: *mut libc::c_void,
32 ) -> libc::c_int;
33 fn dictAddRaw(
34 d: *mut dict,
35 key: *mut libc::c_void,
36 existing: *mut *mut dictEntry,
37 ) -> *mut dictEntry;
38 fn dictDelete(d: *mut dict, key: *const libc::c_void) -> libc::c_int;
39 fn dictUnlink(d: *mut dict, key: *const libc::c_void) -> *mut dictEntry;
40 fn dictFreeUnlinkedEntry(d: *mut dict, he: *mut dictEntry);
41 fn dictRelease(d: *mut dict);
42 fn dictFind(d: *mut dict, key: *const libc::c_void) -> *mut dictEntry;
43 fn dictNext(iter: *mut dictIterator) -> *mut dictEntry;
44 fn dictReleaseIterator(iter: *mut dictIterator);
45 fn dictGetFairRandomKey(d: *mut dict) -> *mut dictEntry;
46 fn zmalloc(size: size_t) -> *mut libc::c_void;
47 fn zfree(ptr: *mut libc::c_void);
48 fn intsetAdd(is: *mut intset, value: int64_t, success: *mut uint8_t) -> *mut intset;
49 fn intsetRemove(
50 is: *mut intset,
51 value: int64_t,
52 success: *mut libc::c_int,
53 ) -> *mut intset;
54 fn intsetFind(is: *mut intset, value: int64_t) -> uint8_t;
55 fn intsetRandom(is: *mut intset) -> int64_t;
56 fn intsetGet(is: *mut intset, pos: uint32_t, value: *mut int64_t) -> uint8_t;
57 fn intsetLen(is: *const intset) -> uint32_t;
58 fn intsetBlobLen(is: *mut intset) -> size_t;
59 static mut server: redisServer;
60 static mut shared: sharedObjectsStruct;
61 static mut setDictType: dictType;
62 static mut sdsReplyDictType: dictType;
63 fn addReplyDeferredLen(c: *mut client) -> *mut libc::c_void;
64 fn setDeferredSetLen(c: *mut client, node: *mut libc::c_void, length: libc::c_long);
65 fn addReplyBulk(c: *mut client, obj: *mut robj);
66 fn addReplyBulkCBuffer(c: *mut client, p: *const libc::c_void, len: size_t);
67 fn addReplyBulkLongLong(c: *mut client, ll: libc::c_longlong);
68 fn addReply(c: *mut client, obj: *mut robj);
69 fn addReplyBulkSds(c: *mut client, s: sds);
70 fn addReplyErrorObject(c: *mut client, err: *mut robj);
71 fn addReplyError(c: *mut client, err: *const libc::c_char);
72 fn addReplyLongLong(c: *mut client, ll: libc::c_longlong);
73 fn addReplyArrayLen(c: *mut client, length: libc::c_long);
74 fn addReplySetLen(c: *mut client, length: libc::c_long);
75 fn rewriteClientCommandVector(c: *mut client, argc: libc::c_int, _: ...);
76 fn decrRefCount(o: *mut robj);
77 fn createObject(type_0: libc::c_int, ptr: *mut libc::c_void) -> *mut robj;
78 fn createStringObject(ptr: *const libc::c_char, len: size_t) -> *mut robj;
79 fn isSdsRepresentableAsLongLong(s: sds, llval: *mut libc::c_longlong) -> libc::c_int;
80 fn createStringObjectFromLongLong(value: libc::c_longlong) -> *mut robj;
81 fn createSetObject() -> *mut robj;
82 fn createIntsetObject() -> *mut robj;
83 fn getLongFromObjectOrReply(
84 c: *mut client,
85 o: *mut robj,
86 target: *mut libc::c_long,
87 msg: *const libc::c_char,
88 ) -> libc::c_int;
89 fn getPositiveLongFromObjectOrReply(
90 c: *mut client,
91 o: *mut robj,
92 target: *mut libc::c_long,
93 msg: *const libc::c_char,
94 ) -> libc::c_int;
95 fn getRangeLongFromObjectOrReply(
96 c: *mut client,
97 o: *mut robj,
98 min: libc::c_long,
99 max: libc::c_long,
100 target: *mut libc::c_long,
101 msg: *const libc::c_char,
102 ) -> libc::c_int;
103 fn checkType(c: *mut client, o: *mut robj, type_0: libc::c_int) -> libc::c_int;
104 fn alsoPropagate(
105 dbid: libc::c_int,
106 argv: *mut *mut robj,
107 argc: libc::c_int,
108 target: libc::c_int,
109 );
110 fn preventCommandPropagation(c: *mut client);
111 fn htNeedsResize(dict: *mut dict) -> libc::c_int;
112 fn _serverPanic(
113 file: *const libc::c_char,
114 line: libc::c_int,
115 msg: *const libc::c_char,
116 _: ...
117 );
118 fn _serverAssert(
119 estr: *const libc::c_char,
120 file: *const libc::c_char,
121 line: libc::c_int,
122 );
123 fn _serverAssertWithInfo(
124 c: *const client,
125 o: *const robj,
126 estr: *const libc::c_char,
127 file: *const libc::c_char,
128 line: libc::c_int,
129 );
130 fn notifyKeyspaceEvent(
131 type_0: libc::c_int,
132 event: *mut libc::c_char,
133 key: *mut robj,
134 dbid: libc::c_int,
135 );
136 fn lookupKeyRead(db: *mut redisDb, key: *mut robj) -> *mut robj;
137 fn lookupKeyWrite(db: *mut redisDb, key: *mut robj) -> *mut robj;
138 fn lookupKeyReadOrReply(
139 c: *mut client,
140 key: *mut robj,
141 reply: *mut robj,
142 ) -> *mut robj;
143 fn lookupKeyWriteOrReply(
144 c: *mut client,
145 key: *mut robj,
146 reply: *mut robj,
147 ) -> *mut robj;
148 fn dbAdd(db: *mut redisDb, key: *mut robj, val: *mut robj);
149 fn dbOverwrite(db: *mut redisDb, key: *mut robj, val: *mut robj);
150 fn setKey(
151 c: *mut client,
152 db: *mut redisDb,
153 key: *mut robj,
154 val: *mut robj,
155 flags: libc::c_int,
156 );
157 fn dbDelete(db: *mut redisDb, key: *mut robj) -> libc::c_int;
158 fn signalModifiedKey(c: *mut client, db: *mut redisDb, key: *mut robj);
159 fn scanGenericCommand(c: *mut client, o: *mut robj, cursor: libc::c_ulong);
160 fn parseScanCursorOrReply(
161 c: *mut client,
162 o: *mut robj,
163 cursor: *mut libc::c_ulong,
164 ) -> libc::c_int;
165 fn freeObjAsync(key: *mut robj, obj: *mut robj, dbid: libc::c_int);
166}
167pub type __int8_t = libc::c_schar;
168pub type __uint8_t = libc::c_uchar;
169pub type __int16_t = libc::c_short;
170pub type __uint16_t = libc::c_ushort;
171pub type __int32_t = libc::c_int;
172pub type __uint32_t = libc::c_uint;
173pub type __int64_t = libc::c_long;
174pub type __uint64_t = libc::c_ulong;
175pub type __uint_least64_t = __uint64_t;
176pub type __mode_t = libc::c_uint;
177pub type __off64_t = libc::c_long;
178pub type __pid_t = libc::c_int;
179pub type __time_t = libc::c_long;
180pub type __ssize_t = libc::c_long;
181pub type __sig_atomic_t = libc::c_int;
182pub type size_t = libc::c_ulong;
183#[derive(Copy, Clone)]
184#[repr(C)]
185pub struct iovec {
186 pub iov_base: *mut libc::c_void,
187 pub iov_len: size_t,
188}
189pub type mode_t = __mode_t;
190pub type off_t = __off64_t;
191pub type pid_t = __pid_t;
192pub type ssize_t = __ssize_t;
193pub type time_t = __time_t;
194pub type int8_t = __int8_t;
195pub type int16_t = __int16_t;
196pub type int32_t = __int32_t;
197pub type int64_t = __int64_t;
198pub type pthread_t = libc::c_ulong;
199pub type uint8_t = __uint8_t;
200pub type uint16_t = __uint16_t;
201pub type uint32_t = __uint32_t;
202pub type uint64_t = __uint64_t;
203pub type uint_least64_t = __uint_least64_t;
204pub type sds = *mut libc::c_char;
205#[derive(Copy, Clone)]
206#[repr(C, packed)]
207pub struct sdshdr8 {
208 pub len: uint8_t,
209 pub alloc: uint8_t,
210 pub flags: libc::c_uchar,
211 pub buf: [libc::c_char; 0],
212}
213#[derive(Copy, Clone)]
214#[repr(C, packed)]
215pub struct sdshdr16 {
216 pub len: uint16_t,
217 pub alloc: uint16_t,
218 pub flags: libc::c_uchar,
219 pub buf: [libc::c_char; 0],
220}
221#[derive(Copy, Clone)]
222#[repr(C, packed)]
223pub struct sdshdr32 {
224 pub len: uint32_t,
225 pub alloc: uint32_t,
226 pub flags: libc::c_uchar,
227 pub buf: [libc::c_char; 0],
228}
229#[derive(Copy, Clone)]
230#[repr(C, packed)]
231pub struct sdshdr64 {
232 pub len: uint64_t,
233 pub alloc: uint64_t,
234 pub flags: libc::c_uchar,
235 pub buf: [libc::c_char; 0],
236}
237#[derive(Copy, Clone)]
238#[repr(C)]
239pub struct aeEventLoop {
240 pub maxfd: libc::c_int,
241 pub setsize: libc::c_int,
242 pub timeEventNextId: libc::c_longlong,
243 pub events: *mut aeFileEvent,
244 pub fired: *mut aeFiredEvent,
245 pub timeEventHead: *mut aeTimeEvent,
246 pub stop: libc::c_int,
247 pub apidata: *mut libc::c_void,
248 pub beforesleep: Option::<aeBeforeSleepProc>,
249 pub aftersleep: Option::<aeBeforeSleepProc>,
250 pub flags: libc::c_int,
251}
252pub type aeBeforeSleepProc = unsafe extern "C" fn(*mut aeEventLoop) -> ();
253#[derive(Copy, Clone)]
254#[repr(C)]
255pub struct aeTimeEvent {
256 pub id: libc::c_longlong,
257 pub when: monotime,
258 pub timeProc: Option::<aeTimeProc>,
259 pub finalizerProc: Option::<aeEventFinalizerProc>,
260 pub clientData: *mut libc::c_void,
261 pub prev: *mut aeTimeEvent,
262 pub next: *mut aeTimeEvent,
263 pub refcount: libc::c_int,
264}
265pub type aeEventFinalizerProc = unsafe extern "C" fn(
266 *mut aeEventLoop,
267 *mut libc::c_void,
268) -> ();
269pub type aeTimeProc = unsafe extern "C" fn(
270 *mut aeEventLoop,
271 libc::c_longlong,
272 *mut libc::c_void,
273) -> libc::c_int;
274pub type monotime = uint64_t;
275#[derive(Copy, Clone)]
276#[repr(C)]
277pub struct aeFiredEvent {
278 pub fd: libc::c_int,
279 pub mask: libc::c_int,
280}
281#[derive(Copy, Clone)]
282#[repr(C)]
283pub struct aeFileEvent {
284 pub mask: libc::c_int,
285 pub rfileProc: Option::<aeFileProc>,
286 pub wfileProc: Option::<aeFileProc>,
287 pub clientData: *mut libc::c_void,
288}
289pub type aeFileProc = unsafe extern "C" fn(
290 *mut aeEventLoop,
291 libc::c_int,
292 *mut libc::c_void,
293 libc::c_int,
294) -> ();
295#[derive(Copy, Clone)]
296#[repr(C)]
297pub struct connection {
298 pub type_0: *mut ConnectionType,
299 pub state: ConnectionState,
300 pub flags: libc::c_short,
301 pub refs: libc::c_short,
302 pub last_errno: libc::c_int,
303 pub private_data: *mut libc::c_void,
304 pub conn_handler: ConnectionCallbackFunc,
305 pub write_handler: ConnectionCallbackFunc,
306 pub read_handler: ConnectionCallbackFunc,
307 pub fd: libc::c_int,
308}
309pub type ConnectionCallbackFunc = Option::<unsafe extern "C" fn(*mut connection) -> ()>;
310pub type ConnectionState = libc::c_uint;
311pub const CONN_STATE_ERROR: ConnectionState = 5;
312pub const CONN_STATE_CLOSED: ConnectionState = 4;
313pub const CONN_STATE_CONNECTED: ConnectionState = 3;
314pub const CONN_STATE_ACCEPTING: ConnectionState = 2;
315pub const CONN_STATE_CONNECTING: ConnectionState = 1;
316pub const CONN_STATE_NONE: ConnectionState = 0;
317#[derive(Copy, Clone)]
318#[repr(C)]
319pub struct ConnectionType {
320 pub ae_handler: Option::<
321 unsafe extern "C" fn(
322 *mut aeEventLoop,
323 libc::c_int,
324 *mut libc::c_void,
325 libc::c_int,
326 ) -> (),
327 >,
328 pub connect: Option::<
329 unsafe extern "C" fn(
330 *mut connection,
331 *const libc::c_char,
332 libc::c_int,
333 *const libc::c_char,
334 ConnectionCallbackFunc,
335 ) -> libc::c_int,
336 >,
337 pub write: Option::<
338 unsafe extern "C" fn(*mut connection, *const libc::c_void, size_t) -> libc::c_int,
339 >,
340 pub writev: Option::<
341 unsafe extern "C" fn(*mut connection, *const iovec, libc::c_int) -> libc::c_int,
342 >,
343 pub read: Option::<
344 unsafe extern "C" fn(*mut connection, *mut libc::c_void, size_t) -> libc::c_int,
345 >,
346 pub close: Option::<unsafe extern "C" fn(*mut connection) -> ()>,
347 pub accept: Option::<
348 unsafe extern "C" fn(*mut connection, ConnectionCallbackFunc) -> libc::c_int,
349 >,
350 pub set_write_handler: Option::<
351 unsafe extern "C" fn(
352 *mut connection,
353 ConnectionCallbackFunc,
354 libc::c_int,
355 ) -> libc::c_int,
356 >,
357 pub set_read_handler: Option::<
358 unsafe extern "C" fn(*mut connection, ConnectionCallbackFunc) -> libc::c_int,
359 >,
360 pub get_last_error: Option::<
361 unsafe extern "C" fn(*mut connection) -> *const libc::c_char,
362 >,
363 pub blocking_connect: Option::<
364 unsafe extern "C" fn(
365 *mut connection,
366 *const libc::c_char,
367 libc::c_int,
368 libc::c_longlong,
369 ) -> libc::c_int,
370 >,
371 pub sync_write: Option::<
372 unsafe extern "C" fn(
373 *mut connection,
374 *mut libc::c_char,
375 ssize_t,
376 libc::c_longlong,
377 ) -> ssize_t,
378 >,
379 pub sync_read: Option::<
380 unsafe extern "C" fn(
381 *mut connection,
382 *mut libc::c_char,
383 ssize_t,
384 libc::c_longlong,
385 ) -> ssize_t,
386 >,
387 pub sync_readline: Option::<
388 unsafe extern "C" fn(
389 *mut connection,
390 *mut libc::c_char,
391 ssize_t,
392 libc::c_longlong,
393 ) -> ssize_t,
394 >,
395 pub get_type: Option::<unsafe extern "C" fn(*mut connection) -> libc::c_int>,
396}
397#[derive(Copy, Clone,c2rust_bitfields:: BitfieldStruct)]
398#[repr(C)]
399pub struct redisObject {
400 #[bitfield(name = "type_0", ty = "libc::c_uint", bits = "0..=3")]
401 #[bitfield(name = "encoding", ty = "libc::c_uint", bits = "4..=7")]
402 #[bitfield(name = "lru", ty = "libc::c_uint", bits = "8..=31")]
403 pub type_0_encoding_lru: [u8; 4],
404 pub refcount: libc::c_int,
405 pub ptr: *mut libc::c_void,
406}
407pub type atomic_int = libc::c_int;
408pub type atomic_uint = libc::c_uint;
409pub type atomic_llong = libc::c_longlong;
410pub type __compar_fn_t = Option::<
411 unsafe extern "C" fn(*const libc::c_void, *const libc::c_void) -> libc::c_int,
412>;
413pub type sig_atomic_t = __sig_atomic_t;
414#[derive(Copy, Clone)]
415#[repr(C)]
416pub struct hdr_histogram {
417 pub lowest_discernible_value: int64_t,
418 pub highest_trackable_value: int64_t,
419 pub unit_magnitude: int32_t,
420 pub significant_figures: int32_t,
421 pub sub_bucket_half_count_magnitude: int32_t,
422 pub sub_bucket_half_count: int32_t,
423 pub sub_bucket_mask: int64_t,
424 pub sub_bucket_count: int32_t,
425 pub bucket_count: int32_t,
426 pub min_value: int64_t,
427 pub max_value: int64_t,
428 pub normalizing_index_offset: int32_t,
429 pub conversion_ratio: libc::c_double,
430 pub counts_len: int32_t,
431 pub total_count: int64_t,
432 pub counts: *mut int64_t,
433}
434pub type mstime_t = libc::c_longlong;
435pub type ustime_t = libc::c_longlong;
436#[derive(Copy, Clone)]
437#[repr(C)]
438pub struct dictEntry {
439 pub key: *mut libc::c_void,
440 pub v: C2RustUnnamed,
441 pub next: *mut dictEntry,
442 pub metadata: [*mut libc::c_void; 0],
443}
444#[derive(Copy, Clone)]
445#[repr(C)]
446pub union C2RustUnnamed {
447 pub val: *mut libc::c_void,
448 pub u64_0: uint64_t,
449 pub s64: int64_t,
450 pub d: libc::c_double,
451}
452#[derive(Copy, Clone)]
453#[repr(C)]
454pub struct dict {
455 pub type_0: *mut dictType,
456 pub ht_table: [*mut *mut dictEntry; 2],
457 pub ht_used: [libc::c_ulong; 2],
458 pub rehashidx: libc::c_long,
459 pub pauserehash: int16_t,
460 pub ht_size_exp: [libc::c_schar; 2],
461}
462#[derive(Copy, Clone)]
463#[repr(C)]
464pub struct dictType {
465 pub hashFunction: Option::<unsafe extern "C" fn(*const libc::c_void) -> uint64_t>,
466 pub keyDup: Option::<
467 unsafe extern "C" fn(*mut dict, *const libc::c_void) -> *mut libc::c_void,
468 >,
469 pub valDup: Option::<
470 unsafe extern "C" fn(*mut dict, *const libc::c_void) -> *mut libc::c_void,
471 >,
472 pub keyCompare: Option::<
473 unsafe extern "C" fn(
474 *mut dict,
475 *const libc::c_void,
476 *const libc::c_void,
477 ) -> libc::c_int,
478 >,
479 pub keyDestructor: Option::<
480 unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
481 >,
482 pub valDestructor: Option::<
483 unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
484 >,
485 pub expandAllowed: Option::<
486 unsafe extern "C" fn(size_t, libc::c_double) -> libc::c_int,
487 >,
488 pub dictEntryMetadataBytes: Option::<unsafe extern "C" fn(*mut dict) -> size_t>,
489}
490#[derive(Copy, Clone)]
491#[repr(C)]
492pub struct dictIterator {
493 pub d: *mut dict,
494 pub index: libc::c_long,
495 pub table: libc::c_int,
496 pub safe: libc::c_int,
497 pub entry: *mut dictEntry,
498 pub nextEntry: *mut dictEntry,
499 pub fingerprint: libc::c_ulonglong,
500}
501#[derive(Copy, Clone)]
502#[repr(C)]
503pub struct listNode {
504 pub prev: *mut listNode,
505 pub next: *mut listNode,
506 pub value: *mut libc::c_void,
507}
508#[derive(Copy, Clone)]
509#[repr(C)]
510pub struct list {
511 pub head: *mut listNode,
512 pub tail: *mut listNode,
513 pub dup: Option::<unsafe extern "C" fn(*mut libc::c_void) -> *mut libc::c_void>,
514 pub free: Option::<unsafe extern "C" fn(*mut libc::c_void) -> ()>,
515 pub match_0: Option::<
516 unsafe extern "C" fn(*mut libc::c_void, *mut libc::c_void) -> libc::c_int,
517 >,
518 pub len: libc::c_ulong,
519}
520#[derive(Copy, Clone)]
521#[repr(C)]
522pub struct intset {
523 pub encoding: uint32_t,
524 pub length: uint32_t,
525 pub contents: [int8_t; 0],
526}
527#[derive(Copy, Clone,c2rust_bitfields:: BitfieldStruct)]
528#[repr(C)]
529pub struct raxNode {
530 #[bitfield(name = "iskey", ty = "uint32_t", bits = "0..=0")]
531 #[bitfield(name = "isnull", ty = "uint32_t", bits = "1..=1")]
532 #[bitfield(name = "iscompr", ty = "uint32_t", bits = "2..=2")]
533 #[bitfield(name = "size", ty = "uint32_t", bits = "3..=31")]
534 pub iskey_isnull_iscompr_size: [u8; 4],
535 pub data: [libc::c_uchar; 0],
536}
537#[derive(Copy, Clone)]
538#[repr(C)]
539pub struct rax {
540 pub head: *mut raxNode,
541 pub numele: uint64_t,
542 pub numnodes: uint64_t,
543}
544pub type pause_type = libc::c_uint;
545pub const CLIENT_PAUSE_ALL: pause_type = 2;
546pub const CLIENT_PAUSE_WRITE: pause_type = 1;
547pub const CLIENT_PAUSE_OFF: pause_type = 0;
548#[derive(Copy, Clone)]
549#[repr(C)]
550pub struct pause_event {
551 pub type_0: pause_type,
552 pub end: mstime_t,
553}
554pub type robj = redisObject;
555pub type RedisModuleUserChangedFunc = Option::<
556 unsafe extern "C" fn(uint64_t, *mut libc::c_void) -> (),
557>;
558#[derive(Copy, Clone)]
559#[repr(C)]
560pub struct redisDb {
561 pub dict: *mut dict,
562 pub expires: *mut dict,
563 pub blocking_keys: *mut dict,
564 pub ready_keys: *mut dict,
565 pub watched_keys: *mut dict,
566 pub id: libc::c_int,
567 pub avg_ttl: libc::c_longlong,
568 pub expires_cursor: libc::c_ulong,
569 pub defrag_later: *mut list,
570 pub slots_to_keys: *mut clusterSlotToKeyMapping,
571}
572#[derive(Copy, Clone)]
573#[repr(C)]
574pub struct multiCmd {
575 pub argv: *mut *mut robj,
576 pub argv_len: libc::c_int,
577 pub argc: libc::c_int,
578 pub cmd: *mut redisCommand,
579}
580#[derive(Copy, Clone)]
581#[repr(C)]
582pub struct redisCommand {
583 pub declared_name: *const libc::c_char,
584 pub summary: *const libc::c_char,
585 pub complexity: *const libc::c_char,
586 pub since: *const libc::c_char,
587 pub doc_flags: libc::c_int,
588 pub replaced_by: *const libc::c_char,
589 pub deprecated_since: *const libc::c_char,
590 pub group: redisCommandGroup,
591 pub history: *mut commandHistory,
592 pub tips: *mut *const libc::c_char,
593 pub proc_0: Option::<redisCommandProc>,
594 pub arity: libc::c_int,
595 pub flags: uint64_t,
596 pub acl_categories: uint64_t,
597 pub key_specs_static: [keySpec; 4],
598 pub getkeys_proc: Option::<redisGetKeysProc>,
599 pub subcommands: *mut redisCommand,
600 pub args: *mut redisCommandArg,
601 pub microseconds: libc::c_longlong,
602 pub calls: libc::c_longlong,
603 pub rejected_calls: libc::c_longlong,
604 pub failed_calls: libc::c_longlong,
605 pub id: libc::c_int,
606 pub fullname: sds,
607 pub latency_histogram: *mut hdr_histogram,
608 pub key_specs: *mut keySpec,
609 pub legacy_range_key_spec: keySpec,
610 pub num_args: libc::c_int,
611 pub num_history: libc::c_int,
612 pub num_tips: libc::c_int,
613 pub key_specs_num: libc::c_int,
614 pub key_specs_max: libc::c_int,
615 pub subcommands_dict: *mut dict,
616 pub parent: *mut redisCommand,
617 pub module_cmd: *mut RedisModuleCommand,
618}
619#[derive(Copy, Clone)]
620#[repr(C)]
621pub struct keySpec {
622 pub notes: *const libc::c_char,
623 pub flags: uint64_t,
624 pub begin_search_type: kspec_bs_type,
625 pub bs: C2RustUnnamed_3,
626 pub find_keys_type: kspec_fk_type,
627 pub fk: C2RustUnnamed_0,
628}
629#[derive(Copy, Clone)]
630#[repr(C)]
631pub union C2RustUnnamed_0 {
632 pub range: C2RustUnnamed_2,
633 pub keynum: C2RustUnnamed_1,
634}
635#[derive(Copy, Clone)]
636#[repr(C)]
637pub struct C2RustUnnamed_1 {
638 pub keynumidx: libc::c_int,
639 pub firstkey: libc::c_int,
640 pub keystep: libc::c_int,
641}
642#[derive(Copy, Clone)]
643#[repr(C)]
644pub struct C2RustUnnamed_2 {
645 pub lastkey: libc::c_int,
646 pub keystep: libc::c_int,
647 pub limit: libc::c_int,
648}
649pub type kspec_fk_type = libc::c_uint;
650pub const KSPEC_FK_KEYNUM: kspec_fk_type = 3;
651pub const KSPEC_FK_RANGE: kspec_fk_type = 2;
652pub const KSPEC_FK_UNKNOWN: kspec_fk_type = 1;
653pub const KSPEC_FK_INVALID: kspec_fk_type = 0;
654#[derive(Copy, Clone)]
655#[repr(C)]
656pub union C2RustUnnamed_3 {
657 pub index: C2RustUnnamed_5,
658 pub keyword: C2RustUnnamed_4,
659}
660#[derive(Copy, Clone)]
661#[repr(C)]
662pub struct C2RustUnnamed_4 {
663 pub keyword: *const libc::c_char,
664 pub startfrom: libc::c_int,
665}
666#[derive(Copy, Clone)]
667#[repr(C)]
668pub struct C2RustUnnamed_5 {
669 pub pos: libc::c_int,
670}
671pub type kspec_bs_type = libc::c_uint;
672pub const KSPEC_BS_KEYWORD: kspec_bs_type = 3;
673pub const KSPEC_BS_INDEX: kspec_bs_type = 2;
674pub const KSPEC_BS_UNKNOWN: kspec_bs_type = 1;
675pub const KSPEC_BS_INVALID: kspec_bs_type = 0;
676#[derive(Copy, Clone)]
677#[repr(C)]
678pub struct redisCommandArg {
679 pub name: *const libc::c_char,
680 pub type_0: redisCommandArgType,
681 pub key_spec_index: libc::c_int,
682 pub token: *const libc::c_char,
683 pub summary: *const libc::c_char,
684 pub since: *const libc::c_char,
685 pub flags: libc::c_int,
686 pub deprecated_since: *const libc::c_char,
687 pub subargs: *mut redisCommandArg,
688 pub num_args: libc::c_int,
689}
690pub type redisCommandArgType = libc::c_uint;
691pub const ARG_TYPE_BLOCK: redisCommandArgType = 8;
692pub const ARG_TYPE_ONEOF: redisCommandArgType = 7;
693pub const ARG_TYPE_PURE_TOKEN: redisCommandArgType = 6;
694pub const ARG_TYPE_UNIX_TIME: redisCommandArgType = 5;
695pub const ARG_TYPE_PATTERN: redisCommandArgType = 4;
696pub const ARG_TYPE_KEY: redisCommandArgType = 3;
697pub const ARG_TYPE_DOUBLE: redisCommandArgType = 2;
698pub const ARG_TYPE_INTEGER: redisCommandArgType = 1;
699pub const ARG_TYPE_STRING: redisCommandArgType = 0;
700pub type redisGetKeysProc = unsafe extern "C" fn(
701 *mut redisCommand,
702 *mut *mut robj,
703 libc::c_int,
704 *mut getKeysResult,
705) -> libc::c_int;
706#[derive(Copy, Clone)]
707#[repr(C)]
708pub struct getKeysResult {
709 pub keysbuf: [keyReference; 256],
710 pub keys: *mut keyReference,
711 pub numkeys: libc::c_int,
712 pub size: libc::c_int,
713}
714#[derive(Copy, Clone)]
715#[repr(C)]
716pub struct keyReference {
717 pub pos: libc::c_int,
718 pub flags: libc::c_int,
719}
720pub type redisCommandProc = unsafe extern "C" fn(*mut client) -> ();
721#[derive(Copy, Clone)]
722#[repr(C)]
723pub struct client {
724 pub id: uint64_t,
725 pub flags: uint64_t,
726 pub conn: *mut connection,
727 pub resp: libc::c_int,
728 pub db: *mut redisDb,
729 pub name: *mut robj,
730 pub querybuf: sds,
731 pub qb_pos: size_t,
732 pub querybuf_peak: size_t,
733 pub argc: libc::c_int,
734 pub argv: *mut *mut robj,
735 pub argv_len: libc::c_int,
736 pub original_argc: libc::c_int,
737 pub original_argv: *mut *mut robj,
738 pub argv_len_sum: size_t,
739 pub cmd: *mut redisCommand,
740 pub lastcmd: *mut redisCommand,
741 pub realcmd: *mut redisCommand,
742 pub user: *mut user,
743 pub reqtype: libc::c_int,
744 pub multibulklen: libc::c_int,
745 pub bulklen: libc::c_long,
746 pub reply: *mut list,
747 pub reply_bytes: libc::c_ulonglong,
748 pub deferred_reply_errors: *mut list,
749 pub sentlen: size_t,
750 pub ctime: time_t,
751 pub duration: libc::c_long,
752 pub slot: libc::c_int,
753 pub cur_script: *mut dictEntry,
754 pub lastinteraction: time_t,
755 pub obuf_soft_limit_reached_time: time_t,
756 pub authenticated: libc::c_int,
757 pub replstate: libc::c_int,
758 pub repl_start_cmd_stream_on_ack: libc::c_int,
759 pub repldbfd: libc::c_int,
760 pub repldboff: off_t,
761 pub repldbsize: off_t,
762 pub replpreamble: sds,
763 pub read_reploff: libc::c_longlong,
764 pub reploff: libc::c_longlong,
765 pub repl_applied: libc::c_longlong,
766 pub repl_ack_off: libc::c_longlong,
767 pub repl_ack_time: libc::c_longlong,
768 pub repl_last_partial_write: libc::c_longlong,
769 pub psync_initial_offset: libc::c_longlong,
770 pub replid: [libc::c_char; 41],
771 pub slave_listening_port: libc::c_int,
772 pub slave_addr: *mut libc::c_char,
773 pub slave_capa: libc::c_int,
774 pub slave_req: libc::c_int,
775 pub mstate: multiState,
776 pub btype: libc::c_int,
777 pub bpop: blockingState,
778 pub woff: libc::c_longlong,
779 pub watched_keys: *mut list,
780 pub pubsub_channels: *mut dict,
781 pub pubsub_patterns: *mut list,
782 pub pubsubshard_channels: *mut dict,
783 pub peerid: sds,
784 pub sockname: sds,
785 pub client_list_node: *mut listNode,
786 pub postponed_list_node: *mut listNode,
787 pub pending_read_list_node: *mut listNode,
788 pub auth_callback: RedisModuleUserChangedFunc,
789 pub auth_callback_privdata: *mut libc::c_void,
790 pub auth_module: *mut libc::c_void,
791 pub client_tracking_redirection: uint64_t,
792 pub client_tracking_prefixes: *mut rax,
793 pub last_memory_usage: size_t,
794 pub last_memory_type: libc::c_int,
795 pub mem_usage_bucket_node: *mut listNode,
796 pub mem_usage_bucket: *mut clientMemUsageBucket,
797 pub ref_repl_buf_node: *mut listNode,
798 pub ref_block_pos: size_t,
799 pub buf_peak: size_t,
800 pub buf_peak_last_reset_time: mstime_t,
801 pub bufpos: libc::c_int,
802 pub buf_usable_size: size_t,
803 pub buf: *mut libc::c_char,
804}
805#[derive(Copy, Clone)]
806#[repr(C)]
807pub struct clientMemUsageBucket {
808 pub clients: *mut list,
809 pub mem_usage_sum: size_t,
810}
811#[derive(Copy, Clone)]
812#[repr(C)]
813pub struct blockingState {
814 pub count: libc::c_long,
815 pub timeout: mstime_t,
816 pub keys: *mut dict,
817 pub target: *mut robj,
818 pub blockpos: blockPos,
819 pub xread_count: size_t,
820 pub xread_group: *mut robj,
821 pub xread_consumer: *mut robj,
822 pub xread_group_noack: libc::c_int,
823 pub numreplicas: libc::c_int,
824 pub reploffset: libc::c_longlong,
825 pub module_blocked_handle: *mut libc::c_void,
826}
827#[derive(Copy, Clone)]
828#[repr(C)]
829pub struct blockPos {
830 pub wherefrom: libc::c_int,
831 pub whereto: libc::c_int,
832}
833#[derive(Copy, Clone)]
834#[repr(C)]
835pub struct multiState {
836 pub commands: *mut multiCmd,
837 pub count: libc::c_int,
838 pub cmd_flags: libc::c_int,
839 pub cmd_inv_flags: libc::c_int,
840 pub argv_len_sums: size_t,
841 pub alloc_count: libc::c_int,
842}
843#[derive(Copy, Clone)]
844#[repr(C)]
845pub struct user {
846 pub name: sds,
847 pub flags: uint32_t,
848 pub passwords: *mut list,
849 pub selectors: *mut list,
850 pub acl_string: *mut robj,
851}
852#[derive(Copy, Clone)]
853#[repr(C)]
854pub struct commandHistory {
855 pub since: *const libc::c_char,
856 pub changes: *const libc::c_char,
857}
858pub type redisCommandGroup = libc::c_uint;
859pub const COMMAND_GROUP_MODULE: redisCommandGroup = 17;
860pub const COMMAND_GROUP_BITMAP: redisCommandGroup = 16;
861pub const COMMAND_GROUP_STREAM: redisCommandGroup = 15;
862pub const COMMAND_GROUP_GEO: redisCommandGroup = 14;
863pub const COMMAND_GROUP_SENTINEL: redisCommandGroup = 13;
864pub const COMMAND_GROUP_CLUSTER: redisCommandGroup = 12;
865pub const COMMAND_GROUP_HYPERLOGLOG: redisCommandGroup = 11;
866pub const COMMAND_GROUP_SCRIPTING: redisCommandGroup = 10;
867pub const COMMAND_GROUP_SERVER: redisCommandGroup = 9;
868pub const COMMAND_GROUP_CONNECTION: redisCommandGroup = 8;
869pub const COMMAND_GROUP_TRANSACTIONS: redisCommandGroup = 7;
870pub const COMMAND_GROUP_PUBSUB: redisCommandGroup = 6;
871pub const COMMAND_GROUP_HASH: redisCommandGroup = 5;
872pub const COMMAND_GROUP_SORTED_SET: redisCommandGroup = 4;
873pub const COMMAND_GROUP_SET: redisCommandGroup = 3;
874pub const COMMAND_GROUP_LIST: redisCommandGroup = 2;
875pub const COMMAND_GROUP_STRING: redisCommandGroup = 1;
876pub const COMMAND_GROUP_GENERIC: redisCommandGroup = 0;
877#[derive(Copy, Clone)]
878#[repr(C)]
879pub struct replBacklog {
880 pub ref_repl_buf_node: *mut listNode,
881 pub unindexed_count: size_t,
882 pub blocks_index: *mut rax,
883 pub histlen: libc::c_longlong,
884 pub offset: libc::c_longlong,
885}
886#[derive(Copy, Clone)]
887#[repr(C)]
888pub struct saveparam {
889 pub seconds: time_t,
890 pub changes: libc::c_int,
891}
892#[derive(Copy, Clone)]
893#[repr(C)]
894pub struct sentinelConfig {
895 pub pre_monitor_cfg: *mut list,
896 pub monitor_cfg: *mut list,
897 pub post_monitor_cfg: *mut list,
898}
899#[derive(Copy, Clone)]
900#[repr(C)]
901pub struct sharedObjectsStruct {
902 pub crlf: *mut robj,
903 pub ok: *mut robj,
904 pub err: *mut robj,
905 pub emptybulk: *mut robj,
906 pub czero: *mut robj,
907 pub cone: *mut robj,
908 pub pong: *mut robj,
909 pub space: *mut robj,
910 pub queued: *mut robj,
911 pub null: [*mut robj; 4],
912 pub nullarray: [*mut robj; 4],
913 pub emptymap: [*mut robj; 4],
914 pub emptyset: [*mut robj; 4],
915 pub emptyarray: *mut robj,
916 pub wrongtypeerr: *mut robj,
917 pub nokeyerr: *mut robj,
918 pub syntaxerr: *mut robj,
919 pub sameobjecterr: *mut robj,
920 pub outofrangeerr: *mut robj,
921 pub noscripterr: *mut robj,
922 pub loadingerr: *mut robj,
923 pub slowevalerr: *mut robj,
924 pub slowscripterr: *mut robj,
925 pub slowmoduleerr: *mut robj,
926 pub bgsaveerr: *mut robj,
927 pub masterdownerr: *mut robj,
928 pub roslaveerr: *mut robj,
929 pub execaborterr: *mut robj,
930 pub noautherr: *mut robj,
931 pub noreplicaserr: *mut robj,
932 pub busykeyerr: *mut robj,
933 pub oomerr: *mut robj,
934 pub plus: *mut robj,
935 pub messagebulk: *mut robj,
936 pub pmessagebulk: *mut robj,
937 pub subscribebulk: *mut robj,
938 pub unsubscribebulk: *mut robj,
939 pub psubscribebulk: *mut robj,
940 pub punsubscribebulk: *mut robj,
941 pub del: *mut robj,
942 pub unlink: *mut robj,
943 pub rpop: *mut robj,
944 pub lpop: *mut robj,
945 pub lpush: *mut robj,
946 pub rpoplpush: *mut robj,
947 pub lmove: *mut robj,
948 pub blmove: *mut robj,
949 pub zpopmin: *mut robj,
950 pub zpopmax: *mut robj,
951 pub emptyscan: *mut robj,
952 pub multi: *mut robj,
953 pub exec: *mut robj,
954 pub left: *mut robj,
955 pub right: *mut robj,
956 pub hset: *mut robj,
957 pub srem: *mut robj,
958 pub xgroup: *mut robj,
959 pub xclaim: *mut robj,
960 pub script: *mut robj,
961 pub replconf: *mut robj,
962 pub eval: *mut robj,
963 pub persist: *mut robj,
964 pub set: *mut robj,
965 pub pexpireat: *mut robj,
966 pub pexpire: *mut robj,
967 pub time: *mut robj,
968 pub pxat: *mut robj,
969 pub absttl: *mut robj,
970 pub retrycount: *mut robj,
971 pub force: *mut robj,
972 pub justid: *mut robj,
973 pub entriesread: *mut robj,
974 pub lastid: *mut robj,
975 pub ping: *mut robj,
976 pub setid: *mut robj,
977 pub keepttl: *mut robj,
978 pub load: *mut robj,
979 pub createconsumer: *mut robj,
980 pub getack: *mut robj,
981 pub special_asterick: *mut robj,
982 pub special_equals: *mut robj,
983 pub default_username: *mut robj,
984 pub redacted: *mut robj,
985 pub ssubscribebulk: *mut robj,
986 pub sunsubscribebulk: *mut robj,
987 pub smessagebulk: *mut robj,
988 pub select: [*mut robj; 10],
989 pub integers: [*mut robj; 10000],
990 pub mbulkhdr: [*mut robj; 32],
991 pub bulkhdr: [*mut robj; 32],
992 pub maphdr: [*mut robj; 32],
993 pub sethdr: [*mut robj; 32],
994 pub minstring: sds,
995 pub maxstring: sds,
996}
997#[derive(Copy, Clone)]
998#[repr(C)]
999pub struct clientBufferLimitsConfig {
1000 pub hard_limit_bytes: libc::c_ulonglong,
1001 pub soft_limit_bytes: libc::c_ulonglong,
1002 pub soft_limit_seconds: time_t,
1003}
1004#[derive(Copy, Clone)]
1005#[repr(C)]
1006pub struct redisOp {
1007 pub argv: *mut *mut robj,
1008 pub argc: libc::c_int,
1009 pub dbid: libc::c_int,
1010 pub target: libc::c_int,
1011}
1012#[derive(Copy, Clone)]
1013#[repr(C)]
1014pub struct redisOpArray {
1015 pub ops: *mut redisOp,
1016 pub numops: libc::c_int,
1017 pub capacity: libc::c_int,
1018}
1019#[derive(Copy, Clone)]
1020#[repr(C)]
1021pub struct malloc_stats {
1022 pub zmalloc_used: size_t,
1023 pub process_rss: size_t,
1024 pub allocator_allocated: size_t,
1025 pub allocator_active: size_t,
1026 pub allocator_resident: size_t,
1027}
1028#[derive(Copy, Clone)]
1029#[repr(C)]
1030pub struct socketFds {
1031 pub fd: [libc::c_int; 16],
1032 pub count: libc::c_int,
1033}
1034#[derive(Copy, Clone)]
1035#[repr(C)]
1036pub struct redisTLSContextConfig {
1037 pub cert_file: *mut libc::c_char,
1038 pub key_file: *mut libc::c_char,
1039 pub key_file_pass: *mut libc::c_char,
1040 pub client_cert_file: *mut libc::c_char,
1041 pub client_key_file: *mut libc::c_char,
1042 pub client_key_file_pass: *mut libc::c_char,
1043 pub dh_params_file: *mut libc::c_char,
1044 pub ca_cert_file: *mut libc::c_char,
1045 pub ca_cert_dir: *mut libc::c_char,
1046 pub protocols: *mut libc::c_char,
1047 pub ciphers: *mut libc::c_char,
1048 pub ciphersuites: *mut libc::c_char,
1049 pub prefer_server_ciphers: libc::c_int,
1050 pub session_caching: libc::c_int,
1051 pub session_cache_size: libc::c_int,
1052 pub session_cache_timeout: libc::c_int,
1053}
1054pub type aof_file_type = libc::c_uint;
1055pub const AOF_FILE_TYPE_INCR: aof_file_type = 105;
1056pub const AOF_FILE_TYPE_HIST: aof_file_type = 104;
1057pub const AOF_FILE_TYPE_BASE: aof_file_type = 98;
1058#[derive(Copy, Clone)]
1059#[repr(C)]
1060pub struct aofInfo {
1061 pub file_name: sds,
1062 pub file_seq: libc::c_longlong,
1063 pub file_type: aof_file_type,
1064}
1065#[derive(Copy, Clone)]
1066#[repr(C)]
1067pub struct aofManifest {
1068 pub base_aof_info: *mut aofInfo,
1069 pub incr_aof_list: *mut list,
1070 pub history_aof_list: *mut list,
1071 pub curr_base_file_seq: libc::c_longlong,
1072 pub curr_incr_file_seq: libc::c_longlong,
1073 pub dirty: libc::c_int,
1074}
1075#[derive(Copy, Clone)]
1076#[repr(C)]
1077pub struct redisServer {
1078 pub pid: pid_t,
1079 pub main_thread_id: pthread_t,
1080 pub configfile: *mut libc::c_char,
1081 pub executable: *mut libc::c_char,
1082 pub exec_argv: *mut *mut libc::c_char,
1083 pub dynamic_hz: libc::c_int,
1084 pub config_hz: libc::c_int,
1085 pub umask: mode_t,
1086 pub hz: libc::c_int,
1087 pub in_fork_child: libc::c_int,
1088 pub db: *mut redisDb,
1089 pub commands: *mut dict,
1090 pub orig_commands: *mut dict,
1091 pub el: *mut aeEventLoop,
1092 pub errors: *mut rax,
1093 pub lruclock: atomic_uint,
1094 pub shutdown_asap: sig_atomic_t,
1095 pub shutdown_mstime: mstime_t,
1096 pub last_sig_received: libc::c_int,
1097 pub shutdown_flags: libc::c_int,
1098 pub activerehashing: libc::c_int,
1099 pub active_defrag_running: libc::c_int,
1100 pub pidfile: *mut libc::c_char,
1101 pub arch_bits: libc::c_int,
1102 pub cronloops: libc::c_int,
1103 pub runid: [libc::c_char; 41],
1104 pub sentinel_mode: libc::c_int,
1105 pub initial_memory_usage: size_t,
1106 pub always_show_logo: libc::c_int,
1107 pub in_exec: libc::c_int,
1108 pub busy_module_yield_flags: libc::c_int,
1109 pub busy_module_yield_reply: *const libc::c_char,
1110 pub core_propagates: libc::c_int,
1111 pub propagate_no_multi: libc::c_int,
1112 pub module_ctx_nesting: libc::c_int,
1113 pub ignore_warnings: *mut libc::c_char,
1114 pub client_pause_in_transaction: libc::c_int,
1115 pub thp_enabled: libc::c_int,
1116 pub page_size: size_t,
1117 pub moduleapi: *mut dict,
1118 pub sharedapi: *mut dict,
1119 pub module_configs_queue: *mut dict,
1120 pub loadmodule_queue: *mut list,
1121 pub module_pipe: [libc::c_int; 2],
1122 pub child_pid: pid_t,
1123 pub child_type: libc::c_int,
1124 pub port: libc::c_int,
1125 pub tls_port: libc::c_int,
1126 pub tcp_backlog: libc::c_int,
1127 pub bindaddr: [*mut libc::c_char; 16],
1128 pub bindaddr_count: libc::c_int,
1129 pub bind_source_addr: *mut libc::c_char,
1130 pub unixsocket: *mut libc::c_char,
1131 pub unixsocketperm: libc::c_uint,
1132 pub ipfd: socketFds,
1133 pub tlsfd: socketFds,
1134 pub sofd: libc::c_int,
1135 pub socket_mark_id: uint32_t,
1136 pub cfd: socketFds,
1137 pub clients: *mut list,
1138 pub clients_to_close: *mut list,
1139 pub clients_pending_write: *mut list,
1140 pub clients_pending_read: *mut list,
1141 pub slaves: *mut list,
1142 pub monitors: *mut list,
1143 pub current_client: *mut client,
1144 pub client_mem_usage_buckets: *mut clientMemUsageBucket,
1145 pub clients_timeout_table: *mut rax,
1146 pub fixed_time_expire: libc::c_long,
1147 pub in_nested_call: libc::c_int,
1148 pub clients_index: *mut rax,
1149 pub client_pause_type: pause_type,
1150 pub postponed_clients: *mut list,
1151 pub client_pause_end_time: mstime_t,
1152 pub client_pause_per_purpose: [*mut pause_event; 3],
1153 pub neterr: [libc::c_char; 256],
1154 pub migrate_cached_sockets: *mut dict,
1155 pub next_client_id: uint_least64_t,
1156 pub protected_mode: libc::c_int,
1157 pub io_threads_num: libc::c_int,
1158 pub io_threads_do_reads: libc::c_int,
1159 pub io_threads_active: libc::c_int,
1160 pub events_processed_while_blocked: libc::c_longlong,
1161 pub enable_protected_configs: libc::c_int,
1162 pub enable_debug_cmd: libc::c_int,
1163 pub enable_module_cmd: libc::c_int,
1164 pub loading: sig_atomic_t,
1165 pub async_loading: sig_atomic_t,
1166 pub loading_total_bytes: off_t,
1167 pub loading_rdb_used_mem: off_t,
1168 pub loading_loaded_bytes: off_t,
1169 pub loading_start_time: time_t,
1170 pub loading_process_events_interval_bytes: off_t,
1171 pub stat_starttime: time_t,
1172 pub stat_numcommands: libc::c_longlong,
1173 pub stat_numconnections: libc::c_longlong,
1174 pub stat_expiredkeys: libc::c_longlong,
1175 pub stat_expired_stale_perc: libc::c_double,
1176 pub stat_expired_time_cap_reached_count: libc::c_longlong,
1177 pub stat_expire_cycle_time_used: libc::c_longlong,
1178 pub stat_evictedkeys: libc::c_longlong,
1179 pub stat_evictedclients: libc::c_longlong,
1180 pub stat_total_eviction_exceeded_time: libc::c_longlong,
1181 pub stat_last_eviction_exceeded_time: monotime,
1182 pub stat_keyspace_hits: libc::c_longlong,
1183 pub stat_keyspace_misses: libc::c_longlong,
1184 pub stat_active_defrag_hits: libc::c_longlong,
1185 pub stat_active_defrag_misses: libc::c_longlong,
1186 pub stat_active_defrag_key_hits: libc::c_longlong,
1187 pub stat_active_defrag_key_misses: libc::c_longlong,
1188 pub stat_active_defrag_scanned: libc::c_longlong,
1189 pub stat_total_active_defrag_time: libc::c_longlong,
1190 pub stat_last_active_defrag_time: monotime,
1191 pub stat_peak_memory: size_t,
1192 pub stat_aof_rewrites: libc::c_longlong,
1193 pub stat_aofrw_consecutive_failures: libc::c_longlong,
1194 pub stat_rdb_saves: libc::c_longlong,
1195 pub stat_fork_time: libc::c_longlong,
1196 pub stat_fork_rate: libc::c_double,
1197 pub stat_total_forks: libc::c_longlong,
1198 pub stat_rejected_conn: libc::c_longlong,
1199 pub stat_sync_full: libc::c_longlong,
1200 pub stat_sync_partial_ok: libc::c_longlong,
1201 pub stat_sync_partial_err: libc::c_longlong,
1202 pub slowlog: *mut list,
1203 pub slowlog_entry_id: libc::c_longlong,
1204 pub slowlog_log_slower_than: libc::c_longlong,
1205 pub slowlog_max_len: libc::c_ulong,
1206 pub cron_malloc_stats: malloc_stats,
1207 pub stat_net_input_bytes: atomic_llong,
1208 pub stat_net_output_bytes: atomic_llong,
1209 pub stat_net_repl_input_bytes: atomic_llong,
1210 pub stat_net_repl_output_bytes: atomic_llong,
1211 pub stat_current_cow_peak: size_t,
1212 pub stat_current_cow_bytes: size_t,
1213 pub stat_current_cow_updated: monotime,
1214 pub stat_current_save_keys_processed: size_t,
1215 pub stat_current_save_keys_total: size_t,
1216 pub stat_rdb_cow_bytes: size_t,
1217 pub stat_aof_cow_bytes: size_t,
1218 pub stat_module_cow_bytes: size_t,
1219 pub stat_module_progress: libc::c_double,
1220 pub stat_clients_type_memory: [size_t; 4],
1221 pub stat_cluster_links_memory: size_t,
1222 pub stat_unexpected_error_replies: libc::c_longlong,
1223 pub stat_total_error_replies: libc::c_longlong,
1224 pub stat_dump_payload_sanitizations: libc::c_longlong,
1225 pub stat_io_reads_processed: libc::c_longlong,
1226 pub stat_io_writes_processed: libc::c_longlong,
1227 pub stat_total_reads_processed: atomic_llong,
1228 pub stat_total_writes_processed: atomic_llong,
1229 pub inst_metric: [C2RustUnnamed_6; 5],
1230 pub stat_reply_buffer_shrinks: libc::c_longlong,
1231 pub stat_reply_buffer_expands: libc::c_longlong,
1232 pub verbosity: libc::c_int,
1233 pub maxidletime: libc::c_int,
1234 pub tcpkeepalive: libc::c_int,
1235 pub active_expire_enabled: libc::c_int,
1236 pub active_expire_effort: libc::c_int,
1237 pub active_defrag_enabled: libc::c_int,
1238 pub sanitize_dump_payload: libc::c_int,
1239 pub skip_checksum_validation: libc::c_int,
1240 pub jemalloc_bg_thread: libc::c_int,
1241 pub active_defrag_ignore_bytes: size_t,
1242 pub active_defrag_threshold_lower: libc::c_int,
1243 pub active_defrag_threshold_upper: libc::c_int,
1244 pub active_defrag_cycle_min: libc::c_int,
1245 pub active_defrag_cycle_max: libc::c_int,
1246 pub active_defrag_max_scan_fields: libc::c_ulong,
1247 pub client_max_querybuf_len: size_t,
1248 pub dbnum: libc::c_int,
1249 pub supervised: libc::c_int,
1250 pub supervised_mode: libc::c_int,
1251 pub daemonize: libc::c_int,
1252 pub set_proc_title: libc::c_int,
1253 pub proc_title_template: *mut libc::c_char,
1254 pub client_obuf_limits: [clientBufferLimitsConfig; 3],
1255 pub pause_cron: libc::c_int,
1256 pub latency_tracking_enabled: libc::c_int,
1257 pub latency_tracking_info_percentiles: *mut libc::c_double,
1258 pub latency_tracking_info_percentiles_len: libc::c_int,
1259 pub aof_enabled: libc::c_int,
1260 pub aof_state: libc::c_int,
1261 pub aof_fsync: libc::c_int,
1262 pub aof_filename: *mut libc::c_char,
1263 pub aof_dirname: *mut libc::c_char,
1264 pub aof_no_fsync_on_rewrite: libc::c_int,
1265 pub aof_rewrite_perc: libc::c_int,
1266 pub aof_rewrite_min_size: off_t,
1267 pub aof_rewrite_base_size: off_t,
1268 pub aof_current_size: off_t,
1269 pub aof_last_incr_size: off_t,
1270 pub aof_fsync_offset: off_t,
1271 pub aof_flush_sleep: libc::c_int,
1272 pub aof_rewrite_scheduled: libc::c_int,
1273 pub aof_buf: sds,
1274 pub aof_fd: libc::c_int,
1275 pub aof_selected_db: libc::c_int,
1276 pub aof_flush_postponed_start: time_t,
1277 pub aof_last_fsync: time_t,
1278 pub aof_rewrite_time_last: time_t,
1279 pub aof_rewrite_time_start: time_t,
1280 pub aof_cur_timestamp: time_t,
1281 pub aof_timestamp_enabled: libc::c_int,
1282 pub aof_lastbgrewrite_status: libc::c_int,
1283 pub aof_delayed_fsync: libc::c_ulong,
1284 pub aof_rewrite_incremental_fsync: libc::c_int,
1285 pub rdb_save_incremental_fsync: libc::c_int,
1286 pub aof_last_write_status: libc::c_int,
1287 pub aof_last_write_errno: libc::c_int,
1288 pub aof_load_truncated: libc::c_int,
1289 pub aof_use_rdb_preamble: libc::c_int,
1290 pub aof_bio_fsync_status: atomic_int,
1291 pub aof_bio_fsync_errno: atomic_int,
1292 pub aof_manifest: *mut aofManifest,
1293 pub aof_disable_auto_gc: libc::c_int,
1294 pub dirty: libc::c_longlong,
1295 pub dirty_before_bgsave: libc::c_longlong,
1296 pub rdb_last_load_keys_expired: libc::c_longlong,
1297 pub rdb_last_load_keys_loaded: libc::c_longlong,
1298 pub saveparams: *mut saveparam,
1299 pub saveparamslen: libc::c_int,
1300 pub rdb_filename: *mut libc::c_char,
1301 pub rdb_compression: libc::c_int,
1302 pub rdb_checksum: libc::c_int,
1303 pub rdb_del_sync_files: libc::c_int,
1304 pub lastsave: time_t,
1305 pub lastbgsave_try: time_t,
1306 pub rdb_save_time_last: time_t,
1307 pub rdb_save_time_start: time_t,
1308 pub rdb_bgsave_scheduled: libc::c_int,
1309 pub rdb_child_type: libc::c_int,
1310 pub lastbgsave_status: libc::c_int,
1311 pub stop_writes_on_bgsave_err: libc::c_int,
1312 pub rdb_pipe_read: libc::c_int,
1313 pub rdb_child_exit_pipe: libc::c_int,
1314 pub rdb_pipe_conns: *mut *mut connection,
1315 pub rdb_pipe_numconns: libc::c_int,
1316 pub rdb_pipe_numconns_writing: libc::c_int,
1317 pub rdb_pipe_buff: *mut libc::c_char,
1318 pub rdb_pipe_bufflen: libc::c_int,
1319 pub rdb_key_save_delay: libc::c_int,
1320 pub key_load_delay: libc::c_int,
1321 pub child_info_pipe: [libc::c_int; 2],
1322 pub child_info_nread: libc::c_int,
1323 pub also_propagate: redisOpArray,
1324 pub replication_allowed: libc::c_int,
1325 pub logfile: *mut libc::c_char,
1326 pub syslog_enabled: libc::c_int,
1327 pub syslog_ident: *mut libc::c_char,
1328 pub syslog_facility: libc::c_int,
1329 pub crashlog_enabled: libc::c_int,
1330 pub memcheck_enabled: libc::c_int,
1331 pub use_exit_on_panic: libc::c_int,
1332 pub shutdown_timeout: libc::c_int,
1333 pub shutdown_on_sigint: libc::c_int,
1334 pub shutdown_on_sigterm: libc::c_int,
1335 pub replid: [libc::c_char; 41],
1336 pub replid2: [libc::c_char; 41],
1337 pub master_repl_offset: libc::c_longlong,
1338 pub second_replid_offset: libc::c_longlong,
1339 pub slaveseldb: libc::c_int,
1340 pub repl_ping_slave_period: libc::c_int,
1341 pub repl_backlog: *mut replBacklog,
1342 pub repl_backlog_size: libc::c_longlong,
1343 pub repl_backlog_time_limit: time_t,
1344 pub repl_no_slaves_since: time_t,
1345 pub repl_min_slaves_to_write: libc::c_int,
1346 pub repl_min_slaves_max_lag: libc::c_int,
1347 pub repl_good_slaves_count: libc::c_int,
1348 pub repl_diskless_sync: libc::c_int,
1349 pub repl_diskless_load: libc::c_int,
1350 pub repl_diskless_sync_delay: libc::c_int,
1351 pub repl_diskless_sync_max_replicas: libc::c_int,
1352 pub repl_buffer_mem: size_t,
1353 pub repl_buffer_blocks: *mut list,
1354 pub masteruser: *mut libc::c_char,
1355 pub masterauth: sds,
1356 pub masterhost: *mut libc::c_char,
1357 pub masterport: libc::c_int,
1358 pub repl_timeout: libc::c_int,
1359 pub master: *mut client,
1360 pub cached_master: *mut client,
1361 pub repl_syncio_timeout: libc::c_int,
1362 pub repl_state: libc::c_int,
1363 pub repl_transfer_size: off_t,
1364 pub repl_transfer_read: off_t,
1365 pub repl_transfer_last_fsync_off: off_t,
1366 pub repl_transfer_s: *mut connection,
1367 pub repl_transfer_fd: libc::c_int,
1368 pub repl_transfer_tmpfile: *mut libc::c_char,
1369 pub repl_transfer_lastio: time_t,
1370 pub repl_serve_stale_data: libc::c_int,
1371 pub repl_slave_ro: libc::c_int,
1372 pub repl_slave_ignore_maxmemory: libc::c_int,
1373 pub repl_down_since: time_t,
1374 pub repl_disable_tcp_nodelay: libc::c_int,
1375 pub slave_priority: libc::c_int,
1376 pub replica_announced: libc::c_int,
1377 pub slave_announce_port: libc::c_int,
1378 pub slave_announce_ip: *mut libc::c_char,
1379 pub propagation_error_behavior: libc::c_int,
1380 pub repl_ignore_disk_write_error: libc::c_int,
1381 pub master_replid: [libc::c_char; 41],
1382 pub master_initial_offset: libc::c_longlong,
1383 pub repl_slave_lazy_flush: libc::c_int,
1384 pub clients_waiting_acks: *mut list,
1385 pub get_ack_from_slaves: libc::c_int,
1386 pub maxclients: libc::c_uint,
1387 pub maxmemory: libc::c_ulonglong,
1388 pub maxmemory_clients: ssize_t,
1389 pub maxmemory_policy: libc::c_int,
1390 pub maxmemory_samples: libc::c_int,
1391 pub maxmemory_eviction_tenacity: libc::c_int,
1392 pub lfu_log_factor: libc::c_int,
1393 pub lfu_decay_time: libc::c_int,
1394 pub proto_max_bulk_len: libc::c_longlong,
1395 pub oom_score_adj_values: [libc::c_int; 3],
1396 pub oom_score_adj: libc::c_int,
1397 pub disable_thp: libc::c_int,
1398 pub blocked_clients: libc::c_uint,
1399 pub blocked_clients_by_type: [libc::c_uint; 8],
1400 pub unblocked_clients: *mut list,
1401 pub ready_keys: *mut list,
1402 pub tracking_clients: libc::c_uint,
1403 pub tracking_table_max_keys: size_t,
1404 pub tracking_pending_keys: *mut list,
1405 pub sort_desc: libc::c_int,
1406 pub sort_alpha: libc::c_int,
1407 pub sort_bypattern: libc::c_int,
1408 pub sort_store: libc::c_int,
1409 pub hash_max_listpack_entries: size_t,
1410 pub hash_max_listpack_value: size_t,
1411 pub set_max_intset_entries: size_t,
1412 pub zset_max_listpack_entries: size_t,
1413 pub zset_max_listpack_value: size_t,
1414 pub hll_sparse_max_bytes: size_t,
1415 pub stream_node_max_bytes: size_t,
1416 pub stream_node_max_entries: libc::c_longlong,
1417 pub list_max_listpack_size: libc::c_int,
1418 pub list_compress_depth: libc::c_int,
1419 pub unixtime: atomic_int,
1420 pub timezone: time_t,
1421 pub daylight_active: libc::c_int,
1422 pub mstime: mstime_t,
1423 pub ustime: ustime_t,
1424 pub blocking_op_nesting: size_t,
1425 pub blocked_last_cron: libc::c_longlong,
1426 pub pubsub_channels: *mut dict,
1427 pub pubsub_patterns: *mut dict,
1428 pub notify_keyspace_events: libc::c_int,
1429 pub pubsubshard_channels: *mut dict,
1430 pub cluster_enabled: libc::c_int,
1431 pub cluster_port: libc::c_int,
1432 pub cluster_node_timeout: mstime_t,
1433 pub cluster_configfile: *mut libc::c_char,
1434 pub cluster: *mut clusterState,
1435 pub cluster_migration_barrier: libc::c_int,
1436 pub cluster_allow_replica_migration: libc::c_int,
1437 pub cluster_slave_validity_factor: libc::c_int,
1438 pub cluster_require_full_coverage: libc::c_int,
1439 pub cluster_slave_no_failover: libc::c_int,
1440 pub cluster_announce_ip: *mut libc::c_char,
1441 pub cluster_announce_hostname: *mut libc::c_char,
1442 pub cluster_preferred_endpoint_type: libc::c_int,
1443 pub cluster_announce_port: libc::c_int,
1444 pub cluster_announce_tls_port: libc::c_int,
1445 pub cluster_announce_bus_port: libc::c_int,
1446 pub cluster_module_flags: libc::c_int,
1447 pub cluster_allow_reads_when_down: libc::c_int,
1448 pub cluster_config_file_lock_fd: libc::c_int,
1449 pub cluster_link_sendbuf_limit_bytes: libc::c_ulonglong,
1450 pub cluster_drop_packet_filter: libc::c_int,
1451 pub script_caller: *mut client,
1452 pub busy_reply_threshold: mstime_t,
1453 pub pre_command_oom_state: libc::c_int,
1454 pub script_disable_deny_script: libc::c_int,
1455 pub lazyfree_lazy_eviction: libc::c_int,
1456 pub lazyfree_lazy_expire: libc::c_int,
1457 pub lazyfree_lazy_server_del: libc::c_int,
1458 pub lazyfree_lazy_user_del: libc::c_int,
1459 pub lazyfree_lazy_user_flush: libc::c_int,
1460 pub latency_monitor_threshold: libc::c_longlong,
1461 pub latency_events: *mut dict,
1462 pub acl_filename: *mut libc::c_char,
1463 pub acllog_max_len: libc::c_ulong,
1464 pub requirepass: sds,
1465 pub acl_pubsub_default: libc::c_int,
1466 pub watchdog_period: libc::c_int,
1467 pub system_memory_size: size_t,
1468 pub tls_cluster: libc::c_int,
1469 pub tls_replication: libc::c_int,
1470 pub tls_auth_clients: libc::c_int,
1471 pub tls_ctx_config: redisTLSContextConfig,
1472 pub server_cpulist: *mut libc::c_char,
1473 pub bio_cpulist: *mut libc::c_char,
1474 pub aof_rewrite_cpulist: *mut libc::c_char,
1475 pub bgsave_cpulist: *mut libc::c_char,
1476 pub sentinel_config: *mut sentinelConfig,
1477 pub failover_end_time: mstime_t,
1478 pub force_failover: libc::c_int,
1479 pub target_replica_host: *mut libc::c_char,
1480 pub target_replica_port: libc::c_int,
1481 pub failover_state: libc::c_int,
1482 pub cluster_allow_pubsubshard_when_down: libc::c_int,
1483 pub reply_buffer_peak_reset_time: libc::c_long,
1484 pub reply_buffer_resizing_enabled: libc::c_int,
1485}
1486#[derive(Copy, Clone)]
1487#[repr(C)]
1488pub struct C2RustUnnamed_6 {
1489 pub last_sample_time: libc::c_longlong,
1490 pub last_sample_count: libc::c_longlong,
1491 pub samples: [libc::c_longlong; 16],
1492 pub idx: libc::c_int,
1493}
1494#[derive(Copy, Clone)]
1495#[repr(C)]
1496pub struct setTypeIterator {
1497 pub subject: *mut robj,
1498 pub encoding: libc::c_int,
1499 pub ii: libc::c_int,
1500 pub di: *mut dictIterator,
1501}
1502#[inline]
1503unsafe extern "C" fn sdslen(s: sds) -> size_t {
1504 let mut flags: libc::c_uchar = *s.offset(-(1 as libc::c_int) as isize)
1505 as libc::c_uchar;
1506 match flags as libc::c_int & 7 as libc::c_int {
1507 0 => return (flags as libc::c_int >> 3 as libc::c_int) as size_t,
1508 1 => {
1509 return (*(s
1510 .offset(-(core::mem::size_of::<sdshdr8>() as libc::c_ulong as isize))
1511 as *mut sdshdr8))
1512 .len as size_t;
1513 }
1514 2 => {
1515 return (*(s
1516 .offset(-(core::mem::size_of::<sdshdr16>() as libc::c_ulong as isize))
1517 as *mut sdshdr16))
1518 .len as size_t;
1519 }
1520 3 => {
1521 return (*(s
1522 .offset(-(core::mem::size_of::<sdshdr32>() as libc::c_ulong as isize))
1523 as *mut sdshdr32))
1524 .len as size_t;
1525 }
1526 4 => {
1527 return (*(s
1528 .offset(-(core::mem::size_of::<sdshdr64>() as libc::c_ulong as isize))
1529 as *mut sdshdr64))
1530 .len;
1531 }
1532 _ => {}
1533 }
1534 return 0 as libc::c_int as size_t;
1535}
1536#[no_mangle]
1537pub unsafe extern "C" fn setTypeCreate(mut value: sds) -> *mut robj {
1538 if isSdsRepresentableAsLongLong(value, 0 as *mut libc::c_longlong)
1539 == 0 as libc::c_int
1540 {
1541 return createIntsetObject();
1542 }
1543 return createSetObject();
1544}
1545#[no_mangle]
1546pub unsafe extern "C" fn setTypeAdd(
1547 mut subject: *mut robj,
1548 mut value: sds,
1549) -> libc::c_int {
1550 let mut llval: libc::c_longlong = 0;
1551 if (*subject).encoding() as libc::c_int == 2 as libc::c_int {
1552 let mut ht: *mut dict = (*subject).ptr as *mut dict;
1553 let mut de: *mut dictEntry = dictAddRaw(
1554 ht,
1555 value as *mut libc::c_void,
1556 0 as *mut *mut dictEntry,
1557 );
1558 if !de.is_null() {
1559 if ((*(*ht).type_0).keyDup).is_some() {
1560 (*de)
1561 .key = ((*(*ht).type_0).keyDup)
1562 .expect(
1563 "non-null function pointer",
1564 )(ht, sdsdup(value) as *const libc::c_void);
1565 } else {
1566 (*de).key = sdsdup(value) as *mut libc::c_void;
1567 }
1568 if ((*(*ht).type_0).valDup).is_some() {
1569 (*de)
1570 .v
1571 .val = ((*(*ht).type_0).valDup)
1572 .expect("non-null function pointer")(ht, 0 as *const libc::c_void);
1573 } else {
1574 (*de).v.val = 0 as *mut libc::c_void;
1575 }
1576 return 1 as libc::c_int;
1577 }
1578 } else if (*subject).encoding() as libc::c_int == 6 as libc::c_int {
1579 if isSdsRepresentableAsLongLong(value, &mut llval) == 0 as libc::c_int {
1580 let mut success: uint8_t = 0 as libc::c_int as uint8_t;
1581 (*subject)
1582 .ptr = intsetAdd(
1583 (*subject).ptr as *mut intset,
1584 llval as int64_t,
1585 &mut success,
1586 ) as *mut libc::c_void;
1587 if success != 0 {
1588 let mut max_entries: size_t = server.set_max_intset_entries;
1589 if max_entries
1590 >= ((1 as libc::c_int) << 30 as libc::c_int) as libc::c_ulong
1591 {
1592 max_entries = ((1 as libc::c_int) << 30 as libc::c_int) as size_t;
1593 }
1594 if intsetLen((*subject).ptr as *const intset) as libc::c_ulong
1595 > max_entries
1596 {
1597 setTypeConvert(subject, 2 as libc::c_int);
1598 }
1599 return 1 as libc::c_int;
1600 }
1601 } else {
1602 setTypeConvert(subject, 2 as libc::c_int);
1603 if dictAdd(
1604 (*subject).ptr as *mut dict,
1605 sdsdup(value) as *mut libc::c_void,
1606 0 as *mut libc::c_void,
1607 ) == 0 as libc::c_int
1608 {} else {
1609 _serverAssert(
1610 b"dictAdd(subject->ptr,sdsdup(value),NULL) == DICT_OK\0" as *const u8
1611 as *const libc::c_char,
1612 b"t_set.c\0" as *const u8 as *const libc::c_char,
1613 82 as libc::c_int,
1614 );
1615 unreachable!();
1616 };
1617 return 1 as libc::c_int;
1618 }
1619 } else {
1620 _serverPanic(
1621 b"t_set.c\0" as *const u8 as *const libc::c_char,
1622 86 as libc::c_int,
1623 b"Unknown set encoding\0" as *const u8 as *const libc::c_char,
1624 );
1625 unreachable!();
1626 }
1627 return 0 as libc::c_int;
1628}
1629#[no_mangle]
1630pub unsafe extern "C" fn setTypeRemove(
1631 mut setobj: *mut robj,
1632 mut value: sds,
1633) -> libc::c_int {
1634 let mut llval: libc::c_longlong = 0;
1635 if (*setobj).encoding() as libc::c_int == 2 as libc::c_int {
1636 if dictDelete((*setobj).ptr as *mut dict, value as *const libc::c_void)
1637 == 0 as libc::c_int
1638 {
1639 if htNeedsResize((*setobj).ptr as *mut dict) != 0 {
1640 dictResize((*setobj).ptr as *mut dict);
1641 }
1642 return 1 as libc::c_int;
1643 }
1644 } else if (*setobj).encoding() as libc::c_int == 6 as libc::c_int {
1645 if isSdsRepresentableAsLongLong(value, &mut llval) == 0 as libc::c_int {
1646 let mut success: libc::c_int = 0;
1647 (*setobj)
1648 .ptr = intsetRemove(
1649 (*setobj).ptr as *mut intset,
1650 llval as int64_t,
1651 &mut success,
1652 ) as *mut libc::c_void;
1653 if success != 0 {
1654 return 1 as libc::c_int;
1655 }
1656 }
1657 } else {
1658 _serverPanic(
1659 b"t_set.c\0" as *const u8 as *const libc::c_char,
1660 105 as libc::c_int,
1661 b"Unknown set encoding\0" as *const u8 as *const libc::c_char,
1662 );
1663 unreachable!();
1664 }
1665 return 0 as libc::c_int;
1666}
1667#[no_mangle]
1668pub unsafe extern "C" fn setTypeIsMember(
1669 mut subject: *mut robj,
1670 mut value: sds,
1671) -> libc::c_int {
1672 let mut llval: libc::c_longlong = 0;
1673 if (*subject).encoding() as libc::c_int == 2 as libc::c_int {
1674 return (dictFind((*subject).ptr as *mut dict, value as *const libc::c_void)
1675 != 0 as *mut libc::c_void as *mut dictEntry) as libc::c_int
1676 } else {
1677 if (*subject).encoding() as libc::c_int == 6 as libc::c_int {
1678 if isSdsRepresentableAsLongLong(value, &mut llval) == 0 as libc::c_int {
1679 return intsetFind((*subject).ptr as *mut intset, llval as int64_t)
1680 as libc::c_int;
1681 }
1682 } else {
1683 _serverPanic(
1684 b"t_set.c\0" as *const u8 as *const libc::c_char,
1685 119 as libc::c_int,
1686 b"Unknown set encoding\0" as *const u8 as *const libc::c_char,
1687 );
1688 unreachable!();
1689 }
1690 }
1691 return 0 as libc::c_int;
1692}
1693#[no_mangle]
1694pub unsafe extern "C" fn setTypeInitIterator(
1695 mut subject: *mut robj,
1696) -> *mut setTypeIterator {
1697 let mut si: *mut setTypeIterator = zmalloc(
1698 core::mem::size_of::<setTypeIterator>() as libc::c_ulong,
1699 ) as *mut setTypeIterator;
1700 (*si).subject = subject;
1701 (*si).encoding = (*subject).encoding() as libc::c_int;
1702 if (*si).encoding == 2 as libc::c_int {
1703 (*si).di = dictGetIterator((*subject).ptr as *mut dict);
1704 } else if (*si).encoding == 6 as libc::c_int {
1705 (*si).ii = 0 as libc::c_int;
1706 } else {
1707 _serverPanic(
1708 b"t_set.c\0" as *const u8 as *const libc::c_char,
1709 133 as libc::c_int,
1710 b"Unknown set encoding\0" as *const u8 as *const libc::c_char,
1711 );
1712 unreachable!();
1713 }
1714 return si;
1715}
1716#[no_mangle]
1717pub unsafe extern "C" fn setTypeReleaseIterator(mut si: *mut setTypeIterator) {
1718 if (*si).encoding == 2 as libc::c_int {
1719 dictReleaseIterator((*si).di);
1720 }
1721 zfree(si as *mut libc::c_void);
1722}
1723#[no_mangle]
1724pub unsafe extern "C" fn setTypeNext(
1725 mut si: *mut setTypeIterator,
1726 mut sdsele: *mut sds,
1727 mut llele: *mut int64_t,
1728) -> libc::c_int {
1729 if (*si).encoding == 2 as libc::c_int {
1730 let mut de: *mut dictEntry = dictNext((*si).di);
1731 if de.is_null() {
1732 return -(1 as libc::c_int);
1733 }
1734 *sdsele = (*de).key as sds;
1735 *llele = -(123456789 as libc::c_int) as int64_t;
1736 } else if (*si).encoding == 6 as libc::c_int {
1737 let fresh0 = (*si).ii;
1738 (*si).ii = (*si).ii + 1;
1739 if intsetGet((*(*si).subject).ptr as *mut intset, fresh0 as uint32_t, llele) == 0
1740 {
1741 return -(1 as libc::c_int);
1742 }
1743 *sdsele = 0 as sds;
1744 } else {
1745 _serverPanic(
1746 b"t_set.c\0" as *const u8 as *const libc::c_char,
1747 168 as libc::c_int,
1748 b"Wrong set encoding in setTypeNext\0" as *const u8 as *const libc::c_char,
1749 );
1750 unreachable!();
1751 }
1752 return (*si).encoding;
1753}
1754#[no_mangle]
1755pub unsafe extern "C" fn setTypeNextObject(mut si: *mut setTypeIterator) -> sds {
1756 let mut intele: int64_t = 0;
1757 let mut sdsele: sds = 0 as *mut libc::c_char;
1758 let mut encoding: libc::c_int = 0;
1759 encoding = setTypeNext(si, &mut sdsele, &mut intele);
1760 match encoding {
1761 -1 => return 0 as sds,
1762 6 => return sdsfromlonglong(intele as libc::c_longlong),
1763 2 => return sdsdup(sdsele),
1764 _ => {
1765 _serverPanic(
1766 b"t_set.c\0" as *const u8 as *const libc::c_char,
1767 193 as libc::c_int,
1768 b"Unsupported encoding\0" as *const u8 as *const libc::c_char,
1769 );
1770 unreachable!();
1771 }
1772 }
1773 return 0 as sds;
1774}
1775#[no_mangle]
1776pub unsafe extern "C" fn setTypeRandomElement(
1777 mut setobj: *mut robj,
1778 mut sdsele: *mut sds,
1779 mut llele: *mut int64_t,
1780) -> libc::c_int {
1781 if (*setobj).encoding() as libc::c_int == 2 as libc::c_int {
1782 let mut de: *mut dictEntry = dictGetFairRandomKey((*setobj).ptr as *mut dict);
1783 *sdsele = (*de).key as sds;
1784 *llele = -(123456789 as libc::c_int) as int64_t;
1785 } else if (*setobj).encoding() as libc::c_int == 6 as libc::c_int {
1786 *llele = intsetRandom((*setobj).ptr as *mut intset);
1787 *sdsele = 0 as sds;
1788 } else {
1789 _serverPanic(
1790 b"t_set.c\0" as *const u8 as *const libc::c_char,
1791 220 as libc::c_int,
1792 b"Unknown set encoding\0" as *const u8 as *const libc::c_char,
1793 );
1794 unreachable!();
1795 }
1796 return (*setobj).encoding() as libc::c_int;
1797}
1798#[no_mangle]
1799pub unsafe extern "C" fn setTypeSize(mut subject: *const robj) -> libc::c_ulong {
1800 if (*subject).encoding() as libc::c_int == 2 as libc::c_int {
1801 return ((*((*subject).ptr as *const dict)).ht_used[0 as libc::c_int as usize])
1802 .wrapping_add(
1803 (*((*subject).ptr as *const dict)).ht_used[1 as libc::c_int as usize],
1804 )
1805 } else {
1806 if (*subject).encoding() as libc::c_int == 6 as libc::c_int {
1807 return intsetLen((*subject).ptr as *const intset) as libc::c_ulong
1808 } else {
1809 _serverPanic(
1810 b"t_set.c\0" as *const u8 as *const libc::c_char,
1811 231 as libc::c_int,
1812 b"Unknown set encoding\0" as *const u8 as *const libc::c_char,
1813 );
1814 unreachable!();
1815 }
1816 }
1817 panic!("Reached end of non-void function without returning");
1818}
1819#[no_mangle]
1820pub unsafe extern "C" fn setTypeConvert(mut setobj: *mut robj, mut enc: libc::c_int) {
1821 let mut si: *mut setTypeIterator = 0 as *mut setTypeIterator;
1822 if (*setobj).type_0() as libc::c_int == 2 as libc::c_int
1823 && (*setobj).encoding() as libc::c_int == 6 as libc::c_int
1824 {} else {
1825 _serverAssertWithInfo(
1826 0 as *const client,
1827 setobj,
1828 b"setobj->type == OBJ_SET && setobj->encoding == OBJ_ENCODING_INTSET\0"
1829 as *const u8 as *const libc::c_char,
1830 b"t_set.c\0" as *const u8 as *const libc::c_char,
1831 241 as libc::c_int,
1832 );
1833 unreachable!();
1834 };
1835 if enc == 2 as libc::c_int {
1836 let mut intele: int64_t = 0;
1837 let mut d: *mut dict = dictCreate(&mut setDictType);
1838 let mut element: sds = 0 as *mut libc::c_char;
1839 dictExpand(d, intsetLen((*setobj).ptr as *const intset) as libc::c_ulong);
1840 si = setTypeInitIterator(setobj);
1841 while setTypeNext(si, &mut element, &mut intele) != -(1 as libc::c_int) {
1842 element = sdsfromlonglong(intele as libc::c_longlong);
1843 if dictAdd(d, element as *mut libc::c_void, 0 as *mut libc::c_void)
1844 == 0 as libc::c_int
1845 {} else {
1846 _serverAssert(
1847 b"dictAdd(d,element,NULL) == DICT_OK\0" as *const u8
1848 as *const libc::c_char,
1849 b"t_set.c\0" as *const u8 as *const libc::c_char,
1850 255 as libc::c_int,
1851 );
1852 unreachable!();
1853 };
1854 }
1855 setTypeReleaseIterator(si);
1856 (*setobj).set_encoding(2 as libc::c_int as libc::c_uint);
1857 zfree((*setobj).ptr);
1858 (*setobj).ptr = d as *mut libc::c_void;
1859 } else {
1860 _serverPanic(
1861 b"t_set.c\0" as *const u8 as *const libc::c_char,
1862 263 as libc::c_int,
1863 b"Unsupported set conversion\0" as *const u8 as *const libc::c_char,
1864 );
1865 unreachable!();
1866 };
1867}
1868#[no_mangle]
1869pub unsafe extern "C" fn setTypeDup(mut o: *mut robj) -> *mut robj {
1870 let mut set: *mut robj = 0 as *mut robj;
1871 let mut si: *mut setTypeIterator = 0 as *mut setTypeIterator;
1872 let mut elesds: sds = 0 as *mut libc::c_char;
1873 let mut intobj: int64_t = 0;
1874 if (*o).type_0() as libc::c_int == 2 as libc::c_int {} else {
1875 _serverAssert(
1876 b"o->type == OBJ_SET\0" as *const u8 as *const libc::c_char,
1877 b"t_set.c\0" as *const u8 as *const libc::c_char,
1878 278 as libc::c_int,
1879 );
1880 unreachable!();
1881 };
1882 if (*o).encoding() as libc::c_int == 6 as libc::c_int {
1883 let mut is: *mut intset = (*o).ptr as *mut intset;
1884 let mut size: size_t = intsetBlobLen(is);
1885 let mut newis: *mut intset = zmalloc(size) as *mut intset;
1886 memcpy(newis as *mut libc::c_void, is as *const libc::c_void, size);
1887 set = createObject(2 as libc::c_int, newis as *mut libc::c_void);
1888 (*set).set_encoding(6 as libc::c_int as libc::c_uint);
1889 } else if (*o).encoding() as libc::c_int == 2 as libc::c_int {
1890 set = createSetObject();
1891 let mut d: *mut dict = (*o).ptr as *mut dict;
1892 dictExpand(
1893 (*set).ptr as *mut dict,
1894 ((*d).ht_used[0 as libc::c_int as usize])
1895 .wrapping_add((*d).ht_used[1 as libc::c_int as usize]),
1896 );
1897 si = setTypeInitIterator(o);
1898 while setTypeNext(si, &mut elesds, &mut intobj) != -(1 as libc::c_int) {
1899 setTypeAdd(set, elesds);
1900 }
1901 setTypeReleaseIterator(si);
1902 } else {
1903 _serverPanic(
1904 b"t_set.c\0" as *const u8 as *const libc::c_char,
1905 298 as libc::c_int,
1906 b"Unknown set encoding\0" as *const u8 as *const libc::c_char,
1907 );
1908 unreachable!();
1909 }
1910 return set;
1911}
1912#[no_mangle]
1913pub unsafe extern "C" fn saddCommand(mut c: *mut client) {
1914 let mut set: *mut robj = 0 as *mut robj;
1915 let mut j: libc::c_int = 0;
1916 let mut added: libc::c_int = 0 as libc::c_int;
1917 set = lookupKeyWrite((*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
1918 if checkType(c, set, 2 as libc::c_int) != 0 {
1919 return;
1920 }
1921 if set.is_null() {
1922 set = setTypeCreate(
1923 (**((*c).argv).offset(2 as libc::c_int as isize)).ptr as sds,
1924 );
1925 dbAdd((*c).db, *((*c).argv).offset(1 as libc::c_int as isize), set);
1926 }
1927 j = 2 as libc::c_int;
1928 while j < (*c).argc {
1929 if setTypeAdd(set, (**((*c).argv).offset(j as isize)).ptr as sds) != 0 {
1930 added += 1;
1931 }
1932 j += 1;
1933 }
1934 if added != 0 {
1935 signalModifiedKey(c, (*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
1936 notifyKeyspaceEvent(
1937 (1 as libc::c_int) << 5 as libc::c_int,
1938 b"sadd\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1939 *((*c).argv).offset(1 as libc::c_int as isize),
1940 (*(*c).db).id,
1941 );
1942 }
1943 server.dirty += added as libc::c_longlong;
1944 addReplyLongLong(c, added as libc::c_longlong);
1945}
1946#[no_mangle]
1947pub unsafe extern "C" fn sremCommand(mut c: *mut client) {
1948 let mut set: *mut robj = 0 as *mut robj;
1949 let mut j: libc::c_int = 0;
1950 let mut deleted: libc::c_int = 0 as libc::c_int;
1951 let mut keyremoved: libc::c_int = 0 as libc::c_int;
1952 set = lookupKeyWriteOrReply(
1953 c,
1954 *((*c).argv).offset(1 as libc::c_int as isize),
1955 shared.czero,
1956 );
1957 if set.is_null() || checkType(c, set, 2 as libc::c_int) != 0 {
1958 return;
1959 }
1960 j = 2 as libc::c_int;
1961 while j < (*c).argc {
1962 if setTypeRemove(set, (**((*c).argv).offset(j as isize)).ptr as sds) != 0 {
1963 deleted += 1;
1964 if setTypeSize(set) == 0 as libc::c_int as libc::c_ulong {
1965 dbDelete((*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
1966 keyremoved = 1 as libc::c_int;
1967 break;
1968 }
1969 }
1970 j += 1;
1971 }
1972 if deleted != 0 {
1973 signalModifiedKey(c, (*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
1974 notifyKeyspaceEvent(
1975 (1 as libc::c_int) << 5 as libc::c_int,
1976 b"srem\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1977 *((*c).argv).offset(1 as libc::c_int as isize),
1978 (*(*c).db).id,
1979 );
1980 if keyremoved != 0 {
1981 notifyKeyspaceEvent(
1982 (1 as libc::c_int) << 2 as libc::c_int,
1983 b"del\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1984 *((*c).argv).offset(1 as libc::c_int as isize),
1985 (*(*c).db).id,
1986 );
1987 }
1988 server.dirty += deleted as libc::c_longlong;
1989 }
1990 addReplyLongLong(c, deleted as libc::c_longlong);
1991}
1992#[no_mangle]
1993pub unsafe extern "C" fn smoveCommand(mut c: *mut client) {
1994 let mut srcset: *mut robj = 0 as *mut robj;
1995 let mut dstset: *mut robj = 0 as *mut robj;
1996 let mut ele: *mut robj = 0 as *mut robj;
1997 srcset = lookupKeyWrite((*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
1998 dstset = lookupKeyWrite((*c).db, *((*c).argv).offset(2 as libc::c_int as isize));
1999 ele = *((*c).argv).offset(3 as libc::c_int as isize);
2000 if srcset.is_null() {
2001 addReply(c, shared.czero);
2002 return;
2003 }
2004 if checkType(c, srcset, 2 as libc::c_int) != 0
2005 || checkType(c, dstset, 2 as libc::c_int) != 0
2006 {
2007 return;
2008 }
2009 if srcset == dstset {
2010 addReply(
2011 c,
2012 if setTypeIsMember(srcset, (*ele).ptr as sds) != 0 {
2013 shared.cone
2014 } else {
2015 shared.czero
2016 },
2017 );
2018 return;
2019 }
2020 if setTypeRemove(srcset, (*ele).ptr as sds) == 0 {
2021 addReply(c, shared.czero);
2022 return;
2023 }
2024 notifyKeyspaceEvent(
2025 (1 as libc::c_int) << 5 as libc::c_int,
2026 b"srem\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2027 *((*c).argv).offset(1 as libc::c_int as isize),
2028 (*(*c).db).id,
2029 );
2030 if setTypeSize(srcset) == 0 as libc::c_int as libc::c_ulong {
2031 dbDelete((*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
2032 notifyKeyspaceEvent(
2033 (1 as libc::c_int) << 2 as libc::c_int,
2034 b"del\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2035 *((*c).argv).offset(1 as libc::c_int as isize),
2036 (*(*c).db).id,
2037 );
2038 }
2039 if dstset.is_null() {
2040 dstset = setTypeCreate((*ele).ptr as sds);
2041 dbAdd((*c).db, *((*c).argv).offset(2 as libc::c_int as isize), dstset);
2042 }
2043 signalModifiedKey(c, (*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
2044 server.dirty += 1;
2045 if setTypeAdd(dstset, (*ele).ptr as sds) != 0 {
2046 server.dirty += 1;
2047 signalModifiedKey(c, (*c).db, *((*c).argv).offset(2 as libc::c_int as isize));
2048 notifyKeyspaceEvent(
2049 (1 as libc::c_int) << 5 as libc::c_int,
2050 b"sadd\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2051 *((*c).argv).offset(2 as libc::c_int as isize),
2052 (*(*c).db).id,
2053 );
2054 }
2055 addReply(c, shared.cone);
2056}
2057#[no_mangle]
2058pub unsafe extern "C" fn sismemberCommand(mut c: *mut client) {
2059 let mut set: *mut robj = 0 as *mut robj;
2060 set = lookupKeyReadOrReply(
2061 c,
2062 *((*c).argv).offset(1 as libc::c_int as isize),
2063 shared.czero,
2064 );
2065 if set.is_null() || checkType(c, set, 2 as libc::c_int) != 0 {
2066 return;
2067 }
2068 if setTypeIsMember(set, (**((*c).argv).offset(2 as libc::c_int as isize)).ptr as sds)
2069 != 0
2070 {
2071 addReply(c, shared.cone);
2072 } else {
2073 addReply(c, shared.czero);
2074 };
2075}
2076#[no_mangle]
2077pub unsafe extern "C" fn smismemberCommand(mut c: *mut client) {
2078 let mut set: *mut robj = 0 as *mut robj;
2079 let mut j: libc::c_int = 0;
2080 set = lookupKeyRead((*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
2081 if !set.is_null() && checkType(c, set, 2 as libc::c_int) != 0 {
2082 return;
2083 }
2084 addReplyArrayLen(c, ((*c).argc - 2 as libc::c_int) as libc::c_long);
2085 j = 2 as libc::c_int;
2086 while j < (*c).argc {
2087 if !set.is_null()
2088 && setTypeIsMember(set, (**((*c).argv).offset(j as isize)).ptr as sds) != 0
2089 {
2090 addReply(c, shared.cone);
2091 } else {
2092 addReply(c, shared.czero);
2093 }
2094 j += 1;
2095 }
2096}
2097#[no_mangle]
2098pub unsafe extern "C" fn scardCommand(mut c: *mut client) {
2099 let mut o: *mut robj = 0 as *mut robj;
2100 o = lookupKeyReadOrReply(
2101 c,
2102 *((*c).argv).offset(1 as libc::c_int as isize),
2103 shared.czero,
2104 );
2105 if o.is_null() || checkType(c, o, 2 as libc::c_int) != 0 {
2106 return;
2107 }
2108 addReplyLongLong(c, setTypeSize(o) as libc::c_longlong);
2109}
2110#[no_mangle]
2111pub unsafe extern "C" fn spopWithCountCommand(mut c: *mut client) {
2112 let mut l: libc::c_long = 0;
2113 let mut count: libc::c_ulong = 0;
2114 let mut size: libc::c_ulong = 0;
2115 let mut set: *mut robj = 0 as *mut robj;
2116 if getPositiveLongFromObjectOrReply(
2117 c,
2118 *((*c).argv).offset(2 as libc::c_int as isize),
2119 &mut l,
2120 0 as *const libc::c_char,
2121 ) != 0 as libc::c_int
2122 {
2123 return;
2124 }
2125 count = l as libc::c_ulong;
2126 set = lookupKeyWriteOrReply(
2127 c,
2128 *((*c).argv).offset(1 as libc::c_int as isize),
2129 shared.emptyset[(*c).resp as usize],
2130 );
2131 if set.is_null() || checkType(c, set, 2 as libc::c_int) != 0 {
2132 return;
2133 }
2134 if count == 0 as libc::c_int as libc::c_ulong {
2135 addReply(c, shared.emptyset[(*c).resp as usize]);
2136 return;
2137 }
2138 size = setTypeSize(set);
2139 notifyKeyspaceEvent(
2140 (1 as libc::c_int) << 5 as libc::c_int,
2141 b"spop\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2142 *((*c).argv).offset(1 as libc::c_int as isize),
2143 (*(*c).db).id,
2144 );
2145 server
2146 .dirty = (server.dirty as libc::c_ulonglong)
2147 .wrapping_add((if count >= size { size } else { count }) as libc::c_ulonglong)
2148 as libc::c_longlong as libc::c_longlong;
2149 if count >= size {
2150 sunionDiffGenericCommand(
2151 c,
2152 ((*c).argv).offset(1 as libc::c_int as isize),
2153 1 as libc::c_int,
2154 0 as *mut robj,
2155 0 as libc::c_int,
2156 );
2157 dbDelete((*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
2158 notifyKeyspaceEvent(
2159 (1 as libc::c_int) << 2 as libc::c_int,
2160 b"del\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2161 *((*c).argv).offset(1 as libc::c_int as isize),
2162 (*(*c).db).id,
2163 );
2164 rewriteClientCommandVector(
2165 c,
2166 2 as libc::c_int,
2167 shared.del,
2168 *((*c).argv).offset(1 as libc::c_int as isize),
2169 );
2170 signalModifiedKey(c, (*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
2171 return;
2172 }
2173 let mut propargv: [*mut robj; 3] = [0 as *mut robj; 3];
2174 propargv[0 as libc::c_int as usize] = shared.srem;
2175 propargv[1 as libc::c_int as usize] = *((*c).argv).offset(1 as libc::c_int as isize);
2176 addReplySetLen(c, count as libc::c_long);
2177 let mut sdsele: sds = 0 as *mut libc::c_char;
2178 let mut objele: *mut robj = 0 as *mut robj;
2179 let mut encoding: libc::c_int = 0;
2180 let mut llele: int64_t = 0;
2181 let mut remaining: libc::c_ulong = size.wrapping_sub(count);
2182 if remaining.wrapping_mul(5 as libc::c_int as libc::c_ulong) > count {
2183 loop {
2184 let fresh1 = count;
2185 count = count.wrapping_sub(1);
2186 if !(fresh1 != 0) {
2187 break;
2188 }
2189 encoding = setTypeRandomElement(set, &mut sdsele, &mut llele);
2190 if encoding == 6 as libc::c_int {
2191 addReplyBulkLongLong(c, llele as libc::c_longlong);
2192 objele = createStringObjectFromLongLong(llele as libc::c_longlong);
2193 (*set)
2194 .ptr = intsetRemove(
2195 (*set).ptr as *mut intset,
2196 llele,
2197 0 as *mut libc::c_int,
2198 ) as *mut libc::c_void;
2199 } else {
2200 addReplyBulkCBuffer(c, sdsele as *const libc::c_void, sdslen(sdsele));
2201 objele = createStringObject(
2202 sdsele as *const libc::c_char,
2203 sdslen(sdsele),
2204 );
2205 setTypeRemove(set, sdsele);
2206 }
2207 propargv[2 as libc::c_int as usize] = objele;
2208 alsoPropagate(
2209 (*(*c).db).id,
2210 propargv.as_mut_ptr(),
2211 3 as libc::c_int,
2212 1 as libc::c_int | 2 as libc::c_int,
2213 );
2214 decrRefCount(objele);
2215 }
2216 } else {
2217 let mut newset: *mut robj = 0 as *mut robj;
2218 loop {
2219 let fresh2 = remaining;
2220 remaining = remaining.wrapping_sub(1);
2221 if !(fresh2 != 0) {
2222 break;
2223 }
2224 encoding = setTypeRandomElement(set, &mut sdsele, &mut llele);
2225 if encoding == 6 as libc::c_int {
2226 sdsele = sdsfromlonglong(llele as libc::c_longlong);
2227 } else {
2228 sdsele = sdsdup(sdsele);
2229 }
2230 if newset.is_null() {
2231 newset = setTypeCreate(sdsele);
2232 }
2233 setTypeAdd(newset, sdsele);
2234 setTypeRemove(set, sdsele);
2235 sdsfree(sdsele);
2236 }
2237 let mut si: *mut setTypeIterator = 0 as *mut setTypeIterator;
2238 si = setTypeInitIterator(set);
2239 loop {
2240 encoding = setTypeNext(si, &mut sdsele, &mut llele);
2241 if !(encoding != -(1 as libc::c_int)) {
2242 break;
2243 }
2244 if encoding == 6 as libc::c_int {
2245 addReplyBulkLongLong(c, llele as libc::c_longlong);
2246 objele = createStringObjectFromLongLong(llele as libc::c_longlong);
2247 } else {
2248 addReplyBulkCBuffer(c, sdsele as *const libc::c_void, sdslen(sdsele));
2249 objele = createStringObject(
2250 sdsele as *const libc::c_char,
2251 sdslen(sdsele),
2252 );
2253 }
2254 propargv[2 as libc::c_int as usize] = objele;
2255 alsoPropagate(
2256 (*(*c).db).id,
2257 propargv.as_mut_ptr(),
2258 3 as libc::c_int,
2259 1 as libc::c_int | 2 as libc::c_int,
2260 );
2261 decrRefCount(objele);
2262 }
2263 setTypeReleaseIterator(si);
2264 dbOverwrite((*c).db, *((*c).argv).offset(1 as libc::c_int as isize), newset);
2265 }
2266 preventCommandPropagation(c);
2267 signalModifiedKey(c, (*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
2268}
2269#[no_mangle]
2270pub unsafe extern "C" fn spopCommand(mut c: *mut client) {
2271 let mut set: *mut robj = 0 as *mut robj;
2272 let mut ele: *mut robj = 0 as *mut robj;
2273 let mut sdsele: sds = 0 as *mut libc::c_char;
2274 let mut llele: int64_t = 0;
2275 let mut encoding: libc::c_int = 0;
2276 if (*c).argc == 3 as libc::c_int {
2277 spopWithCountCommand(c);
2278 return;
2279 } else {
2280 if (*c).argc > 3 as libc::c_int {
2281 addReplyErrorObject(c, shared.syntaxerr);
2282 return;
2283 }
2284 }
2285 set = lookupKeyWriteOrReply(
2286 c,
2287 *((*c).argv).offset(1 as libc::c_int as isize),
2288 shared.null[(*c).resp as usize],
2289 );
2290 if set.is_null() || checkType(c, set, 2 as libc::c_int) != 0 {
2291 return;
2292 }
2293 encoding = setTypeRandomElement(set, &mut sdsele, &mut llele);
2294 if encoding == 6 as libc::c_int {
2295 ele = createStringObjectFromLongLong(llele as libc::c_longlong);
2296 (*set)
2297 .ptr = intsetRemove((*set).ptr as *mut intset, llele, 0 as *mut libc::c_int)
2298 as *mut libc::c_void;
2299 } else {
2300 ele = createStringObject(sdsele as *const libc::c_char, sdslen(sdsele));
2301 setTypeRemove(set, (*ele).ptr as sds);
2302 }
2303 notifyKeyspaceEvent(
2304 (1 as libc::c_int) << 5 as libc::c_int,
2305 b"spop\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2306 *((*c).argv).offset(1 as libc::c_int as isize),
2307 (*(*c).db).id,
2308 );
2309 rewriteClientCommandVector(
2310 c,
2311 3 as libc::c_int,
2312 shared.srem,
2313 *((*c).argv).offset(1 as libc::c_int as isize),
2314 ele,
2315 );
2316 addReplyBulk(c, ele);
2317 decrRefCount(ele);
2318 if setTypeSize(set) == 0 as libc::c_int as libc::c_ulong {
2319 dbDelete((*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
2320 notifyKeyspaceEvent(
2321 (1 as libc::c_int) << 2 as libc::c_int,
2322 b"del\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2323 *((*c).argv).offset(1 as libc::c_int as isize),
2324 (*(*c).db).id,
2325 );
2326 }
2327 signalModifiedKey(c, (*c).db, *((*c).argv).offset(1 as libc::c_int as isize));
2328 server.dirty += 1;
2329}
2330#[no_mangle]
2331pub unsafe extern "C" fn srandmemberWithCountCommand(mut c: *mut client) {
2332 let mut l: libc::c_long = 0;
2333 let mut count: libc::c_ulong = 0;
2334 let mut size: libc::c_ulong = 0;
2335 let mut uniq: libc::c_int = 1 as libc::c_int;
2336 let mut set: *mut robj = 0 as *mut robj;
2337 let mut ele: sds = 0 as *mut libc::c_char;
2338 let mut llele: int64_t = 0;
2339 let mut encoding: libc::c_int = 0;
2340 let mut d: *mut dict = 0 as *mut dict;
2341 if getLongFromObjectOrReply(
2342 c,
2343 *((*c).argv).offset(2 as libc::c_int as isize),
2344 &mut l,
2345 0 as *const libc::c_char,
2346 ) != 0 as libc::c_int
2347 {
2348 return;
2349 }
2350 if l >= 0 as libc::c_int as libc::c_long {
2351 count = l as libc::c_ulong;
2352 } else {
2353 count = -l as libc::c_ulong;
2354 uniq = 0 as libc::c_int;
2355 }
2356 set = lookupKeyReadOrReply(
2357 c,
2358 *((*c).argv).offset(1 as libc::c_int as isize),
2359 shared.emptyarray,
2360 );
2361 if set.is_null() || checkType(c, set, 2 as libc::c_int) != 0 {
2362 return;
2363 }
2364 size = setTypeSize(set);
2365 if count == 0 as libc::c_int as libc::c_ulong {
2366 addReply(c, shared.emptyarray);
2367 return;
2368 }
2369 if uniq == 0 || count == 1 as libc::c_int as libc::c_ulong {
2370 addReplyArrayLen(c, count as libc::c_long);
2371 loop {
2372 let fresh3 = count;
2373 count = count.wrapping_sub(1);
2374 if !(fresh3 != 0) {
2375 break;
2376 }
2377 encoding = setTypeRandomElement(set, &mut ele, &mut llele);
2378 if encoding == 6 as libc::c_int {
2379 addReplyBulkLongLong(c, llele as libc::c_longlong);
2380 } else {
2381 addReplyBulkCBuffer(c, ele as *const libc::c_void, sdslen(ele));
2382 }
2383 if (*c).flags & ((1 as libc::c_int) << 10 as libc::c_int) as libc::c_ulong
2384 != 0
2385 {
2386 break;
2387 }
2388 }
2389 return;
2390 }
2391 if count >= size {
2392 let mut si: *mut setTypeIterator = 0 as *mut setTypeIterator;
2393 addReplyArrayLen(c, size as libc::c_long);
2394 si = setTypeInitIterator(set);
2395 loop {
2396 encoding = setTypeNext(si, &mut ele, &mut llele);
2397 if !(encoding != -(1 as libc::c_int)) {
2398 break;
2399 }
2400 if encoding == 6 as libc::c_int {
2401 addReplyBulkLongLong(c, llele as libc::c_longlong);
2402 } else {
2403 addReplyBulkCBuffer(c, ele as *const libc::c_void, sdslen(ele));
2404 }
2405 size = size.wrapping_sub(1);
2406 }
2407 setTypeReleaseIterator(si);
2408 if size == 0 as libc::c_int as libc::c_ulong {} else {
2409 _serverAssert(
2410 b"size==0\0" as *const u8 as *const libc::c_char,
2411 b"t_set.c\0" as *const u8 as *const libc::c_char,
2412 724 as libc::c_int,
2413 );
2414 unreachable!();
2415 };
2416 return;
2417 }
2418 d = dictCreate(&mut sdsReplyDictType);
2419 if count.wrapping_mul(3 as libc::c_int as libc::c_ulong) > size {
2420 let mut si_0: *mut setTypeIterator = 0 as *mut setTypeIterator;
2421 si_0 = setTypeInitIterator(set);
2422 dictExpand(d, size);
2423 loop {
2424 encoding = setTypeNext(si_0, &mut ele, &mut llele);
2425 if !(encoding != -(1 as libc::c_int)) {
2426 break;
2427 }
2428 let mut retval: libc::c_int = 1 as libc::c_int;
2429 if encoding == 6 as libc::c_int {
2430 retval = dictAdd(
2431 d,
2432 sdsfromlonglong(llele as libc::c_longlong) as *mut libc::c_void,
2433 0 as *mut libc::c_void,
2434 );
2435 } else {
2436 retval = dictAdd(
2437 d,
2438 sdsdup(ele) as *mut libc::c_void,
2439 0 as *mut libc::c_void,
2440 );
2441 }
2442 if retval == 0 as libc::c_int {} else {
2443 _serverAssert(
2444 b"retval == DICT_OK\0" as *const u8 as *const libc::c_char,
2445 b"t_set.c\0" as *const u8 as *const libc::c_char,
2446 754 as libc::c_int,
2447 );
2448 unreachable!();
2449 };
2450 }
2451 setTypeReleaseIterator(si_0);
2452 if ((*d).ht_used[0 as libc::c_int as usize])
2453 .wrapping_add((*d).ht_used[1 as libc::c_int as usize]) == size
2454 {} else {
2455 _serverAssert(
2456 b"dictSize(d) == size\0" as *const u8 as *const libc::c_char,
2457 b"t_set.c\0" as *const u8 as *const libc::c_char,
2458 757 as libc::c_int,
2459 );
2460 unreachable!();
2461 };
2462 while size > count {
2463 let mut de: *mut dictEntry = 0 as *mut dictEntry;
2464 de = dictGetFairRandomKey(d);
2465 dictUnlink(d, (*de).key);
2466 sdsfree((*de).key as sds);
2467 dictFreeUnlinkedEntry(d, de);
2468 size = size.wrapping_sub(1);
2469 }
2470 } else {
2471 let mut added: libc::c_ulong = 0 as libc::c_int as libc::c_ulong;
2472 let mut sdsele: sds = 0 as *mut libc::c_char;
2473 dictExpand(d, count);
2474 while added < count {
2475 encoding = setTypeRandomElement(set, &mut ele, &mut llele);
2476 if encoding == 6 as libc::c_int {
2477 sdsele = sdsfromlonglong(llele as libc::c_longlong);
2478 } else {
2479 sdsele = sdsdup(ele);
2480 }
2481 if dictAdd(d, sdsele as *mut libc::c_void, 0 as *mut libc::c_void)
2482 == 0 as libc::c_int
2483 {
2484 added = added.wrapping_add(1);
2485 } else {
2486 sdsfree(sdsele);
2487 }
2488 }
2489 }
2490 let mut di: *mut dictIterator = 0 as *mut dictIterator;
2491 let mut de_0: *mut dictEntry = 0 as *mut dictEntry;
2492 addReplyArrayLen(c, count as libc::c_long);
2493 di = dictGetIterator(d);
2494 loop {
2495 de_0 = dictNext(di);
2496 if de_0.is_null() {
2497 break;
2498 }
2499 addReplyBulkSds(c, (*de_0).key as sds);
2500 }
2501 dictReleaseIterator(di);
2502 dictRelease(d);
2503}
2504#[no_mangle]
2505pub unsafe extern "C" fn srandmemberCommand(mut c: *mut client) {
2506 let mut set: *mut robj = 0 as *mut robj;
2507 let mut ele: sds = 0 as *mut libc::c_char;
2508 let mut llele: int64_t = 0;
2509 let mut encoding: libc::c_int = 0;
2510 if (*c).argc == 3 as libc::c_int {
2511 srandmemberWithCountCommand(c);
2512 return;
2513 } else {
2514 if (*c).argc > 3 as libc::c_int {
2515 addReplyErrorObject(c, shared.syntaxerr);
2516 return;
2517 }
2518 }
2519 set = lookupKeyReadOrReply(
2520 c,
2521 *((*c).argv).offset(1 as libc::c_int as isize),
2522 shared.null[(*c).resp as usize],
2523 );
2524 if set.is_null() || checkType(c, set, 2 as libc::c_int) != 0 {
2525 return;
2526 }
2527 encoding = setTypeRandomElement(set, &mut ele, &mut llele);
2528 if encoding == 6 as libc::c_int {
2529 addReplyBulkLongLong(c, llele as libc::c_longlong);
2530 } else {
2531 addReplyBulkCBuffer(c, ele as *const libc::c_void, sdslen(ele));
2532 };
2533}
2534#[no_mangle]
2535pub unsafe extern "C" fn qsortCompareSetsByCardinality(
2536 mut s1: *const libc::c_void,
2537 mut s2: *const libc::c_void,
2538) -> libc::c_int {
2539 if setTypeSize(*(s1 as *mut *mut robj)) > setTypeSize(*(s2 as *mut *mut robj)) {
2540 return 1 as libc::c_int;
2541 }
2542 if setTypeSize(*(s1 as *mut *mut robj)) < setTypeSize(*(s2 as *mut *mut robj)) {
2543 return -(1 as libc::c_int);
2544 }
2545 return 0 as libc::c_int;
2546}
2547#[no_mangle]
2548pub unsafe extern "C" fn qsortCompareSetsByRevCardinality(
2549 mut s1: *const libc::c_void,
2550 mut s2: *const libc::c_void,
2551) -> libc::c_int {
2552 let mut o1: *mut robj = *(s1 as *mut *mut robj);
2553 let mut o2: *mut robj = *(s2 as *mut *mut robj);
2554 let mut first: libc::c_ulong = if !o1.is_null() {
2555 setTypeSize(o1)
2556 } else {
2557 0 as libc::c_int as libc::c_ulong
2558 };
2559 let mut second: libc::c_ulong = if !o2.is_null() {
2560 setTypeSize(o2)
2561 } else {
2562 0 as libc::c_int as libc::c_ulong
2563 };
2564 if first < second {
2565 return 1 as libc::c_int;
2566 }
2567 if first > second {
2568 return -(1 as libc::c_int);
2569 }
2570 return 0 as libc::c_int;
2571}
2572#[no_mangle]
2573pub unsafe extern "C" fn sinterGenericCommand(
2574 mut c: *mut client,
2575 mut setkeys: *mut *mut robj,
2576 mut setnum: libc::c_ulong,
2577 mut dstkey: *mut robj,
2578 mut cardinality_only: libc::c_int,
2579 mut limit: libc::c_ulong,
2580) {
2581 let mut sets: *mut *mut robj = zmalloc(
2582 (core::mem::size_of::<*mut robj>() as libc::c_ulong).wrapping_mul(setnum),
2583 ) as *mut *mut robj;
2584 let mut si: *mut setTypeIterator = 0 as *mut setTypeIterator;
2585 let mut dstset: *mut robj = 0 as *mut robj;
2586 let mut elesds: sds = 0 as *mut libc::c_char;
2587 let mut intobj: int64_t = 0;
2588 let mut replylen: *mut libc::c_void = 0 as *mut libc::c_void;
2589 let mut j: libc::c_ulong = 0;
2590 let mut cardinality: libc::c_ulong = 0 as libc::c_int as libc::c_ulong;
2591 let mut encoding: libc::c_int = 0;
2592 let mut empty: libc::c_int = 0 as libc::c_int;
2593 j = 0 as libc::c_int as libc::c_ulong;
2594 while j < setnum {
2595 let mut setobj: *mut robj = lookupKeyRead((*c).db, *setkeys.offset(j as isize));
2596 if setobj.is_null() {
2597 empty += 1 as libc::c_int;
2598 let ref mut fresh4 = *sets.offset(j as isize);
2599 *fresh4 = 0 as *mut robj;
2600 } else {
2601 if checkType(c, setobj, 2 as libc::c_int) != 0 {
2602 zfree(sets as *mut libc::c_void);
2603 return;
2604 }
2605 let ref mut fresh5 = *sets.offset(j as isize);
2606 *fresh5 = setobj;
2607 }
2608 j = j.wrapping_add(1);
2609 }
2610 if empty > 0 as libc::c_int {
2611 zfree(sets as *mut libc::c_void);
2612 if !dstkey.is_null() {
2613 if dbDelete((*c).db, dstkey) != 0 {
2614 signalModifiedKey(c, (*c).db, dstkey);
2615 notifyKeyspaceEvent(
2616 (1 as libc::c_int) << 2 as libc::c_int,
2617 b"del\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2618 dstkey,
2619 (*(*c).db).id,
2620 );
2621 server.dirty += 1;
2622 }
2623 addReply(c, shared.czero);
2624 } else if cardinality_only != 0 {
2625 addReplyLongLong(c, cardinality as libc::c_longlong);
2626 } else {
2627 addReply(c, shared.emptyset[(*c).resp as usize]);
2628 }
2629 return;
2630 }
2631 qsort(
2632 sets as *mut libc::c_void,
2633 setnum,
2634 core::mem::size_of::<*mut robj>() as libc::c_ulong,
2635 Some(
2636 qsortCompareSetsByCardinality
2637 as unsafe extern "C" fn(
2638 *const libc::c_void,
2639 *const libc::c_void,
2640 ) -> libc::c_int,
2641 ),
2642 );
2643 if !dstkey.is_null() {
2644 dstset = createIntsetObject();
2645 } else if cardinality_only == 0 {
2646 replylen = addReplyDeferredLen(c);
2647 }
2648 si = setTypeInitIterator(*sets.offset(0 as libc::c_int as isize));
2649 loop {
2650 encoding = setTypeNext(si, &mut elesds, &mut intobj);
2651 if !(encoding != -(1 as libc::c_int)) {
2652 break;
2653 }
2654 j = 1 as libc::c_int as libc::c_ulong;
2655 while j < setnum {
2656 if !(*sets.offset(j as isize) == *sets.offset(0 as libc::c_int as isize)) {
2657 if encoding == 6 as libc::c_int {
2658 if (**sets.offset(j as isize)).encoding() as libc::c_int
2659 == 6 as libc::c_int
2660 && intsetFind(
2661 (**sets.offset(j as isize)).ptr as *mut intset,
2662 intobj,
2663 ) == 0
2664 {
2665 break;
2666 }
2667 if (**sets.offset(j as isize)).encoding() as libc::c_int
2668 == 2 as libc::c_int
2669 {
2670 elesds = sdsfromlonglong(intobj as libc::c_longlong);
2671 if setTypeIsMember(*sets.offset(j as isize), elesds) == 0 {
2672 sdsfree(elesds);
2673 break;
2674 } else {
2675 sdsfree(elesds);
2676 }
2677 }
2678 } else if encoding == 2 as libc::c_int {
2679 if setTypeIsMember(*sets.offset(j as isize), elesds) == 0 {
2680 break;
2681 }
2682 }
2683 }
2684 j = j.wrapping_add(1);
2685 }
2686 if !(j == setnum) {
2687 continue;
2688 }
2689 if cardinality_only != 0 {
2690 cardinality = cardinality.wrapping_add(1);
2691 if limit != 0 && cardinality >= limit {
2692 break;
2693 }
2694 } else if dstkey.is_null() {
2695 if encoding == 2 as libc::c_int {
2696 addReplyBulkCBuffer(c, elesds as *const libc::c_void, sdslen(elesds));
2697 } else {
2698 addReplyBulkLongLong(c, intobj as libc::c_longlong);
2699 }
2700 cardinality = cardinality.wrapping_add(1);
2701 } else if encoding == 6 as libc::c_int {
2702 elesds = sdsfromlonglong(intobj as libc::c_longlong);
2703 setTypeAdd(dstset, elesds);
2704 sdsfree(elesds);
2705 } else {
2706 setTypeAdd(dstset, elesds);
2707 }
2708 }
2709 setTypeReleaseIterator(si);
2710 if cardinality_only != 0 {
2711 addReplyLongLong(c, cardinality as libc::c_longlong);
2712 } else if !dstkey.is_null() {
2713 if setTypeSize(dstset) > 0 as libc::c_int as libc::c_ulong {
2714 setKey(c, (*c).db, dstkey, dstset, 0 as libc::c_int);
2715 addReplyLongLong(c, setTypeSize(dstset) as libc::c_longlong);
2716 notifyKeyspaceEvent(
2717 (1 as libc::c_int) << 5 as libc::c_int,
2718 b"sinterstore\0" as *const u8 as *const libc::c_char
2719 as *mut libc::c_char,
2720 dstkey,
2721 (*(*c).db).id,
2722 );
2723 server.dirty += 1;
2724 } else {
2725 addReply(c, shared.czero);
2726 if dbDelete((*c).db, dstkey) != 0 {
2727 server.dirty += 1;
2728 signalModifiedKey(c, (*c).db, dstkey);
2729 notifyKeyspaceEvent(
2730 (1 as libc::c_int) << 2 as libc::c_int,
2731 b"del\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2732 dstkey,
2733 (*(*c).db).id,
2734 );
2735 }
2736 }
2737 decrRefCount(dstset);
2738 } else {
2739 setDeferredSetLen(c, replylen, cardinality as libc::c_long);
2740 }
2741 zfree(sets as *mut libc::c_void);
2742}
2743#[no_mangle]
2744pub unsafe extern "C" fn sinterCommand(mut c: *mut client) {
2745 sinterGenericCommand(
2746 c,
2747 ((*c).argv).offset(1 as libc::c_int as isize),
2748 ((*c).argc - 1 as libc::c_int) as libc::c_ulong,
2749 0 as *mut robj,
2750 0 as libc::c_int,
2751 0 as libc::c_int as libc::c_ulong,
2752 );
2753}
2754#[no_mangle]
2755pub unsafe extern "C" fn sinterCardCommand(mut c: *mut client) {
2756 let mut j: libc::c_long = 0;
2757 let mut numkeys: libc::c_long = 0 as libc::c_int as libc::c_long;
2758 let mut limit: libc::c_long = 0 as libc::c_int as libc::c_long;
2759 if getRangeLongFromObjectOrReply(
2760 c,
2761 *((*c).argv).offset(1 as libc::c_int as isize),
2762 1 as libc::c_int as libc::c_long,
2763 9223372036854775807 as libc::c_long,
2764 &mut numkeys,
2765 b"numkeys should be greater than 0\0" as *const u8 as *const libc::c_char,
2766 ) != 0 as libc::c_int
2767 {
2768 return;
2769 }
2770 if numkeys > ((*c).argc - 2 as libc::c_int) as libc::c_long {
2771 addReplyError(
2772 c,
2773 b"Number of keys can't be greater than number of args\0" as *const u8
2774 as *const libc::c_char,
2775 );
2776 return;
2777 }
2778 j = 2 as libc::c_int as libc::c_long + numkeys;
2779 while j < (*c).argc as libc::c_long {
2780 let mut opt: *mut libc::c_char = (**((*c).argv).offset(j as isize)).ptr
2781 as *mut libc::c_char;
2782 let mut moreargs: libc::c_int = (((*c).argc - 1 as libc::c_int) as libc::c_long
2783 - j) as libc::c_int;
2784 if strcasecmp(opt, b"LIMIT\0" as *const u8 as *const libc::c_char) == 0
2785 && moreargs != 0
2786 {
2787 j += 1;
2788 if getPositiveLongFromObjectOrReply(
2789 c,
2790 *((*c).argv).offset(j as isize),
2791 &mut limit,
2792 b"LIMIT can't be negative\0" as *const u8 as *const libc::c_char,
2793 ) != 0 as libc::c_int
2794 {
2795 return;
2796 }
2797 } else {
2798 addReplyErrorObject(c, shared.syntaxerr);
2799 return;
2800 }
2801 j += 1;
2802 }
2803 sinterGenericCommand(
2804 c,
2805 ((*c).argv).offset(2 as libc::c_int as isize),
2806 numkeys as libc::c_ulong,
2807 0 as *mut robj,
2808 1 as libc::c_int,
2809 limit as libc::c_ulong,
2810 );
2811}
2812#[no_mangle]
2813pub unsafe extern "C" fn sinterstoreCommand(mut c: *mut client) {
2814 sinterGenericCommand(
2815 c,
2816 ((*c).argv).offset(2 as libc::c_int as isize),
2817 ((*c).argc - 2 as libc::c_int) as libc::c_ulong,
2818 *((*c).argv).offset(1 as libc::c_int as isize),
2819 0 as libc::c_int,
2820 0 as libc::c_int as libc::c_ulong,
2821 );
2822}
2823#[no_mangle]
2824pub unsafe extern "C" fn sunionDiffGenericCommand(
2825 mut c: *mut client,
2826 mut setkeys: *mut *mut robj,
2827 mut setnum: libc::c_int,
2828 mut dstkey: *mut robj,
2829 mut op: libc::c_int,
2830) {
2831 let mut sets: *mut *mut robj = zmalloc(
2832 (core::mem::size_of::<*mut robj>() as libc::c_ulong)
2833 .wrapping_mul(setnum as libc::c_ulong),
2834 ) as *mut *mut robj;
2835 let mut si: *mut setTypeIterator = 0 as *mut setTypeIterator;
2836 let mut dstset: *mut robj = 0 as *mut robj;
2837 let mut ele: sds = 0 as *mut libc::c_char;
2838 let mut j: libc::c_int = 0;
2839 let mut cardinality: libc::c_int = 0 as libc::c_int;
2840 let mut diff_algo: libc::c_int = 1 as libc::c_int;
2841 let mut sameset: libc::c_int = 0 as libc::c_int;
2842 j = 0 as libc::c_int;
2843 while j < setnum {
2844 let mut setobj: *mut robj = lookupKeyRead((*c).db, *setkeys.offset(j as isize));
2845 if setobj.is_null() {
2846 let ref mut fresh6 = *sets.offset(j as isize);
2847 *fresh6 = 0 as *mut robj;
2848 } else {
2849 if checkType(c, setobj, 2 as libc::c_int) != 0 {
2850 zfree(sets as *mut libc::c_void);
2851 return;
2852 }
2853 let ref mut fresh7 = *sets.offset(j as isize);
2854 *fresh7 = setobj;
2855 if j > 0 as libc::c_int
2856 && *sets.offset(0 as libc::c_int as isize) == *sets.offset(j as isize)
2857 {
2858 sameset = 1 as libc::c_int;
2859 }
2860 }
2861 j += 1;
2862 }
2863 if op == 1 as libc::c_int && !(*sets.offset(0 as libc::c_int as isize)).is_null()
2864 && sameset == 0
2865 {
2866 let mut algo_one_work: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
2867 let mut algo_two_work: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
2868 j = 0 as libc::c_int;
2869 while j < setnum {
2870 if !(*sets.offset(j as isize)).is_null() {
2871 algo_one_work = (algo_one_work as libc::c_ulonglong)
2872 .wrapping_add(
2873 setTypeSize(*sets.offset(0 as libc::c_int as isize))
2874 as libc::c_ulonglong,
2875 ) as libc::c_longlong as libc::c_longlong;
2876 algo_two_work = (algo_two_work as libc::c_ulonglong)
2877 .wrapping_add(
2878 setTypeSize(*sets.offset(j as isize)) as libc::c_ulonglong,
2879 ) as libc::c_longlong as libc::c_longlong;
2880 }
2881 j += 1;
2882 }
2883 algo_one_work /= 2 as libc::c_int as libc::c_longlong;
2884 diff_algo = if algo_one_work <= algo_two_work {
2885 1 as libc::c_int
2886 } else {
2887 2 as libc::c_int
2888 };
2889 if diff_algo == 1 as libc::c_int && setnum > 1 as libc::c_int {
2890 qsort(
2891 sets.offset(1 as libc::c_int as isize) as *mut libc::c_void,
2892 (setnum - 1 as libc::c_int) as size_t,
2893 core::mem::size_of::<*mut robj>() as libc::c_ulong,
2894 Some(
2895 qsortCompareSetsByRevCardinality
2896 as unsafe extern "C" fn(
2897 *const libc::c_void,
2898 *const libc::c_void,
2899 ) -> libc::c_int,
2900 ),
2901 );
2902 }
2903 }
2904 dstset = createIntsetObject();
2905 if op == 0 as libc::c_int {
2906 j = 0 as libc::c_int;
2907 while j < setnum {
2908 if !(*sets.offset(j as isize)).is_null() {
2909 si = setTypeInitIterator(*sets.offset(j as isize));
2910 loop {
2911 ele = setTypeNextObject(si);
2912 if ele.is_null() {
2913 break;
2914 }
2915 if setTypeAdd(dstset, ele) != 0 {
2916 cardinality += 1;
2917 }
2918 sdsfree(ele);
2919 }
2920 setTypeReleaseIterator(si);
2921 }
2922 j += 1;
2923 }
2924 } else if !(op == 1 as libc::c_int && sameset != 0) {
2925 if op == 1 as libc::c_int && !(*sets.offset(0 as libc::c_int as isize)).is_null()
2926 && diff_algo == 1 as libc::c_int
2927 {
2928 si = setTypeInitIterator(*sets.offset(0 as libc::c_int as isize));
2929 loop {
2930 ele = setTypeNextObject(si);
2931 if ele.is_null() {
2932 break;
2933 }
2934 j = 1 as libc::c_int;
2935 while j < setnum {
2936 if !(*sets.offset(j as isize)).is_null() {
2937 if *sets.offset(j as isize)
2938 == *sets.offset(0 as libc::c_int as isize)
2939 {
2940 break;
2941 }
2942 if setTypeIsMember(*sets.offset(j as isize), ele) != 0 {
2943 break;
2944 }
2945 }
2946 j += 1;
2947 }
2948 if j == setnum {
2949 setTypeAdd(dstset, ele);
2950 cardinality += 1;
2951 }
2952 sdsfree(ele);
2953 }
2954 setTypeReleaseIterator(si);
2955 } else if op == 1 as libc::c_int
2956 && !(*sets.offset(0 as libc::c_int as isize)).is_null()
2957 && diff_algo == 2 as libc::c_int
2958 {
2959 j = 0 as libc::c_int;
2960 while j < setnum {
2961 if !(*sets.offset(j as isize)).is_null() {
2962 si = setTypeInitIterator(*sets.offset(j as isize));
2963 loop {
2964 ele = setTypeNextObject(si);
2965 if ele.is_null() {
2966 break;
2967 }
2968 if j == 0 as libc::c_int {
2969 if setTypeAdd(dstset, ele) != 0 {
2970 cardinality += 1;
2971 }
2972 } else if setTypeRemove(dstset, ele) != 0 {
2973 cardinality -= 1;
2974 }
2975 sdsfree(ele);
2976 }
2977 setTypeReleaseIterator(si);
2978 if cardinality == 0 as libc::c_int {
2979 break;
2980 }
2981 }
2982 j += 1;
2983 }
2984 }
2985 }
2986 if dstkey.is_null() {
2987 addReplySetLen(c, cardinality as libc::c_long);
2988 si = setTypeInitIterator(dstset);
2989 loop {
2990 ele = setTypeNextObject(si);
2991 if ele.is_null() {
2992 break;
2993 }
2994 addReplyBulkCBuffer(c, ele as *const libc::c_void, sdslen(ele));
2995 sdsfree(ele);
2996 }
2997 setTypeReleaseIterator(si);
2998 if server.lazyfree_lazy_server_del != 0 {
2999 freeObjAsync(0 as *mut robj, dstset, -(1 as libc::c_int));
3000 } else {
3001 decrRefCount(dstset);
3002 };
3003 } else {
3004 if setTypeSize(dstset) > 0 as libc::c_int as libc::c_ulong {
3005 setKey(c, (*c).db, dstkey, dstset, 0 as libc::c_int);
3006 addReplyLongLong(c, setTypeSize(dstset) as libc::c_longlong);
3007 notifyKeyspaceEvent(
3008 (1 as libc::c_int) << 5 as libc::c_int,
3009 (if op == 0 as libc::c_int {
3010 b"sunionstore\0" as *const u8 as *const libc::c_char
3011 } else {
3012 b"sdiffstore\0" as *const u8 as *const libc::c_char
3013 }) as *mut libc::c_char,
3014 dstkey,
3015 (*(*c).db).id,
3016 );
3017 server.dirty += 1;
3018 } else {
3019 addReply(c, shared.czero);
3020 if dbDelete((*c).db, dstkey) != 0 {
3021 server.dirty += 1;
3022 signalModifiedKey(c, (*c).db, dstkey);
3023 notifyKeyspaceEvent(
3024 (1 as libc::c_int) << 2 as libc::c_int,
3025 b"del\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3026 dstkey,
3027 (*(*c).db).id,
3028 );
3029 }
3030 }
3031 decrRefCount(dstset);
3032 }
3033 zfree(sets as *mut libc::c_void);
3034}
3035#[no_mangle]
3036pub unsafe extern "C" fn sunionCommand(mut c: *mut client) {
3037 sunionDiffGenericCommand(
3038 c,
3039 ((*c).argv).offset(1 as libc::c_int as isize),
3040 (*c).argc - 1 as libc::c_int,
3041 0 as *mut robj,
3042 0 as libc::c_int,
3043 );
3044}
3045#[no_mangle]
3046pub unsafe extern "C" fn sunionstoreCommand(mut c: *mut client) {
3047 sunionDiffGenericCommand(
3048 c,
3049 ((*c).argv).offset(2 as libc::c_int as isize),
3050 (*c).argc - 2 as libc::c_int,
3051 *((*c).argv).offset(1 as libc::c_int as isize),
3052 0 as libc::c_int,
3053 );
3054}
3055#[no_mangle]
3056pub unsafe extern "C" fn sdiffCommand(mut c: *mut client) {
3057 sunionDiffGenericCommand(
3058 c,
3059 ((*c).argv).offset(1 as libc::c_int as isize),
3060 (*c).argc - 1 as libc::c_int,
3061 0 as *mut robj,
3062 1 as libc::c_int,
3063 );
3064}
3065#[no_mangle]
3066pub unsafe extern "C" fn sdiffstoreCommand(mut c: *mut client) {
3067 sunionDiffGenericCommand(
3068 c,
3069 ((*c).argv).offset(2 as libc::c_int as isize),
3070 (*c).argc - 2 as libc::c_int,
3071 *((*c).argv).offset(1 as libc::c_int as isize),
3072 1 as libc::c_int,
3073 );
3074}
3075#[no_mangle]
3076pub unsafe extern "C" fn sscanCommand(mut c: *mut client) {
3077 let mut set: *mut robj = 0 as *mut robj;
3078 let mut cursor: libc::c_ulong = 0;
3079 if parseScanCursorOrReply(
3080 c,
3081 *((*c).argv).offset(2 as libc::c_int as isize),
3082 &mut cursor,
3083 ) == -(1 as libc::c_int)
3084 {
3085 return;
3086 }
3087 set = lookupKeyReadOrReply(
3088 c,
3089 *((*c).argv).offset(1 as libc::c_int as isize),
3090 shared.emptyscan,
3091 );
3092 if set.is_null() || checkType(c, set, 2 as libc::c_int) != 0 {
3093 return;
3094 }
3095 scanGenericCommand(c, set, cursor);
3096}