static int
select_list(expression_type parent_type,
struct selection *selection,
const freesasa_structure *structure,
const expression *expr)
{
int resr, resl;
expression *left, *right;
if (expr == NULL)
return fail_msg("NULL expression");
left = expr->left;
right = expr->right;
switch(expr->type) {
case E_PLUS:
if (left == NULL || right == NULL)
return fail_msg("NULL expression");
resl = select_list(parent_type, selection, structure, left);
resr = select_list(parent_type, selection, structure, right);
if (resl == FREESASA_WARN || resr == FREESASA_WARN)
return FREESASA_WARN;
break;
case E_RANGE:
if (left == NULL || right == NULL)
return fail_msg("NULL expression");
return select_range(E_RANGE, parent_type, selection, structure, left, right);
case E_RANGE_OPEN_L:
if (left != NULL || right == NULL)
return fail_msg("NULL expression");
return select_range(E_RANGE_OPEN_L, parent_type, selection, structure, left, right);
case E_RANGE_OPEN_R:
if (left == NULL || right != NULL)
return fail_msg("NULL expression");
return select_range(E_RANGE_OPEN_R, parent_type, selection, structure, left, right);
case E_ID:
case E_NUMBER:
if (is_valid_id(parent_type, expr) == FREESASA_SUCCESS)
select_id(parent_type, selection, structure, expr->value);
else return freesasa_warn("select: %s: '%s' invalid %s",
e_str(parent_type), expr->value, e_str(expr->type));
break;
default:
return freesasa_fail("select: parse error (expression: '%s %s')",
e_str(parent_type), e_str(expr->type));
}
return FREESASA_SUCCESS;
}
static void
ensure_anchor_selected (Movement *mv)
{
GtkTextBuffer *buffer;
GtkTextMark *selection_mark;
GtkTextMark *insert_mark;
GtkTextIter anchor_begin;
GtkTextIter anchor_end;
GtkTextIter insert_iter;
GtkTextIter selection_iter;
GtkTextMark *selection_anchor_begin;
GtkTextMark *selection_anchor_end;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
selection_anchor_begin = gtk_text_buffer_get_mark (buffer, ANCHOR_BEGIN);
selection_anchor_end = gtk_text_buffer_get_mark (buffer, ANCHOR_END);
if (!selection_anchor_begin || !selection_anchor_end)
return;
gtk_text_buffer_get_iter_at_mark (buffer, &anchor_begin, selection_anchor_begin);
gtk_text_buffer_get_iter_at_mark (buffer, &anchor_end, selection_anchor_end);
insert_mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &insert_iter, insert_mark);
selection_mark = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &selection_iter, selection_mark);
if ((gtk_text_iter_compare (&selection_iter, &anchor_end) < 0) &&
(gtk_text_iter_compare (&insert_iter, &anchor_end) < 0))
{
if (gtk_text_iter_compare (&insert_iter, &selection_iter) < 0)
select_range (mv, &insert_iter, &anchor_end);
else
select_range (mv, &anchor_end, &selection_iter);
}
else if ((gtk_text_iter_compare (&selection_iter, &anchor_begin) > 0) &&
(gtk_text_iter_compare (&insert_iter, &anchor_begin) > 0))
{
if (gtk_text_iter_compare (&insert_iter, &selection_iter) < 0)
select_range (mv, &anchor_begin, &selection_iter);
else
select_range (mv, &insert_iter, &anchor_begin);
}
}
static void
etsm_real_move_selection_end (ETreeSelectionModel *etsm,
gint row)
{
ETreePath end_path;
gint start;
end_path = e_tree_table_adapter_node_at_row (etsm->priv->etta, row);
g_return_if_fail (end_path);
start = e_tree_table_adapter_row_of_node (
etsm->priv->etta, etsm->priv->start_path);
clear_selection (etsm);
select_range (etsm, start, row);
}
void FindBar::on_find_next_clicked() {
if(!window_.current_buffer()) {
return;
}
auto buf = window_.current_buffer()->buffer();
auto start = buf->get_iter_at_mark(buf->get_insert());
auto text = unicode(find_entry_->get_text().c_str());
locate_matches(text);
auto next = find_next_match(start);
last_selected_match_ = next;
if(next > -1) {
auto match = matches_[next];
buf->select_range(match.first, match.second);
window_.current_buffer()->view().scroll_to(match.first);
}
}
bool verifyFlashMemory(int moduleNumber, FILE *rbtFile, bool simulate, bool verbose)
{
unsigned long vmeaddr, vme_virt_addr;
volatile int *p_addr;
char c_input[MAXLEN];
int i, j;
int len;
int l_word;
intptr_t fbase;
int data;
int bits = 0;
int err = 0;
int line = 0;
int l_count = 0;
// printf("\nverifying flash memory\n");
printlog("verifing flash memory", true, !quiet);
vmeaddr = moduleNumber * MODULE_LENGTH ;
vme_virt_addr = (unsigned long)openvme((void *)vmeaddr, VME_LENGTH, verbose);
fbase = vme_virt_addr + FLASHBASE;
p_addr = (volatile int *)fbase;
select_range(vme_virt_addr, 0+RANGENUMBER, verbose);
rewind(rbtFile);
fgets(c_input,MAXLEN,rbtFile);
fgets(c_input,MAXLEN,rbtFile);
// design name
fgets(c_input,MAXLEN,rbtFile);
printlog("file information:", true, verbose);
printlog(c_input, true, verbose);
// printf("%s",c_input);
// architecture name
fgets(c_input,MAXLEN,rbtFile);
printlog(c_input, true, verbose);
// printf("%s",c_input);
// part
fgets(c_input,MAXLEN,rbtFile);
printlog(c_input, true, verbose);
// printf("%s",c_input);
// date
fgets(c_input,MAXLEN,rbtFile);
printlog(c_input, true, verbose);
// printf("%s",c_input);
// bits
fgets(c_input,MAXLEN,rbtFile);
printlog(c_input, true, verbose);
// printf("%s",c_input);
l_count = 0;
// printf("addr = %x\n",p_addr);
if (!quiet && !verbose) {
printf("\n");
}
while(fgets(c_input, MAXLEN,rbtFile) != NULL) {
len = strlen(c_input) -1;
// printf("%s",c_input);
line++;
if((line % 10000) == 0) {
if (verbose) {
// printf("line %d ",line);
// if (verbose) printf("time: %f clocks\n", (int) time(NULL) - timestamp); //timestamp = (int) clock();
} else {
if (!quiet) {
int i;
printf("\r");
for (i = 0; i < line / 10000; i++) {
printf(">");
}
for (i = line / 10000; i < 38; i++) {
printf("-");
}
fflush(stdout);
}
}
}
for(i=0; i<len/8; i++) {
l_word = 0;
for(j=0; j<8; j++) {
// printf("%c ",c_input[j+8*i]);
if(c_input[(7-j)+8*i] == '1') {
l_word += (1<<j);
}
bits++;
}
// printf("word = %x\n",l_word);
// prog_flash((int)p_addr,l_word);
data = ntohl(*p_addr) & 0xff;
if(data != l_word) {
// printf("ERROR: offset %x, written %x read %x\n",l_count,
// l_word,data);
err++;
}
// if(err > 100)goto err_exit;
p_addr++;
l_count++;
if(l_count == RANGELIMIT) {
// range++;
select_range(vme_virt_addr, 1, verbose);
p_addr = (int *) fbase;
}
}
}
// if (!quiet && !verbose) printf("\n");
//
// printf("File %s verified, %d bits, %d bytes\n", fileName, bits, l_count);
closevme(verbose);
// err_exit:
// return_controller(vme_virt_addr,vme_len);
// exit(1);
if (err == 0) {
return true;
} else {
return false;
}
}
void writeFlashMemory(int moduleNumber, FILE *rbtFile, bool simulate, bool verbose)
{
int i, j;
int len;
int l_word;
int bits = 0;
char c_input[MAXLEN];
volatile int *p_addr;
int l_count = 0;
unsigned long vmeaddr, vme_virt_addr;
int line;
line = 0;
printlog("writing new program to flash memory", true, !quiet);
vmeaddr = moduleNumber * MODULE_LENGTH ;
// vme_len = 0x1000000;
// vme_am = 0x09;
vme_virt_addr = (unsigned long)openvme((void *)vmeaddr, VME_LENGTH, verbose);
intptr_t fbase = vme_virt_addr + FLASHBASE;
p_addr = (int *) fbase;
select_range(vme_virt_addr, 0+RANGENUMBER, verbose);
// read header
fgets(c_input,MAXLEN,rbtFile);
fgets(c_input,MAXLEN,rbtFile);
// design name
fgets(c_input,MAXLEN,rbtFile);
// printf("%s",c_input);
// architecture name
fgets(c_input,MAXLEN,rbtFile);
// printf("%s",c_input);
// part
fgets(c_input,MAXLEN,rbtFile);
// printf("%s",c_input);
// date
fgets(c_input,MAXLEN,rbtFile);
// printf("%s",c_input);
// bits
fgets(c_input,MAXLEN,rbtFile);
// printf("%s",c_input);
l_count = 0;
// printf("addr = %x\n",p_addr);
if (!quiet && !verbose) {
printf("\n");
}
while(fgets(c_input, MAXLEN,rbtFile) != NULL) {
len = strlen(c_input) -1;
// printf("%s",c_input);
line++;
if((line % 10000) == 0) {
if (verbose) {
// printf("line %d ",line);
// if (verbose) printf("time: %f clocks\n", (int) time(NULL) - timestamp); //timestamp = (int) clock();
} else {
if (!quiet) {
int i;
printf("\r");
for (i = 0; i < line / 10000; i++) {
printf(">");
}
for (i = line / 10000; i < 38; i++) {
printf("-");
}
fflush(stdout);
}
}
}
for(i=0; i<len/8; i++) {
l_word = 0;
for(j=0; j<8; j++) {
// printf("%c ",c_input[j+8*i]);
if(c_input[(7-j)+8*i] == '1') {
l_word += (1<<j);
}
bits++;
}
// printf("word = %x\n",l_word);
if (!simulate) {
prog_flash((intptr_t)p_addr, l_word, verbose);
}
p_addr++;
l_count++;
if(l_count == RANGELIMIT) {
// range++;
select_range(vme_virt_addr, 1+RANGENUMBER, verbose);
p_addr = (int *) fbase;
/*int loopCounter = 0;
int val = 0;
range++;
if (verbose) printf("selecting next range \n");
while ((val != range + 1 + 64) && (loopCounter < 10))
{
val = select_range(vme_virt_addr, range + 1, verbose);
loopCounter++;
if (val != range + 1 + 64)
{
read_array(fbase);
closevme(verbose);
vme_virt_addr = (unsigned long)openvme((void *)vmeaddr,vme_len, verbose);
fbase = vme_virt_addr + FLASHBASE;
p_addr = (int *) fbase;
}
}*/
//select_range(vme_virt_addr,range, verbose);
//vme_virt_addr = saveSelectRange(vme_virt_addr, (void *)vmeaddr,vme_len, range + 1, verbose);
//p_addr = (int *)fbase;
}
}
}
// if (!quiet && !verbose) printf("\n");
// if (verbose) printf("File %s loaded, %d bits, %d bytes\n",fileName,bits,l_count);
read_array(fbase);
closevme(verbose);
}
void eraseFlashMemory(int moduleNumber, bool simulate, bool verbose)
{
int i;
int status;
bool errorOccured = true;
int loopCounter = 0;
unsigned long vmeaddr;
unsigned long vme_virt_addr;
int fbase;
printlog("erasing flash memory", true, !quiet);
while (errorOccured && (loopCounter < MAXLOOPS)) {
loopCounter++;
printlog("attempt #: ", true, verbose);
printlogInt(loopCounter, verbose);
errorOccured = false;
vmeaddr = moduleNumber * MODULE_LENGTH ;
vme_virt_addr = (unsigned long) openvme((void *)vmeaddr, VME_LENGTH, verbose);
fbase = vme_virt_addr + FLASHBASE;
select_range(vme_virt_addr, 0+RANGENUMBER, verbose);
for (i = 0; i <= 7; i++) {
printlog("block #: ", true, verbose);
printlogInt(i, verbose);
if (!simulate) {
status = erase_block(fbase, i, verbose);
} else {
status = 0;
}
if (status == 0) {
printlog(" successfully erased", false, verbose);
} else {
printlog(" can\'t be erased", false, verbose);
errorOccured = true;
}
}
if (!errorOccured) {
select_range(vme_virt_addr, 1+RANGENUMBER, verbose);
for (i = 0; i <= 7; i++) {
printlog("block #: ", true, verbose);
printlogInt(i, verbose);
if (!simulate) {
status = erase_block(fbase, i, verbose);
} else {
status = 0;
}
if (status == 0) {
printlog(" successfully erased", false, verbose);
} else {
printlog(" can\'t be erased", false, verbose);
errorOccured = true;
}
}
}
read_array(fbase);
closevme(verbose);
sleep(2);
}
if(errorOccured) {
printlog("Error erasing flash memory, aborting", true, verbose);
closeLog(verbose);
exit(1);
}
}
int Fl_ToggleTree::handle(int event) {
// printf("event: %d\n",event);
static Fl_ToggleNode* prev = 0;
switch (event) {
case FL_ENTER:
return 1;
case FL_RELEASE: {
if (edit_input_->visible()) {
end_edit();
}
int depth;
int cy;
Fl_ToggleNode* tnode = (Fl_ToggleNode*) Fl_Tree::find(Fl::event_y(), depth, cy);
if (Fl::event_x() < x() + depth*16 + 16) {
if (tnode->opened_) {
current_ = tnode;
state_ = FL_TOGGLE_OPENED;
do_callback();
close(tnode);
} else {
current_ = tnode;
state_ = FL_TOGGLE_CLOSED;
do_callback();
open(tnode);
}
return 1;
} else {
if (Fl::event_state(FL_SHIFT)) {
if (prev == 0) prev = tnode;
select_range(prev, tnode, 1);
current_ = 0;
state_ = FL_TOGGLE_SELECT;
do_callback();
} else if (Fl::event_state(FL_CTRL)) {
if (!tnode->selected_)
select_range(tnode, tnode, Fl::event_state(FL_CTRL));
else {
tnode->selected_ = 0;
tnode->changed_ = 1;
tnode = 0;
}
current_ = 0;
state_ = FL_TOGGLE_SELECT;
do_callback();
} else {
select_range(tnode, tnode, 0);
state_ = Fl::event_clicks() ? FL_TOGGLE_HIT : FL_TOGGLE_SELECT;
if (tnode == current_ && state_ == FL_TOGGLE_SELECT) {
state_ = FL_TOGGLE_RESELECT;
}
current_ = tnode;
if (state_ == FL_TOGGLE_RESELECT && edit_on_reselect_) {
edit(tnode, x() + depth*16 + label_offset_, cy);
}
do_callback();
}
damaged_ = 0;
damage(FL_DAMAGE_CHILD);
prev = tnode;
}
}
return 1;
break;
}
return 1;
}
static void
ide_source_view_movements_previous_line (Movement *mv)
{
GtkTextBuffer *buffer;
gboolean has_selection;
guint line;
guint offset = 0;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
/* check for linewise */
has_selection = !gtk_text_iter_equal (&mv->insert, &mv->selection) || !mv->exclusive;
line = gtk_text_iter_get_line (&mv->insert);
if ((*mv->target_offset) > 0)
offset = *mv->target_offset;
if (line == 0)
return;
/*
* If we have a whole line selected (from say `V`), then we need to swap the cursor and
* selection. This feels to me like a slight bit of a hack. There may be cause to actually have
* a selection mode and know the type of selection (line vs individual characters).
*/
if (is_single_line_selection (&mv->insert, &mv->selection))
{
if (gtk_text_iter_compare (&mv->insert, &mv->selection) > 0)
gtk_text_iter_order (&mv->insert, &mv->selection);
gtk_text_iter_set_line (&mv->insert, gtk_text_iter_get_line (&mv->insert) - 1);
select_range (mv, &mv->insert, &mv->selection);
ensure_anchor_selected (mv);
return;
}
if (is_single_char_selection (&mv->insert, &mv->selection))
{
if (gtk_text_iter_compare (&mv->insert, &mv->selection) > 0)
{
if (offset)
--offset;
*mv->target_offset = offset;
}
}
gtk_text_buffer_get_iter_at_line (buffer, &mv->insert, line - 1);
if ((line - 1) == gtk_text_iter_get_line (&mv->insert))
{
for (; offset; offset--)
if (!gtk_text_iter_ends_line (&mv->insert))
if (!gtk_text_iter_forward_char (&mv->insert))
break;
if (has_selection)
{
if (gtk_text_iter_equal (&mv->insert, &mv->selection))
gtk_text_iter_backward_char (&mv->insert);
select_range (mv, &mv->insert, &mv->selection);
ensure_anchor_selected (mv);
}
else
gtk_text_buffer_select_range (buffer, &mv->insert, &mv->insert);
}
/* make sure selection/insert are up to date */
if (!gtk_text_buffer_get_has_selection (buffer))
mv->selection = mv->insert;
}
