inline void latch_interrupt (void)
{
delay(2);
//fprintf (stdout, "%lu|", latch_counter);
if ((botcfg.state == STATE_MACRO) && (macro1.next_latch == latch_counter - 1))
{
set_inputs (PIN_BASE, p1.input);
pb_read_next (¯o1);
}
else if ((botcfg.state == STATE_PLAYBACK) && (playback.next_latch == latch_counter))
{
//We are due to load up the next set of inputs
set_inputs(PIN_BASE, p1.input);
playback_read_next ();
}
else if (botcfg.state == STATE_RECORDING && p1.input != p1.input_old)
{
p1.input_old = p1.input;
record_player_inputs ();
set_inputs(PIN_BASE, p1.input);
}
else if (botcfg.state == STATE_RUNNING && p1.input != p1.input_old)
{
p1.input_old = p1.input;
set_inputs(PIN_BASE, p1.input);
}
latch_counter++;
if (subs.running && subs.start_latch == latch_counter)
{
fprintf (stdout, "%s\n", subs.text);
sub_read_next ();
}
}
void erase_term(Term* term)
{
pre_erase_term(term);
set_null(term_value(term));
set_inputs(term, TermList());
change_function(term, NULL);
term->type = NULL;
remove_nested_contents(term);
// for each user, clear that user's input list of this term
remove_from_any_user_lists(term);
clear_from_dependencies_of_users(term);
if (term->owningBlock != NULL) {
// remove name binding if necessary
term->owningBlock->removeNameBinding(term);
// index may be invalid if something bad has happened
ca_assert(term->index < term->owningBlock->length());
term->owningBlock->_terms.setAt(term->index, NULL);
term->owningBlock = NULL;
term->index = -1;
}
dealloc_term(term);
}
int main(int argc, char **argv)
{
char line_buffer[1024];
/* get input variables */
if (fgets(line_buffer, 1024, stdin) == NULL) {
fprintf(stderr, "fgets: crash\n");
exit(-1);
}
get_input_variables(line_buffer);
/* get circuit spec */
if (fgets(line_buffer, 1024, stdin) == NULL) {
fprintf(stderr, "fgets: crash\n");
exit(-1);
}
get_circuit(line_buffer);
replace_labels(circuit);
/* evaluate until eof */
while (fgets(line_buffer, 1024, stdin) != NULL) {
set_inputs(line_buffer);
final_val = evaluate(circuit);
}
printf("Result: %d\n", final_val);
free_element(circuit);
exit(0);
}
void insert_looped_placeholders(Block* contents)
{
Value names;
list_names_that_must_be_looped(contents, &names);
for (ListIterator it(&names); it; ++it) {
Term* inputPlaceholder = append_input_placeholder(contents);
Value* name = it.value();
rename(inputPlaceholder, name);
Value owningTermVal;
owningTermVal.set_term(contents->owningTerm);
Term* outsideTerm = find_name_at(&owningTermVal, name);
Term* innerResult = find_local_name(contents, name);
Term* outputPlaceholder = append_output_placeholder(contents, innerResult);
rename(outputPlaceholder, name);
set_inputs(inputPlaceholder, TermList(outsideTerm, outputPlaceholder));
for (BlockInputIterator it(contents); it; ++it) {
Term* term = it.currentTerm();
if (it.currentInput() == outsideTerm && term != inputPlaceholder)
set_input(term, it.currentInputIndex(), inputPlaceholder);
}
}
}
void wb_reset(void) {
rtfSimpleUart.rst_i = 1;
set_inputs();
next_timeframe();
rtfSimpleUart.rst_i = 0;
// Rule 3.20
rtfSimpleUart.stb_i = 0; rtfSimpleUart.cyc_i = 0;
}
void clear_block(Block* block)
{
block->names.clear();
block->inProgress = false;
// Iterate through the block and tear down any term references, so that we
// don't have to worry about stale pointers later.
for (BlockIterator it(block); it; ++it) {
if (*it == NULL)
continue;
pre_erase_term(*it);
set_inputs(*it, TermList());
remove_from_any_user_lists(*it);
change_function(*it, NULL);
}
for (int i= block->_terms.length() - 1; i >= 0; i--) {
Term* term = block->get(i);
if (term == NULL)
continue;
if (term->nestedContents)
clear_block(term->nestedContents);
}
for (int i = block->_terms.length() - 1; i >= 0; i--) {
Term* term = block->get(i);
if (term == NULL)
continue;
// Delete any leftover users, mark them as repairable.
for (int userIndex = 0; userIndex < term->users.length(); userIndex++) {
Term* user = term->users[userIndex];
for (int depIndex = 0; depIndex < user->numDependencies(); depIndex++) {
if (user->dependency(depIndex) == term) {
// mark_repairable_link(user, term->name, depIndex);
user->setDependency(depIndex, NULL);
}
}
}
erase_term(term);
}
block->_terms.clear();
}
void block_update_pack_state_calls(Block* block)
{
if (block->stateType == NULL) {
// No state type, make sure there's no pack_state call.
// TODO: Handle this case properly (should search and destroy an existing pack_state call)
return;
}
int stateOutputIndex = block->length() - 1 - find_state_output(block)->index;
for (int i=0; i < block->length(); i++) {
Term* term = block->get(i);
if (term == NULL)
continue;
if (term->function == FUNCS.pack_state) {
// Update the inputs for this pack_state call
TermList inputs;
list_inputs_to_pack_state(block, i, &inputs);
set_inputs(term, inputs);
}
else if (should_have_preceeding_pack_state(term)) {
// Check if we need to insert a pack_state call
Term* existing = term->input(stateOutputIndex);
if (existing == NULL || existing->function != FUNCS.pack_state) {
TermList inputs;
list_inputs_to_pack_state(block, i, &inputs);
if (inputs.length() != 0) {
Term* pack_state = apply(block, FUNCS.pack_state, inputs);
move_before(pack_state, term);
// Only set as an input for a non-minor block.
if (term->nestedContents == NULL || !is_minor_block(term->nestedContents)) {
set_input(term, stateOutputIndex, pack_state);
set_input_hidden(term, stateOutputIndex, true);
set_input_implicit(term, stateOutputIndex, true);
}
// Advance i to compensate for the term just added
i++;
}
}
}
}
}
void wb_write(_u32 addr, _u8 b) {
// Master presents address, data, asserts WE, CYC and STB
rtfSimpleUart.adr_i = addr;
rtfSimpleUart.dat_i = b;
rtfSimpleUart.we_i = 1;
rtfSimpleUart.cyc_i = 1;
rtfSimpleUart.stb_i = 1;
set_inputs();
//assert(rtfSimpleUart.ack_o == 1);
// We assume the acknowledge comes right away.
// NB Wishbone does not guarantee this in general!
// The simple UART appears to derive ack_o combinatorially from stb_i and cyc_i.
next_timeframe();
rtfSimpleUart.we_i = 0;
rtfSimpleUart.cyc_i = 0;
rtfSimpleUart.stb_i = 0;
}
void branch_update_existing_pack_state_calls(Branch* branch)
{
if (branch->stateType == NULL) {
// No state type, make sure there's no pack_state call.
// TODO: Handle this case properly (should search and destroy an existing pack_state call)
return;
}
int stateOutputIndex = branch->length() - 1 - find_state_output(branch)->index;
for (int i=0; i < branch->length(); i++) {
Term* term = branch->get(i);
if (term == NULL)
continue;
if (term->function == FUNCS.pack_state) {
// Update the inputs for this pack_state call
TermList inputs;
get_list_of_state_outputs(branch, i, &inputs);
set_inputs(term, inputs);
}
if (term->function == FUNCS.exit_point) {
// Check if we need to insert a pack_state call
Term* existing = term->input(stateOutputIndex);
if (existing == NULL || existing->function != FUNCS.pack_state) {
TermList inputs;
get_list_of_state_outputs(branch, i, &inputs);
if (inputs.length() != 0) {
Term* pack_state = apply(branch, FUNCS.pack_state, inputs);
move_before(pack_state, term);
set_input(term, stateOutputIndex + 1, pack_state);
// Advance i to compensate for the term just added
i++;
}
}
}
}
}
void wb_idle() {
set_inputs();
next_timeframe();
}
