st_uint
st_input_get_line (st_input *input)
{
st_assert (input != NULL);
return input->line;
}
st_uint
st_input_index (st_input *input)
{
st_assert (input != NULL);
return input->p;
}
st_uint
st_input_size (st_input *input)
{
st_assert (input != NULL);
return input->n;
}
st_uint
st_input_get_column (st_input *input)
{
st_assert (input != NULL);
return input->column;
}
static st_oop
block_context_new (st_machine *machine, st_uint initial_ip, st_uint argcount)
{
st_oop home;
st_oop context;
st_oop method;
st_oop *stack;
st_uint stack_size;
stack_size = 32;
context = st_memory_allocate (ST_SIZE_OOPS (struct st_block_context) + stack_size);
if (context == 0) {
st_memory_perform_gc ();
context = st_memory_allocate (ST_SIZE_OOPS (struct st_block_context) + stack_size);
st_assert (context != 0);
}
st_object_initialize_header (context, ST_BLOCK_CONTEXT_CLASS);
if (ST_OBJECT_CLASS (machine->context) == ST_BLOCK_CONTEXT_CLASS)
home = ST_BLOCK_CONTEXT_HOME (machine->context);
else
home = machine->context;
ST_CONTEXT_PART_SENDER (context) = ST_NIL;
ST_CONTEXT_PART_IP (context) = st_smi_new (0);
ST_CONTEXT_PART_SP (context) = st_smi_new (0);
ST_BLOCK_CONTEXT_INITIALIP (context) = st_smi_new (initial_ip);
ST_BLOCK_CONTEXT_ARGCOUNT (context) = st_smi_new (argcount);
ST_BLOCK_CONTEXT_HOME (context) = home;
return context;
}
static void
create_actual_message (st_machine *machine)
{
st_oop *elements;
st_oop message;
st_oop array;
array = st_object_new_arrayed (ST_ARRAY_CLASS, machine->message_argcount);
elements = st_array_elements (array);
for (st_uint i = 0; i < machine->message_argcount; i++)
elements[i] = machine->stack[machine->sp - machine->message_argcount + i];
machine->sp -= machine->message_argcount;
message = st_object_new (ST_MESSAGE_CLASS);
if (message == 0) {
st_memory_perform_gc ();
message = st_object_new (ST_MESSAGE_CLASS);
st_assert (message != 0);
}
ST_OBJECT_FIELDS (message)[0] = machine->message_selector;
ST_OBJECT_FIELDS (message)[1] = array;
ST_STACK_PUSH (machine, message);
machine->message_selector = ST_SELECTOR_DOESNOTUNDERSTAND;
machine->message_argcount = 1;
}
void
st_input_destroy (st_input *input)
{
st_assert (input != NULL);
st_free (input->text);
st_free (input);
}
void
st_input_mark (st_input *input)
{
st_assert (input != NULL);
input->marker.p = input->p;
input->marker.line = input->line;
input->marker.column = input->column;
}
void
st_input_rewind (st_input *input)
{
st_assert (input != NULL);
st_input_seek (input, input->marker.p);
input->line = input->marker.line;
input->column = input->marker.column;
}
void
st_input_seek (st_input *input, st_uint index)
{
st_assert (input != NULL);
if (index <= input->p) {
input->p = index;
}
while (input->p < index)
st_input_consume (input);
}
st_input *
st_input_new (const char *string)
{
st_input *input;
st_assert (string != NULL);
input = st_new0 (st_input);
initialize_state (input, strdup (string));
return input;
}
void SchedulerTestFixture::testSchedulerLeaks() {
MWTime howlongus = 1000;
shared_ptr<ScheduleTask> node;
st_assert("node is not initialized correctly", node == 0);
st_assert("node is not initialized correctly", node.use_count() == 0);
shared_ptr<Scheduler> scheduler = Scheduler::instance();
node = scheduler->scheduleUS(FILELINE,
howlongus,
0,
1,
boost::bind(test_for_leaks),
M_DEFAULT_PRIORITY,
M_DEFAULT_WARN_SLOP_US,
M_DEFAULT_FAIL_SLOP_US,
M_MISSED_EXECUTION_CATCH_UP);
sleep(5);
st_assert("something is wrong at this point", bool(node));
st_assert("node should have one reference at this point", node.use_count() == 1);
}
char *
st_input_range (st_input *input, st_uint start, st_uint end)
{
char *buf;
st_uint len;
st_assert ((end - start) >= 0);
len = end - start;
buf = st_malloc (len + 1);
memcpy (buf, input->text + start, len);
buf[len] = 0;
return buf;
}
void
st_input_consume (st_input *input)
{
st_assert (input != NULL);
if (input->p < input->n) {
input->column++;
/* 0x000A is newline */
if (input->text[input->p] == 0x000A) {
input->line++;
input->column = 1;
}
input->p++;
}
}
char
st_input_look_ahead (st_input *input, int i)
{
st_assert (input != NULL);
if (ST_UNLIKELY (i == 0)) {
return 0x0000;
}
if (ST_UNLIKELY (i < 0)) {
i++;
if ((input->p + i - 1) < 0)
return ST_INPUT_EOF;
}
if ((input->p + i - 1) >= input->n) {
return ST_INPUT_EOF;
}
return input->text[input->p + i - 1];
}
void *test_for_leaks() {
usleep(1000);
st_assert("test assert", true);
return 0;
}
