char *
str_replace (const char *haystack, const char *needle, const char *replacement)
{
assert (haystack != NULL);
assert (needle != NULL);
assert (replacement != NULL);
string_buffer_t *sb = string_buffer_create ();
size_t haystack_len = strlen (haystack);
size_t needle_len = strlen (needle);
int pos = 0;
while (pos < haystack_len) {
if (needle_len > 0 && str_starts_with (&haystack[pos], needle)) {
string_buffer_append_string (sb, replacement);
pos += needle_len;
}
else {
string_buffer_append (sb, haystack[pos]);
pos++;
}
}
if (needle_len == 0 && haystack_len == 0)
string_buffer_append_string (sb, replacement);
char *res = string_buffer_to_string (sb);
string_buffer_destroy (sb);
return res;
}
void
string_buffer_appendf (string_buffer_t *sb, const char *fmt, ...)
{
assert (sb != NULL);
assert (fmt != NULL);
int size = MIN_PRINTF_ALLOC;
char *buf = malloc (size * sizeof(char));
int returnsize;
va_list args;
va_start (args,fmt);
returnsize = vsnprintf (buf, size, fmt, args);
va_end (args);
if (returnsize >= size) {
// otherwise, we should try again
free (buf);
size = returnsize + 1;
buf = malloc (size * sizeof(char));
va_start (args, fmt);
returnsize = vsnprintf (buf, size, fmt, args);
va_end (args);
}
string_buffer_append_string (sb, buf);
free (buf);
}
char *js_get_message(jsval v) {
jsval messages, msg, rval;
uint32_t messages_len;
char *c_str;
int i;
struct string_buffer sb = STRING_BUFFER_INITIALIZER;
if (!JS_GetProperty(js_context, JSVAL_TO_OBJECT(v), "messages", &messages)) {
return NULL;
}
switch(JS_TypeOfValue(js_context, messages)) {
case JSTYPE_STRING:
c_str = JS_EncodeString(js_context, JSVAL_TO_STRING(messages));
return c_str;
case JSTYPE_OBJECT:
if (!JS_GetArrayLength(js_context, JSVAL_TO_OBJECT(messages), &messages_len)) {
return NULL;
}
for (i = 0; i < (int) messages_len; i++) {
if (!JS_GetElement(js_context, JSVAL_TO_OBJECT(messages), i, &msg)) {
goto out_err;
}
c_str = JS_EncodeString(js_context, JSVAL_TO_STRING(msg));
if (string_buffer_append_string(&sb, c_str))
goto out_err;
if (i < (int) messages_len - 1) {
if (string_buffer_append_char(&sb, '\n'))
goto out_err;
}
free(c_str);
}
return sb.s;
default:
break;
}
out_err:
free(c_str);
string_buffer_cleanup(&sb);
return NULL;
}
void string_buffer_append_unichar(StringBuffer * sbuffer, gunichar c)
{
char buf[6];
int bytes = g_unichar_to_utf8(c, &buf);
string_buffer_append_string(sbuffer, &buf, bytes);
}
void session_run_with_nick(struct room *room, struct lock *roomLock, struct reader *reader, struct writer *writer, struct string_buffer *nick)
/*@
requires
locked(roomLock, ?roomLockId, room_ctor(room), currentThread, _) &*& lockset(currentThread, cons(roomLockId, nil)) &*&
room(room) &*& reader(reader) &*& writer(writer) &*& string_buffer(nick, _);
@*/
/*@
ensures
[_]lock(roomLock, roomLockId, room_ctor(room)) &*& lockset(currentThread, nil) &*&
reader(reader) &*& writer(writer) &*& string_buffer(nick, _);
@*/
{
struct member *member = 0;
struct string_buffer *joinMessage = create_string_buffer();
string_buffer_append_string_buffer(joinMessage, nick);
string_buffer_append_string(joinMessage, " has joined the room.");
room_broadcast_message(room, joinMessage);
string_buffer_dispose(joinMessage);
{
struct string_buffer *nickCopy = string_buffer_copy(nick);
//@ open room(room);
member = malloc(sizeof(struct member));
if (member == 0) {
abort();
}
member->nick = nickCopy;
member->writer = writer;
//@ split_fraction member_writer(member, _) by 1/2;
//@ close member(member);
//@ assert room->members |-> ?list &*& lseg(list, 0, ?members, @member);
member->next = room->members;
room->members = member;
//@ open member_next(member, _);
//@ close lseg(member, 0, cons(member, members), @member);
//@ assert [_]room->ghost_list_id |-> ?id;
//@ split_fraction room_ghost_list_id(room, id);
//@ ghost_list_add(id, member);
//@ close room(room);
}
//@ close room_ctor(room)();
lock_release(roomLock);
//@ leak [_]lock(roomLock, roomLockId, room_ctor(room));
{
bool eof = false;
struct string_buffer *message = create_string_buffer();
while (!eof)
//@ invariant reader(reader) &*& string_buffer(nick, _) &*& string_buffer(message, _) &*& [_]lock(roomLock, roomLockId, room_ctor(room)) &*& lockset(currentThread, nil);
{
eof = reader_read_line(reader, message);
if (eof) {
} else {
lock_acquire(roomLock);
//@ open room_ctor(room)();
{
struct string_buffer *fullMessage = create_string_buffer();
string_buffer_append_string_buffer(fullMessage, nick);
string_buffer_append_string(fullMessage, " says: ");
string_buffer_append_string_buffer(fullMessage, message);
room_broadcast_message(room, fullMessage);
string_buffer_dispose(fullMessage);
}
//@ close room_ctor(room)();
lock_release(roomLock);
}
}
string_buffer_dispose(message);
}
lock_acquire(roomLock);
//@ open room_ctor(room)();
//@ open room(room);
{
struct member *membersList = room->members;
//@ open room_members(room, _);
//@ assert lseg(membersList, 0, ?members, @member);
//@ assert [_]ghost_list_member_handle(?id, ?d);
//@ ghost_list_member_handle_lemma(id, d);
lseg_remove(&room->members, member);
//@ assert pointer(&room->members, ?list);
//@ close room_members(room, list);
//@ assert pointer((void *)member, ?memberNext);
//@ close member_next(member, memberNext);
}
//@ assert ghost_list(?id, _);
//@ ghost_list_remove(id, member);
//@ close room(room);
{
struct string_buffer *goodbyeMessage = create_string_buffer();
string_buffer_append_string_buffer(goodbyeMessage, nick);
string_buffer_append_string(goodbyeMessage, " left the room.");
room_broadcast_message(room, goodbyeMessage);
string_buffer_dispose(goodbyeMessage);
}
//@ close room_ctor(room)();
lock_release(roomLock);
//@ open member(member);
string_buffer_dispose(member->nick);
free(member);
}
int main() {
int32_t x, y;
uint32_t a, b, n;
char c;
string_buffer_t *s;
s = &buffer;
init_string_buffer(s, 0);
show_test("empty buffer", s);
string_buffer_reset(s);
for (c = 'a'; c <= 'z'; c++) {
string_buffer_append_char(s, c);
}
show_test("alphabet", s);
string_buffer_reset(s);
for (c = 'a'; c <= 'z'; c++) {
string_buffer_append_char(s, c);
}
string_buffer_append_string(s, "au898ue2bcc90219");
show_test("alphabet+au898ue2bcc90219", s);
x = INT32_MIN;
for (;;){
sprintf(aux, "signed number: %" PRId32, x);
string_buffer_reset(s);
string_buffer_append_int32(s, x);
show_test(aux, s);
y = x >> 1;
if (y == x) break;
x = y;
}
x = INT32_MAX;
for (;;) {
sprintf(aux, "signed number: %" PRId32, x);
string_buffer_reset(s);
string_buffer_append_int32(s, x);
show_test(aux, s);
y = x>>1;
if (y == x) break;
x = y;
}
a = UINT32_MAX;
for (;;){
sprintf(aux, "unsigned number: %" PRIu32, a);
string_buffer_reset(s);
string_buffer_append_uint32(s, a);
show_test(aux, s);
b = a >> 1;
if (b == a) break;
a = b;
}
mpz_init(z0);
mpz_init(z1);
mpq_init(q0);
mpz_set_str(z0, "111102222033330123456789", 10);
string_buffer_reset(s);
string_buffer_append_mpz(s, z0);
show_test("mpz: 111102222033330123456789", s);
mpz_set_str(z0, "-111102222033330123456789", 10);
string_buffer_reset(s);
string_buffer_append_mpz(s, z0);
show_test("mpz: -111102222033330123456789", s);
string_buffer_reset(s);
string_buffer_append_mpz(s, z1);
show_test("mpz: 0", s);
mpq_set_str(q0, "-98765432109876543210", 10);
string_buffer_reset(s);
string_buffer_append_mpq(s, q0);
show_test("mpq: -98765432109876543210", s);
mpq_set_str(q0, "-98765432109876543210/38192839777", 10);
string_buffer_reset(s);
string_buffer_append_mpq(s, q0);
show_test("mpq: -98765432109876543210/38192839777", s);
init_rationals();
rational_t r0;
q_init(&r0);
string_buffer_reset(s);
string_buffer_append_rational(s, &r0);
show_test("rational: 0", s);
q_set_int32(&r0, -12, 73);
string_buffer_reset(s);
string_buffer_append_rational(s, &r0);
show_test("rational: -12/73", s);
q_set_mpq(&r0, q0);
string_buffer_reset(s);
string_buffer_append_rational(s, &r0);
show_test("rational: -98765432109876543210/38192839777", s);
q_set_mpz(&r0, z0);
string_buffer_reset(s);
string_buffer_append_rational(s, &r0);
show_test("rational: -111102222033330123456789", s);
printf("\nBit Vectors\n");
init_bvconstants();
bv0 = bvconst_alloc(1);
bvconst_clear(bv0, 1);
for (n=1; n<= 32; n++) {
string_buffer_reset(s);
string_buffer_append_bvconst(s, bv0, n);
sprintf(aux, "bv[%" PRIu32"]: 0b000...", n);
show_test(aux, s);
}
for (n=1; n <= 32; n++) {
bvconst_clear(bv0, 1);
bvconst_set_bit(bv0, n-1);
string_buffer_reset(s);
string_buffer_append_bvconst(s, bv0, n);
sprintf(aux, "bv[%" PRIu32"]: 0b100...", n);
show_test(aux, s);
}
bvconst_free(bv0, 1);
cleanup_bvconstants();
cleanup_rationals();
mpz_clear(z0);
mpz_clear(z1);
mpq_clear(q0);
delete_string_buffer(s);
return 0;
}
