luke
/
xschem
mirror of https://github.com/StefanSchippers/xschem.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

replaced frequent "xctx->something" accesses with "something" for code readability, optimizations in hash_wire() when incremental wires added, STR_ALLOC() macro (performance reasons)

This commit is contained in:
Stefan Schippers 2020-10-16 16:34:15 +02:00
parent 35c2d0fa93
commit b626dfb599
8 changed files with 535 additions and 508 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/actions.c
View File

@ -1673,7 +1673,7 @@ void new_wire(int what, double mx_snap, double my_snap)
printf("xschem wire %g %g %g %g %d\n", xx1, yy1, xx2, yy2, -1);
fflush(stdout);
}
hash_wire(XINSERT, xctx->wires-1);
hash_wire(XINSERT, xctx->wires-1, 1);
/* prepared_hash_wires = 0; */
prepared_hilight_structs = 0;
update_conn_cues(1,1);

281
src/check.c
View File

@ -32,12 +32,14 @@ void check_touch(int i, int j,
int touch1=0,touch2=0,touch3=0,touch4=0;
double delta1x,delta1y,delta2x,delta2y;
double x1,y1,x2,y2;
x1=xctx->wire[i].x1;
x2=xctx->wire[i].x2;
y1=xctx->wire[i].y1;
y2=xctx->wire[i].y2;
xWire * const wire = xctx->wire;
x1=wire[i].x1;
x2=wire[i].x2;
y1=wire[i].y1;
y2=wire[i].y2;
delta1x = x2-x1;delta1y = y1-y2 ;
delta2x = xctx->wire[j].x2-xctx->wire[j].x1;delta2y = xctx->wire[j].y1-xctx->wire[j].y2 ;
delta2x = wire[j].x2-wire[j].x1;delta2y = wire[j].y1-wire[j].y2 ;
*included = 0;
*includes = 0;
@ -47,32 +49,32 @@ void check_touch(int i, int j,
*parallel = (delta1x*delta2y == delta2x*delta1y ? 1:0);
/* the order of the following 4 if(touch...) is not don't care !!! */
if(touch(xctx->wire[j].x1,xctx->wire[j].y1,xctx->wire[j].x2,xctx->wire[j].y2,x1,y1) )
if(touch(wire[j].x1,wire[j].y1,wire[j].x2,wire[j].y2,x1,y1) )
{
*touches = 1;touch3 =1;
*xt = x1; *yt = y1;
if((*xt > xctx->wire[j].x1 && *xt < xctx->wire[j].x2)||
(*yt > xctx->wire[j].y1 && *yt < xctx->wire[j].y2)) *breaks = 1;
if((*xt > wire[j].x1 && *xt < wire[j].x2)||
(*yt > wire[j].y1 && *yt < wire[j].y2)) *breaks = 1;
}
if(touch(xctx->wire[j].x1,xctx->wire[j].y1,xctx->wire[j].x2,xctx->wire[j].y2,x2,y2) )
if(touch(wire[j].x1,wire[j].y1,wire[j].x2,wire[j].y2,x2,y2) )
{
*touches = 1;touch4 =1;
*xt = x2; *yt = y2;
if((*xt > xctx->wire[j].x1 && *xt < xctx->wire[j].x2)||
(*yt > xctx->wire[j].y1 && *yt < xctx->wire[j].y2)) *breaks = 1;
if((*xt > wire[j].x1 && *xt < wire[j].x2)||
(*yt > wire[j].y1 && *yt < wire[j].y2)) *breaks = 1;
}
if(touch3 && touch4) *included = 1;
if(touch(x1,y1,x2,y2,xctx->wire[j].x1,xctx->wire[j].y1) )
if(touch(x1,y1,x2,y2,wire[j].x1,wire[j].y1) )
{
*touches = 1;touch1=1;
*xt = xctx->wire[j].x1; *yt = xctx->wire[j].y1;
*xt = wire[j].x1; *yt = wire[j].y1;
if((*xt > x1 && *xt < x2)||(*yt > y1 && *yt < y2)) *broken = 1;
}
if(touch(x1,y1,x2,y2,xctx->wire[j].x2,xctx->wire[j].y2) )
if(touch(x1,y1,x2,y2,wire[j].x2,wire[j].y2) )
{
*touches = 1;touch2=1;
*xt = xctx->wire[j].x2; *yt = xctx->wire[j].y2;
*xt = wire[j].x2; *yt = wire[j].y2;
if((*xt > x1 && *xt < x2)||(*yt > y1 && *yt < y2)) *broken = 1;
}
if(touch1 && touch2) *includes = 1;
@ -86,6 +88,7 @@ void update_conn_cues(int draw_cues, int dr_win)
double x0, y0;
double x1, y1, x2, y2;
struct wireentry *wireptr;
xWire * const wire = xctx->wire;
hash_wires(); /* must be done also if xctx->wires==0 to clear wiretable */
if(!xctx->wires) return;
@ -98,18 +101,18 @@ void update_conn_cues(int draw_cues, int dr_win)
for(init_wire_iterator(x1, y1, x2, y2); ( wireptr = wire_iterator_next() ) ;) {
k=wireptr->n;
/* optimization when editing small areas (detailed zoom) of a huge schematic */
if(LINE_OUTSIDE(xctx->wire[k].x1, xctx->wire[k].y1, xctx->wire[k].x2, xctx->wire[k].y2, x1, y1, x2, y2)) continue;
if(LINE_OUTSIDE(wire[k].x1, wire[k].y1, wire[k].x2, wire[k].y2, x1, y1, x2, y2)) continue;
for(l = 0;l < 2;l++) {
if(l==0 ) {
if(xctx->wire[k].end1 !=-1) continue;
xctx->wire[k].end1=0;
x0 = xctx->wire[k].x1;
y0 = xctx->wire[k].y1;
if(wire[k].end1 !=-1) continue;
wire[k].end1=0;
x0 = wire[k].x1;
y0 = wire[k].y1;
} else {
if(xctx->wire[k].end2 !=-1) continue;
xctx->wire[k].end2=0;
x0 = xctx->wire[k].x2;
y0 = xctx->wire[k].y2;
if(wire[k].end2 !=-1) continue;
wire[k].end2=0;
x0 = wire[k].x2;
y0 = wire[k].y2;
}
get_square(x0, y0, &sqx, &sqy);
for(wptr = wiretable[sqx][sqy] ; wptr ; wptr = wptr->next) {
@ -117,14 +120,14 @@ void update_conn_cues(int draw_cues, int dr_win)
if(i == k) {
continue; /* no check wire against itself */
}
if( touch(xctx->wire[i].x1, xctx->wire[i].y1, xctx->wire[i].x2, xctx->wire[i].y2, x0,y0) ) {
if( (x0 != xctx->wire[i].x1 && x0 != xctx->wire[i].x2) ||
(y0 != xctx->wire[i].y1 && y0 != xctx->wire[i].y2) ) {
if(l == 0) xctx->wire[k].end1 += 2;
else xctx->wire[k].end2 += 2;
if( touch(wire[i].x1, wire[i].y1, wire[i].x2, wire[i].y2, x0,y0) ) {
if( (x0 != wire[i].x1 && x0 != wire[i].x2) ||
(y0 != wire[i].y1 && y0 != wire[i].y2) ) {
if(l == 0) wire[k].end1 += 2;
else wire[k].end2 += 2;
} else {
if(l == 0) xctx->wire[k].end1 += 1;
else xctx->wire[k].end2 += 1;
if(l == 0) wire[k].end1 += 1;
else wire[k].end2 += 1;
}
}
}
@ -136,13 +139,13 @@ void update_conn_cues(int draw_cues, int dr_win)
for(init_wire_iterator(x1, y1, x2, y2); ( wireptr = wire_iterator_next() ) ;) {
i = wireptr->n;
/* optimization when editing small areas (detailed zoom) of a huge schematic */
if(LINE_OUTSIDE(xctx->wire[i].x1, xctx->wire[i].y1,
xctx->wire[i].x2, xctx->wire[i].y2, x1, y1, x2, y2)) continue;
if( xctx->wire[i].end1 >1 ) { /* 20150331 draw_dots */
filledarc(WIRELAYER, ADD, xctx->wire[i].x1, xctx->wire[i].y1, cadhalfdotsize, 0, 360);
if(LINE_OUTSIDE(wire[i].x1, wire[i].y1,
wire[i].x2, wire[i].y2, x1, y1, x2, y2)) continue;
if( wire[i].end1 >1 ) { /* 20150331 draw_dots */
filledarc(WIRELAYER, ADD, wire[i].x1, wire[i].y1, cadhalfdotsize, 0, 360);
}
if( xctx->wire[i].end2 >1 ) { /* 20150331 draw_dots */
filledarc(WIRELAYER, ADD, xctx->wire[i].x2, xctx->wire[i].y2, cadhalfdotsize, 0, 360);
if( wire[i].end2 >1 ) { /* 20150331 draw_dots */
filledarc(WIRELAYER, ADD, wire[i].x2, wire[i].y2, cadhalfdotsize, 0, 360);
}
}
filledarc(WIRELAYER, END, 0.0, 0.0, 0.0, 0.0, 0.0);
@ -157,14 +160,16 @@ void trim_wires(void)
unsigned short parallel,breaks,broken,touches,included,includes;
double xt=0,yt=0;
int loops=0;
xWire * const wire = xctx->wire;
int const wires = xctx->wires;
do {
loops++;
for(i=0;i<xctx->wires;i++) xctx->wire[i].end1=xctx->wire[i].end2=0;
for(i=0;i<wires;i++) wire[i].end1=wire[i].end2=0;
changed=0;
for(i=0;i<xctx->wires;i++)
for(i=0;i<wires;i++)
{
for(j=i+1;j<xctx->wires;j++)
for(j=i+1;j<wires;j++)
{
check_touch(i,j, &parallel,&breaks,&broken,&touches,&included,&includes, &xt,&yt);
if(included)
@ -187,81 +192,81 @@ void trim_wires(void)
{
check_wire_storage();
changed=1;
xctx->wire[xctx->wires].x1=xctx->wire[i].x1;
xctx->wire[xctx->wires].y1=xctx->wire[i].y1;
xctx->wire[xctx->wires].end1=xctx->wire[i].end1;
xctx->wire[xctx->wires].end2=1;
xctx->wire[xctx->wires].x2=xt;
xctx->wire[xctx->wires].y2=yt;
xctx->wire[xctx->wires].sel=0;
xctx->wire[xctx->wires].prop_ptr=NULL;
my_strdup(27, &xctx->wire[xctx->wires].prop_ptr, xctx->wire[i].prop_ptr);
if(!strcmp(get_tok_value(xctx->wire[xctx->wires].prop_ptr,"bus",0), "true"))
xctx->wire[xctx->wires].bus=1;
wire[wires].x1=wire[i].x1;
wire[wires].y1=wire[i].y1;
wire[wires].end1=wire[i].end1;
wire[wires].end2=1;
wire[wires].x2=xt;
wire[wires].y2=yt;
wire[wires].sel=0;
wire[wires].prop_ptr=NULL;
my_strdup(27, &wire[wires].prop_ptr, wire[i].prop_ptr);
if(!strcmp(get_tok_value(wire[wires].prop_ptr,"bus",0), "true"))
wire[wires].bus=1;
else
xctx->wire[xctx->wires].bus=0;
xctx->wire[xctx->wires].node=NULL;
my_strdup(28, &xctx->wire[xctx->wires].node, xctx->wire[i].node);
wire[wires].bus=0;
wire[wires].node=NULL;
my_strdup(28, &wire[wires].node, wire[i].node);
xctx->wires++;
xctx->wire[i].x1 = xt;
xctx->wire[i].y1 = yt;
xctx->wire[i].end1 = 1;
wire[i].x1 = xt;
wire[i].y1 = yt;
wire[i].end1 = 1;
} /* end if broken */
else if(breaks) /*xctx->wire[i] breaks xctx->wire[j] */
else if(breaks) /*wire[i] breaks wire[j] */
{
changed=1;
if(xctx->wire[i].x1==xt && xctx->wire[i].y1==yt) xctx->wire[i].end1+=1;
else if(xctx->wire[i].x2==xt && xctx->wire[i].y2==yt) xctx->wire[i].end2+=1;
if(wire[i].x1==xt && wire[i].y1==yt) wire[i].end1+=1;
else if(wire[i].x2==xt && wire[i].y2==yt) wire[i].end2+=1;
check_wire_storage();
xctx->wire[xctx->wires].x1=xctx->wire[j].x1;
xctx->wire[xctx->wires].y1=xctx->wire[j].y1;
xctx->wire[xctx->wires].end1=xctx->wire[j].end1;
xctx->wire[xctx->wires].end2=1;
xctx->wire[xctx->wires].x2=xt;
xctx->wire[xctx->wires].y2=yt;
xctx->wire[xctx->wires].sel=0;
xctx->wire[xctx->wires].prop_ptr=NULL;
my_strdup(29, &xctx->wire[xctx->wires].prop_ptr, xctx->wire[j].prop_ptr);
if(!strcmp(get_tok_value(xctx->wire[xctx->wires].prop_ptr,"bus",0), "true"))
xctx->wire[xctx->wires].bus=1;
wire[wires].x1=wire[j].x1;
wire[wires].y1=wire[j].y1;
wire[wires].end1=wire[j].end1;
wire[wires].end2=1;
wire[wires].x2=xt;
wire[wires].y2=yt;
wire[wires].sel=0;
wire[wires].prop_ptr=NULL;
my_strdup(29, &wire[wires].prop_ptr, wire[j].prop_ptr);
if(!strcmp(get_tok_value(wire[wires].prop_ptr,"bus",0), "true"))
wire[wires].bus=1;
else
xctx->wire[xctx->wires].bus=0;
xctx->wire[xctx->wires].node=NULL;
my_strdup(30, &xctx->wire[xctx->wires].node, xctx->wire[j].node);
wire[wires].bus=0;
wire[wires].node=NULL;
my_strdup(30, &wire[wires].node, wire[j].node);
xctx->wires++;
xctx->wire[j].x1 = xt;
xctx->wire[j].y1 = yt;
xctx->wire[j].end1 = 1;
wire[j].x1 = xt;
wire[j].y1 = yt;
wire[j].end1 = 1;
} /* end else if breaks */
else /* xctx->wire[i] touches but does not break xctx->wire[j] */
else /* wire[i] touches but does not break wire[j] */
{
if(xctx->wire[i].x1==xctx->wire[j].x1 && xctx->wire[i].y1==xctx->wire[j].y1)
{xctx->wire[i].end1++;xctx->wire[j].end1++;}
else if(xctx->wire[i].x1==xctx->wire[j].x2 && xctx->wire[i].y1==xctx->wire[j].y2)
{xctx->wire[i].end1++;xctx->wire[j].end2++;}
else if(xctx->wire[i].x2==xctx->wire[j].x1 && xctx->wire[i].y2==xctx->wire[j].y1)
{xctx->wire[i].end2++;xctx->wire[j].end1++;}
if(wire[i].x1==wire[j].x1 && wire[i].y1==wire[j].y1)
{wire[i].end1++;wire[j].end1++;}
else if(wire[i].x1==wire[j].x2 && wire[i].y1==wire[j].y2)
{wire[i].end1++;wire[j].end2++;}
else if(wire[i].x2==wire[j].x1 && wire[i].y2==wire[j].y1)
{wire[i].end2++;wire[j].end1++;}
else
{xctx->wire[i].end2++;xctx->wire[j].end2++;}
{wire[i].end2++;wire[j].end2++;}
}
} /* end if touches */
} /* end for j */
} /* end for i */
for(i=0;i<xctx->wires;i++) {
for(j=i+1;j<xctx->wires;j++) {
for(i=0;i<wires;i++) {
for(j=i+1;j<wires;j++) {
check_touch(i,j, &parallel,&breaks,&broken,&touches,&included,&includes, &xt,&yt);
if( touches && parallel)
{
if(xctx->wire[j].x1 == xt && xctx->wire[j].y1 == yt) /* touch in x1, y1 */
if(wire[j].x1 == xt && wire[j].y1 == yt) /* touch in x1, y1 */
{
if(xctx->wire[i].end2 == 1 && xctx->wire[j].end1 == 1) /* merge wire */
if(wire[i].end2 == 1 && wire[j].end1 == 1) /* merge wire */
{
changed=1;
xctx->wire[i].x2 = xctx->wire[j].x2;xctx->wire[i].y2 = xctx->wire[j].y2;
xctx->wire[i].end2=xctx->wire[j].end2;
wire[i].x2 = wire[j].x2;wire[i].y2 = wire[j].y2;
wire[i].end2=wire[j].end2;
freenet_nocheck(j);
j--;
break;
@ -269,11 +274,11 @@ void trim_wires(void)
}
else /* touch in x2,y2 */
{
if(xctx->wire[i].end1 == 1 && xctx->wire[j].end2 == 1) /* merge wire */
if(wire[i].end1 == 1 && wire[j].end2 == 1) /* merge wire */
{
changed=1;
xctx->wire[i].x1 = xctx->wire[j].x1;xctx->wire[i].y1 = xctx->wire[j].y1;
xctx->wire[i].end1=xctx->wire[j].end1;
wire[i].x1 = wire[j].x1;wire[i].y1 = wire[j].y1;
wire[i].end1=wire[j].end1;
freenet_nocheck(j);
j--;
break;
@ -300,8 +305,10 @@ void break_wires_at_pins(void)
xRect *rct;
double x0, y0, rx1, ry1;
int changed=0;
hash_wires();
xWire * const wire = xctx->wire;
int const wires = xctx->wires;
hash_wires();
need_rebuild_selected_array=1;
rebuild_selected_array();
@ -323,31 +330,31 @@ void break_wires_at_pins(void)
get_square(x0, y0, &sqx, &sqy);
for(wptr=wiretable[sqx][sqy]; wptr; wptr=wptr->next) {
i = wptr->n;
if( touch(xctx->wire[i].x1, xctx->wire[i].y1,
xctx->wire[i].x2, xctx->wire[i].y2, x0,y0) )
if( touch(wire[i].x1, wire[i].y1,
wire[i].x2, wire[i].y2, x0,y0) )
{
if( (x0!=xctx->wire[i].x1 && x0!=xctx->wire[i].x2) ||
(y0!=xctx->wire[i].y1 && y0!=xctx->wire[i].y2) ) {
if( (x0!=wire[i].x1 && x0!=wire[i].x2) ||
(y0!=wire[i].y1 && y0!=wire[i].y2) ) {
if(!changed) { push_undo(); changed=1;}
check_wire_storage();
xctx->wire[xctx->wires].x1=xctx->wire[i].x1;
xctx->wire[xctx->wires].y1=xctx->wire[i].y1;
xctx->wire[xctx->wires].x2=x0;
xctx->wire[xctx->wires].y2=y0;
xctx->wire[xctx->wires].sel=SELECTED;
xctx->wire[xctx->wires].prop_ptr=NULL;
my_strdup(31, &xctx->wire[xctx->wires].prop_ptr, xctx->wire[i].prop_ptr);
if(!strcmp(get_tok_value(xctx->wire[xctx->wires].prop_ptr,"bus",0), "true"))
xctx->wire[xctx->wires].bus=1;
wire[wires].x1=wire[i].x1;
wire[wires].y1=wire[i].y1;
wire[wires].x2=x0;
wire[wires].y2=y0;
wire[wires].sel=SELECTED;
wire[wires].prop_ptr=NULL;
my_strdup(31, &wire[wires].prop_ptr, wire[i].prop_ptr);
if(!strcmp(get_tok_value(wire[wires].prop_ptr,"bus",0), "true"))
wire[wires].bus=1;
else
xctx->wire[xctx->wires].bus=0;
xctx->wire[xctx->wires].node=NULL;
hash_wire(XINSERT, xctx->wires);
my_strdup(32, &xctx->wire[xctx->wires].node, xctx->wire[i].node);
wire[wires].bus=0;
wire[wires].node=NULL;
hash_wire(XINSERT, wires, 0);
my_strdup(32, &wire[wires].node, wire[i].node);
need_rebuild_selected_array=1;
xctx->wires++;
xctx->wire[i].x1 = x0;
xctx->wire[i].y1 = y0;
wire[i].x1 = x0;
wire[i].y1 = y0;
}
}
}
@ -358,17 +365,17 @@ void break_wires_at_pins(void)
/* hash_wires(); */
rebuild_selected_array();
for(j=0;j<lastselected;j++) if(selectedgroup[j].type==WIRE) {
/* for(k=0; k < xctx->wires; k++) { */
/* for(k=0; k < wires; k++) { */
int l;
k = selectedgroup[j].n;
for(l=0;l<2;l++) {
if(l==0 ) {
x0 = xctx->wire[k].x1;
y0 = xctx->wire[k].y1;
x0 = wire[k].x1;
y0 = wire[k].y1;
} else {
x0 = xctx->wire[k].x2;
y0 = xctx->wire[k].y2;
x0 = wire[k].x2;
y0 = wire[k].y2;
}
get_square(x0, y0, &sqx, &sqy);
/* printf(" k=%d, x0=%g, y0=%g\n", k, x0, y0); */
@ -378,31 +385,31 @@ void break_wires_at_pins(void)
if(i==k) {
continue; /* no check wire against itself */
}
if( touch(xctx->wire[i].x1, xctx->wire[i].y1,
xctx->wire[i].x2, xctx->wire[i].y2, x0,y0) )
if( touch(wire[i].x1, wire[i].y1,
wire[i].x2, wire[i].y2, x0,y0) )
{
if( (x0!=xctx->wire[i].x1 && x0!=xctx->wire[i].x2) ||
(y0!=xctx->wire[i].y1 && y0!=xctx->wire[i].y2) ) {
if( (x0!=wire[i].x1 && x0!=wire[i].x2) ||
(y0!=wire[i].y1 && y0!=wire[i].y2) ) {
/* printf("touch in mid point: %d\n", l+1); */
if(!changed) { push_undo(); changed=1;}
check_wire_storage();
xctx->wire[xctx->wires].x1=xctx->wire[i].x1;
xctx->wire[xctx->wires].y1=xctx->wire[i].y1;
xctx->wire[xctx->wires].x2=x0;
xctx->wire[xctx->wires].y2=y0;
xctx->wire[xctx->wires].sel=SELECTED;
xctx->wire[xctx->wires].prop_ptr=NULL;
my_strdup(33, &xctx->wire[xctx->wires].prop_ptr, xctx->wire[i].prop_ptr);
if(!strcmp(get_tok_value(xctx->wire[xctx->wires].prop_ptr,"bus",0), "true"))
xctx->wire[xctx->wires].bus=1;
wire[wires].x1=wire[i].x1;
wire[wires].y1=wire[i].y1;
wire[wires].x2=x0;
wire[wires].y2=y0;
wire[wires].sel=SELECTED;
wire[wires].prop_ptr=NULL;
my_strdup(33, &wire[wires].prop_ptr, wire[i].prop_ptr);
if(!strcmp(get_tok_value(wire[wires].prop_ptr,"bus",0), "true"))
wire[wires].bus=1;
else
xctx->wire[xctx->wires].bus=0;
xctx->wire[xctx->wires].node=NULL;
hash_wire(XINSERT, xctx->wires);
wire[wires].bus=0;
wire[wires].node=NULL;
hash_wire(XINSERT, wires, 0);
need_rebuild_selected_array=1;
xctx->wires++;
xctx->wire[i].x1 = x0;
xctx->wire[i].y1 = y0;
wire[i].x1 = x0;
wire[i].y1 = y0;
}
}
}

10
src/editprop.c
View File

@ -376,16 +376,6 @@ char *strtoupper(char* s) {
return s;
}
/* given a dest_string of size 'size', allocate space to make sure it can
* hold additional 'add' characters starting at position 'pos' */
void str_alloc( char **dest_string, int add, int pos, int *size)
{
if (pos + add >= *size) {
*size = (1 + (pos + add) / CADCHUNKALLOC) * CADCHUNKALLOC;
my_realloc(1212, dest_string, *size);
}
}
void set_inst_prop(int i)
{
char *ptr = NULL;

261
src/move.c
View File

@ -506,6 +506,10 @@ void copy_objects(int what)
/* int customfont; */
#endif
int const instances = xctx->instances;
xInstance * const inst = xctx->inst;
xLine ** const line = xctx->line;
xWire * const wire = xctx->wire;
if(what & BEGIN)
{
rotatelocal=0;
@ -573,33 +577,33 @@ void copy_objects(int what)
}
check_wire_storage();
/*
if(xctx->wire[n].bus){
if(wire[n].bus){
int ov, y1, y2;
ov = bus_width> cadhalfdotsize ? bus_width : CADHALFDOTSIZE;
if(xctx->wire[n].y1 < xctx->wire[n].y2) { y1 = xctx->wire[n].y1-ov; y2 = xctx->wire[n].y2+ov; }
else { y1 = xctx->wire[n].y1+ov; y2 = xctx->wire[n].y2-ov; }
bbox(ADD, xctx->wire[n].x1-ov, y1 , xctx->wire[n].x2+ov , y2 );
if(wire[n].y1 < wire[n].y2) { y1 = wire[n].y1-ov; y2 = wire[n].y2+ov; }
else { y1 = wire[n].y1+ov; y2 = wire[n].y2-ov; }
bbox(ADD, wire[n].x1-ov, y1 , wire[n].x2+ov , y2 );
} else {
int ov, y1, y2;
ov = cadhalfdotsize;
if(xctx->wire[n].y1 < xctx->wire[n].y2) { y1 = xctx->wire[n].y1-ov; y2 = xctx->wire[n].y2+ov; }
else { y1 = xctx->wire[n].y1+ov; y2 = xctx->wire[n].y2-ov; }
bbox(ADD, xctx->wire[n].x1-ov, y1 , xctx->wire[n].x2+ov , y2 );
if(wire[n].y1 < wire[n].y2) { y1 = wire[n].y1-ov; y2 = wire[n].y2+ov; }
else { y1 = wire[n].y1+ov; y2 = wire[n].y2-ov; }
bbox(ADD, wire[n].x1-ov, y1 , wire[n].x2+ov , y2 );
}
*/
if(rotatelocal) {
ROTATION(xctx->wire[n].x1, xctx->wire[n].y1, xctx->wire[n].x1, xctx->wire[n].y1, rx1,ry1);
ROTATION(xctx->wire[n].x1, xctx->wire[n].y1, xctx->wire[n].x2, xctx->wire[n].y2, rx2,ry2);
ROTATION(wire[n].x1, wire[n].y1, wire[n].x1, wire[n].y1, rx1,ry1);
ROTATION(wire[n].x1, wire[n].y1, wire[n].x2, wire[n].y2, rx2,ry2);
} else {
ROTATION(x1, y_1, xctx->wire[n].x1, xctx->wire[n].y1, rx1,ry1);
ROTATION(x1, y_1, xctx->wire[n].x2, xctx->wire[n].y2, rx2,ry2);
ROTATION(x1, y_1, wire[n].x1, wire[n].y1, rx1,ry1);
ROTATION(x1, y_1, wire[n].x2, wire[n].y2, rx2,ry2);
}
if( xctx->wire[n].sel & (SELECTED|SELECTED1) )
if( wire[n].sel & (SELECTED|SELECTED1) )
{
rx1+=deltax;
ry1+=deltay;
}
if( xctx->wire[n].sel & (SELECTED|SELECTED2) )
if( wire[n].sel & (SELECTED|SELECTED2) )
{
rx2+=deltax;
ry2+=deltay;
@ -609,13 +613,13 @@ void copy_objects(int what)
ORDER(rx1,ry1,rx2,ry2);
if( tmpx == rx2 && tmpy == ry2)
{
if(xctx->wire[n].sel == SELECTED1) xctx->wire[n].sel = SELECTED2;
else if(xctx->wire[n].sel == SELECTED2) xctx->wire[n].sel = SELECTED1;
if(wire[n].sel == SELECTED1) wire[n].sel = SELECTED2;
else if(wire[n].sel == SELECTED2) wire[n].sel = SELECTED1;
}
selectedgroup[i].n=xctx->wires;
storeobject(-1, rx1,ry1,rx2,ry2,WIRE,0,xctx->wire[n].sel,xctx->wire[n].prop_ptr);
xctx->wire[n].sel=0;
if(xctx->wire[n].bus)
storeobject(-1, rx1,ry1,rx2,ry2,WIRE,0,wire[n].sel,wire[n].prop_ptr);
wire[n].sel=0;
if(wire[n].bus)
drawline(WIRELAYER, THICK, rx1,ry1,rx2,ry2, 0);
else
drawline(WIRELAYER, ADD, rx1,ry1,rx2,ry2, 0);
@ -633,20 +637,20 @@ void copy_objects(int what)
{
case LINE:
if(c!=k) break;
/* bbox(ADD, xctx->line[c][n].x1, xctx->line[c][n].y1, xctx->line[c][n].x2, xctx->line[c][n].y2) */
/* bbox(ADD, line[c][n].x1, line[c][n].y1, line[c][n].x2, line[c][n].y2) */
if(rotatelocal) {
ROTATION(xctx->line[c][n].x1, xctx->line[c][n].y1, xctx->line[c][n].x1, xctx->line[c][n].y1, rx1,ry1);
ROTATION(xctx->line[c][n].x1, xctx->line[c][n].y1, xctx->line[c][n].x2, xctx->line[c][n].y2, rx2,ry2);
ROTATION(line[c][n].x1, line[c][n].y1, line[c][n].x1, line[c][n].y1, rx1,ry1);
ROTATION(line[c][n].x1, line[c][n].y1, line[c][n].x2, line[c][n].y2, rx2,ry2);
} else {
ROTATION(x1, y_1, xctx->line[c][n].x1, xctx->line[c][n].y1, rx1,ry1);
ROTATION(x1, y_1, xctx->line[c][n].x2, xctx->line[c][n].y2, rx2,ry2);
ROTATION(x1, y_1, line[c][n].x1, line[c][n].y1, rx1,ry1);
ROTATION(x1, y_1, line[c][n].x2, line[c][n].y2, rx2,ry2);
}
if( xctx->line[c][n].sel & (SELECTED|SELECTED1) )
if( line[c][n].sel & (SELECTED|SELECTED1) )
{
rx1+=deltax;
ry1+=deltay;
}
if( xctx->line[c][n].sel & (SELECTED|SELECTED2) )
if( line[c][n].sel & (SELECTED|SELECTED2) )
{
rx2+=deltax;
ry2+=deltay;
@ -656,16 +660,16 @@ void copy_objects(int what)
ORDER(rx1,ry1,rx2,ry2);
if( tmpx == rx2 && tmpy == ry2)
{
if(xctx->line[c][n].sel == SELECTED1) xctx->line[c][n].sel = SELECTED2;
else if(xctx->line[c][n].sel == SELECTED2) xctx->line[c][n].sel = SELECTED1;
if(line[c][n].sel == SELECTED1) line[c][n].sel = SELECTED2;
else if(line[c][n].sel == SELECTED2) line[c][n].sel = SELECTED1;
}
if(xctx->line[c][n].bus)
drawline(k, THICK, rx1,ry1,rx2,ry2, xctx->line[c][n].dash);
if(line[c][n].bus)
drawline(k, THICK, rx1,ry1,rx2,ry2, line[c][n].dash);
else
drawline(k, ADD, rx1,ry1,rx2,ry2, xctx->line[c][n].dash);
drawline(k, ADD, rx1,ry1,rx2,ry2, line[c][n].dash);
selectedgroup[i].n=xctx->lines[c];
storeobject(-1, rx1, ry1, rx2, ry2, LINE, c, xctx->line[c][n].sel, xctx->line[c][n].prop_ptr);
xctx->line[c][n].sel=0;
storeobject(-1, rx1, ry1, rx2, ry2, LINE, c, line[c][n].sel, line[c][n].prop_ptr);
line[c][n].sel=0;
break;
case POLYGON:
@ -862,34 +866,34 @@ void copy_objects(int what)
check_inst_storage();
if(rotatelocal) {
ROTATION(xctx->inst[n].x0, xctx->inst[n].y0, xctx->inst[n].x0, xctx->inst[n].y0, rx1,ry1);
ROTATION(inst[n].x0, inst[n].y0, inst[n].x0, inst[n].y0, rx1,ry1);
} else {
ROTATION(x1, y_1, xctx->inst[n].x0, xctx->inst[n].y0, rx1,ry1);
ROTATION(x1, y_1, inst[n].x0, inst[n].y0, rx1,ry1);
}
xctx->inst[xctx->instances] = xctx->inst[n];
xctx->inst[xctx->instances].prop_ptr=NULL;
xctx->inst[xctx->instances].instname=NULL;
xctx->inst[xctx->instances].node=NULL;
xctx->inst[xctx->instances].name=NULL;
my_strdup(232, &xctx->inst[xctx->instances].name, xctx->inst[n].name);
my_strdup(233, &xctx->inst[xctx->instances].prop_ptr, xctx->inst[n].prop_ptr);
my_strdup2(234, &xctx->inst[xctx->instances].instname, get_tok_value(xctx->inst[n].prop_ptr, "name",0));
xctx->inst[n].sel=0;
xctx->inst[xctx->instances].flags = xctx->inst[n].flags;
xctx->inst[xctx->instances].flags &= ~4; /* do not propagate hilight */
xctx->inst[xctx->instances].x0 = rx1+deltax;
xctx->inst[xctx->instances].y0 = ry1+deltay;
xctx->inst[xctx->instances].sel = SELECTED;
xctx->inst[xctx->instances].rot = (xctx->inst[xctx->instances].rot +
( (flip && (xctx->inst[xctx->instances].rot & 1) ) ? rot+2 : rot) ) & 0x3;
xctx->inst[xctx->instances].flip = (flip? !xctx->inst[n].flip:xctx->inst[n].flip);
inst[instances] = inst[n];
inst[instances].prop_ptr=NULL;
inst[instances].instname=NULL;
inst[instances].node=NULL;
inst[instances].name=NULL;
my_strdup(232, &inst[instances].name, inst[n].name);
my_strdup(233, &inst[instances].prop_ptr, inst[n].prop_ptr);
my_strdup2(234, &inst[instances].instname, get_tok_value(inst[n].prop_ptr, "name",0));
inst[n].sel=0;
inst[instances].flags = inst[n].flags;
inst[instances].flags &= ~4; /* do not propagate hilight */
inst[instances].x0 = rx1+deltax;
inst[instances].y0 = ry1+deltay;
inst[instances].sel = SELECTED;
inst[instances].rot = (inst[instances].rot +
( (flip && (inst[instances].rot & 1) ) ? rot+2 : rot) ) & 0x3;
inst[instances].flip = (flip? !inst[n].flip:inst[n].flip);
/* the newpropcnt argument is zero for the 1st call and used in */
/* new_prop_string() for cleaning some internal caches. */
if(!newpropcnt) hash_all_names(xctx->instances);
new_prop_string(xctx->instances, xctx->inst[n].prop_ptr,newpropcnt++, dis_uniq_names);
my_strdup2(235, &xctx->inst[xctx->instances].instname,
get_tok_value(xctx->inst[xctx->instances].prop_ptr, "name", 0));
n=selectedgroup[i].n=xctx->instances;
if(!newpropcnt) hash_all_names(instances);
new_prop_string(instances, inst[n].prop_ptr,newpropcnt++, dis_uniq_names);
my_strdup2(235, &inst[instances].instname,
get_tok_value(inst[instances].prop_ptr, "name", 0));
n=selectedgroup[i].n=instances;
xctx->instances++;
}
@ -918,16 +922,16 @@ void copy_objects(int what)
if(k == 0) {
if(selectedgroup[i].type == ELEMENT) {
int p;
symbol_bbox(n, &xctx->inst[n].x1, &xctx->inst[n].y1, &xctx->inst[n].x2, &xctx->inst[n].y2 );
bbox(ADD, xctx->inst[n].x1, xctx->inst[n].y1, xctx->inst[n].x2, xctx->inst[n].y2 );
if(show_pin_net_names) for(p = 0; p < (xctx->inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) {
if( xctx->inst[n].node && xctx->inst[n].node[p]) {
find_inst_to_be_redrawn(xctx->inst[n].node[p]);
symbol_bbox(n, &inst[n].x1, &inst[n].y1, &inst[n].x2, &inst[n].y2 );
bbox(ADD, inst[n].x1, inst[n].y1, inst[n].x2, inst[n].y2 );
if(show_pin_net_names) for(p = 0; p < (inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) {
if( inst[n].node && inst[n].node[p]) {
find_inst_to_be_redrawn(inst[n].node[p]);
}
}
}
if(show_pin_net_names && selectedgroup[i].type == WIRE) {
find_inst_to_be_redrawn(xctx->wire[n].node);
find_inst_to_be_redrawn(wire[n].node);
}
}
}
@ -967,6 +971,9 @@ void move_objects(int what, int merge, double dx, double dy)
#ifdef HAS_CAIRO
char *textfont;
#endif
xInstance * const inst = xctx->inst;
xLine ** const line = xctx->line;
xWire * const wire = xctx->wire;
if(what & BEGIN)
{
@ -1042,16 +1049,16 @@ void move_objects(int what, int merge, double dx, double dy)
n = selectedgroup[i].n;
if( selectedgroup[i].type == ELEMENT) {
int p;
symbol_bbox(n, &xctx->inst[n].x1, &xctx->inst[n].y1, &xctx->inst[n].x2, &xctx->inst[n].y2 );
bbox(ADD, xctx->inst[n].x1, xctx->inst[n].y1, xctx->inst[n].x2, xctx->inst[n].y2 );
if(show_pin_net_names) for(p = 0; p < (xctx->inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) {
if( xctx->inst[n].node && xctx->inst[n].node[p]) {
find_inst_to_be_redrawn(xctx->inst[n].node[p]);
symbol_bbox(n, &inst[n].x1, &inst[n].y1, &inst[n].x2, &inst[n].y2 );
bbox(ADD, inst[n].x1, inst[n].y1, inst[n].x2, inst[n].y2 );
if(show_pin_net_names) for(p = 0; p < (inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) {
if( inst[n].node && inst[n].node[p]) {
find_inst_to_be_redrawn(inst[n].node[p]);
}
}
}
if(show_pin_net_names && selectedgroup[i].type == WIRE) {
find_inst_to_be_redrawn(xctx->wire[n].node);
find_inst_to_be_redrawn(wire[n].node);
}
}
if(show_pin_net_names) find_inst_hash_clear();
@ -1068,95 +1075,95 @@ void move_objects(int what, int merge, double dx, double dy)
firstw = 0;
}
if(k == 0) {
if(xctx->wire[n].bus){
if(wire[n].bus){
int ov, y1, y2;
ov = bus_width> cadhalfdotsize ? bus_width : CADHALFDOTSIZE;
if(xctx->wire[n].y1 < xctx->wire[n].y2) { y1 = xctx->wire[n].y1-ov; y2 = xctx->wire[n].y2+ov; }
else { y1 = xctx->wire[n].y1+ov; y2 = xctx->wire[n].y2-ov; }
bbox(ADD, xctx->wire[n].x1-ov, y1 , xctx->wire[n].x2+ov , y2 );
if(wire[n].y1 < wire[n].y2) { y1 = wire[n].y1-ov; y2 = wire[n].y2+ov; }
else { y1 = wire[n].y1+ov; y2 = wire[n].y2-ov; }
bbox(ADD, wire[n].x1-ov, y1 , wire[n].x2+ov , y2 );
} else {
int ov, y1, y2;
ov = cadhalfdotsize;
if(xctx->wire[n].y1 < xctx->wire[n].y2) { y1 = xctx->wire[n].y1-ov; y2 = xctx->wire[n].y2+ov; }
else { y1 = xctx->wire[n].y1+ov; y2 = xctx->wire[n].y2-ov; }
bbox(ADD, xctx->wire[n].x1-ov, y1 , xctx->wire[n].x2+ov , y2 );
if(wire[n].y1 < wire[n].y2) { y1 = wire[n].y1-ov; y2 = wire[n].y2+ov; }
else { y1 = wire[n].y1+ov; y2 = wire[n].y2-ov; }
bbox(ADD, wire[n].x1-ov, y1 , wire[n].x2+ov , y2 );
}
if(rotatelocal) {
ROTATION(xctx->wire[n].x1, xctx->wire[n].y1, xctx->wire[n].x1, xctx->wire[n].y1, rx1,ry1);
ROTATION(xctx->wire[n].x1, xctx->wire[n].y1, xctx->wire[n].x2, xctx->wire[n].y2, rx2,ry2);
ROTATION(wire[n].x1, wire[n].y1, wire[n].x1, wire[n].y1, rx1,ry1);
ROTATION(wire[n].x1, wire[n].y1, wire[n].x2, wire[n].y2, rx2,ry2);
} else {
ROTATION(x1, y_1, xctx->wire[n].x1, xctx->wire[n].y1, rx1,ry1);
ROTATION(x1, y_1, xctx->wire[n].x2, xctx->wire[n].y2, rx2,ry2);
ROTATION(x1, y_1, wire[n].x1, wire[n].y1, rx1,ry1);
ROTATION(x1, y_1, wire[n].x2, wire[n].y2, rx2,ry2);
}
if( xctx->wire[n].sel & (SELECTED|SELECTED1) )
if( wire[n].sel & (SELECTED|SELECTED1) )
{
rx1+=deltax;
ry1+=deltay;
}
if( xctx->wire[n].sel & (SELECTED|SELECTED2) )
if( wire[n].sel & (SELECTED|SELECTED2) )
{
rx2+=deltax;
ry2+=deltay;
}
xctx->wire[n].x1=rx1;
xctx->wire[n].y1=ry1;
wire[n].x1=rx1;
wire[n].y1=ry1;
ORDER(rx1,ry1,rx2,ry2);
if( xctx->wire[n].x1 == rx2 && xctx->wire[n].y1 == ry2)
if( wire[n].x1 == rx2 && wire[n].y1 == ry2)
{
if(xctx->wire[n].sel == SELECTED1) xctx->wire[n].sel = SELECTED2;
else if(xctx->wire[n].sel == SELECTED2) xctx->wire[n].sel = SELECTED1;
if(wire[n].sel == SELECTED1) wire[n].sel = SELECTED2;
else if(wire[n].sel == SELECTED2) wire[n].sel = SELECTED1;
}
xctx->wire[n].x1=rx1;
xctx->wire[n].y1=ry1;
xctx->wire[n].x2=rx2;
xctx->wire[n].y2=ry2;
wire[n].x1=rx1;
wire[n].y1=ry1;
wire[n].x2=rx2;
wire[n].y2=ry2;
} else if(k == WIRELAYER) {
if(xctx->wire[n].bus)
drawline(WIRELAYER, THICK, xctx->wire[n].x1, xctx->wire[n].y1, xctx->wire[n].x2, xctx->wire[n].y2, 0);
if(wire[n].bus)
drawline(WIRELAYER, THICK, wire[n].x1, wire[n].y1, wire[n].x2, wire[n].y2, 0);
else
drawline(WIRELAYER, ADD, xctx->wire[n].x1, xctx->wire[n].y1, xctx->wire[n].x2, xctx->wire[n].y2, 0);
drawline(WIRELAYER, ADD, wire[n].x1, wire[n].y1, wire[n].x2, wire[n].y2, 0);
}
break;
case LINE:
if(c!=k) break;
bbox(ADD, xctx->line[c][n].x1, xctx->line[c][n].y1, xctx->line[c][n].x2, xctx->line[c][n].y2);
bbox(ADD, line[c][n].x1, line[c][n].y1, line[c][n].x2, line[c][n].y2);
if(rotatelocal) {
ROTATION(xctx->line[c][n].x1, xctx->line[c][n].y1, xctx->line[c][n].x1, xctx->line[c][n].y1, rx1,ry1);
ROTATION(xctx->line[c][n].x1, xctx->line[c][n].y1, xctx->line[c][n].x2, xctx->line[c][n].y2, rx2,ry2);
ROTATION(line[c][n].x1, line[c][n].y1, line[c][n].x1, line[c][n].y1, rx1,ry1);
ROTATION(line[c][n].x1, line[c][n].y1, line[c][n].x2, line[c][n].y2, rx2,ry2);
} else {
ROTATION(x1, y_1, xctx->line[c][n].x1, xctx->line[c][n].y1, rx1,ry1);
ROTATION(x1, y_1, xctx->line[c][n].x2, xctx->line[c][n].y2, rx2,ry2);
ROTATION(x1, y_1, line[c][n].x1, line[c][n].y1, rx1,ry1);
ROTATION(x1, y_1, line[c][n].x2, line[c][n].y2, rx2,ry2);
}
if( xctx->line[c][n].sel & (SELECTED|SELECTED1) )
if( line[c][n].sel & (SELECTED|SELECTED1) )
{
rx1+=deltax;
ry1+=deltay;
}
if( xctx->line[c][n].sel & (SELECTED|SELECTED2) )
if( line[c][n].sel & (SELECTED|SELECTED2) )
{
rx2+=deltax;
ry2+=deltay;
}
xctx->line[c][n].x1=rx1;
xctx->line[c][n].y1=ry1;
line[c][n].x1=rx1;
line[c][n].y1=ry1;
ORDER(rx1,ry1,rx2,ry2);
if( xctx->line[c][n].x1 == rx2 && xctx->line[c][n].y1 == ry2)
if( line[c][n].x1 == rx2 && line[c][n].y1 == ry2)
{
if(xctx->line[c][n].sel == SELECTED1) xctx->line[c][n].sel = SELECTED2;
else if(xctx->line[c][n].sel == SELECTED2) xctx->line[c][n].sel = SELECTED1;
if(line[c][n].sel == SELECTED1) line[c][n].sel = SELECTED2;
else if(line[c][n].sel == SELECTED2) line[c][n].sel = SELECTED1;
}
xctx->line[c][n].x1=rx1;
xctx->line[c][n].y1=ry1;
xctx->line[c][n].x2=rx2;
xctx->line[c][n].y2=ry2;
if(xctx->line[c][n].bus)
drawline(k, THICK, xctx->line[c][n].x1, xctx->line[c][n].y1,
xctx->line[c][n].x2, xctx->line[c][n].y2, xctx->line[c][n].dash);
line[c][n].x1=rx1;
line[c][n].y1=ry1;
line[c][n].x2=rx2;
line[c][n].y2=ry2;
if(line[c][n].bus)
drawline(k, THICK, line[c][n].x1, line[c][n].y1,
line[c][n].x2, line[c][n].y2, line[c][n].dash);
else
drawline(k, ADD, xctx->line[c][n].x1, xctx->line[c][n].y1,
xctx->line[c][n].x2, xctx->line[c][n].y2, xctx->line[c][n].dash);
drawline(k, ADD, line[c][n].x1, line[c][n].y1,
line[c][n].x2, line[c][n].y2, line[c][n].dash);
break;
case POLYGON:
@ -1389,15 +1396,15 @@ void move_objects(int what, int merge, double dx, double dy)
firsti = 0;
}
if(rotatelocal) {
ROTATION(xctx->inst[n].x0, xctx->inst[n].y0, xctx->inst[n].x0, xctx->inst[n].y0, rx1,ry1);
ROTATION(inst[n].x0, inst[n].y0, inst[n].x0, inst[n].y0, rx1,ry1);
} else {
ROTATION(x1, y_1, xctx->inst[n].x0, xctx->inst[n].y0, rx1,ry1);
ROTATION(x1, y_1, inst[n].x0, inst[n].y0, rx1,ry1);
}
xctx->inst[n].x0 = rx1+deltax;
xctx->inst[n].y0 = ry1+deltay;
xctx->inst[n].rot = (xctx->inst[n].rot +
( (flip && (xctx->inst[n].rot & 1) ) ? rot+2 : rot) ) & 0x3;
xctx->inst[n].flip = flip ^ xctx->inst[n].flip;
inst[n].x0 = rx1+deltax;
inst[n].y0 = ry1+deltay;
inst[n].rot = (inst[n].rot +
( (flip && (inst[n].rot & 1) ) ? rot+2 : rot) ) & 0x3;
inst[n].flip = flip ^ inst[n].flip;
}
break;
@ -1420,16 +1427,16 @@ void move_objects(int what, int merge, double dx, double dy)
if(k == 0) {
if(selectedgroup[i].type == ELEMENT) {
int p;
symbol_bbox(n, &xctx->inst[n].x1, &xctx->inst[n].y1, &xctx->inst[n].x2, &xctx->inst[n].y2 );
bbox(ADD, xctx->inst[n].x1, xctx->inst[n].y1, xctx->inst[n].x2, xctx->inst[n].y2 );
if(show_pin_net_names) for(p = 0; p < (xctx->inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) {
if( xctx->inst[n].node && xctx->inst[n].node[p]) {
find_inst_to_be_redrawn(xctx->inst[n].node[p]);
symbol_bbox(n, &inst[n].x1, &inst[n].y1, &inst[n].x2, &inst[n].y2 );
bbox(ADD, inst[n].x1, inst[n].y1, inst[n].x2, inst[n].y2 );
if(show_pin_net_names) for(p = 0; p < (inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) {
if( inst[n].node && inst[n].node[p]) {
find_inst_to_be_redrawn(inst[n].node[p]);
}
}
}
if(show_pin_net_names && selectedgroup[i].type == WIRE) {
find_inst_to_be_redrawn(xctx->wire[n].node);
find_inst_to_be_redrawn(wire[n].node);
}
}
/* draw_symbol(ADD,k, n,k, 0, 0, 0.0, 0.0); */

280
src/netlist.c
View File

@ -309,36 +309,36 @@ void hash_inst_pin(int what, int i, int j)
* 0, XINSERT : add to hash
* 1, XDELETE : remove from hash
*/
void hash_wire(int what, int n)
void hash_wire(int what, int n, int incremental)
{
int tmpi,tmpj, counti,countj,i,j;
double tmpd;
double x1, y1, x2, y2;
int x1a, x2a, y1a, y2a;
struct wireentry *wptr;
xWire * const wire = xctx->wire;
/* wire[n].node=NULL; */
my_free(827, &wire[n].node);
/* xctx->wire[n].node=NULL; */
my_free(827, &xctx->wire[n].node);
xctx->wire[n].end1 = xctx->wire[n].end2=-1;
x1=xctx->wire[n].x1;
x2=xctx->wire[n].x2;
y1=xctx->wire[n].y1;
y2=xctx->wire[n].y2;
wire[n].end1 = wire[n].end2=-1;
x1=wire[n].x1;
x2=wire[n].x2;
y1=wire[n].y1;
y2=wire[n].y2;
/* ordered bbox */
if( x2 < x1) { tmpd=x2;x2=x1;x1=tmpd;}
if( y2 < y1) { tmpd=y2;y2=y1;y1=tmpd;}
/* calculate square 4 1st bbox point of xctx->wire[k] */
/* calculate square 4 1st bbox point of wire[k] */
x1a=floor(x1/BOXSIZE) ;
y1a=floor(y1/BOXSIZE) ;
/* calculate square 4 2nd bbox point of xctx->wire[k] */
/* calculate square 4 2nd bbox point of wire[k] */
x2a=floor(x2/BOXSIZE);
y2a=floor(y2/BOXSIZE);
/*loop thru all squares that intersect bbox of xctx->wire[k] */
/*loop thru all squares that intersect bbox of wire[k] */
counti=0;
for(i=x1a; i<=x2a && counti < NBOXES; i++)
{
@ -349,13 +349,13 @@ void hash_wire(int what, int n)
{
countj++;
tmpj=j%NBOXES; if(tmpj<0) tmpj+=NBOXES;
/* insert xctx->wire[n] in region [tmpi, tmpj] */
/* insert wire[n] in region [tmpi, tmpj] */
if(what==XINSERT) wireinsert(n, tmpi, tmpj);
else wiredelete(n, tmpi, tmpj);
/* reset ends of all wires that *could* touch xctx->wire[n] */
for(wptr = wiretable[tmpi][tmpj] ; wptr ; wptr = wptr->next) {
xctx->wire[wptr->n].end1 = xctx->wire[wptr->n].end2 = -1;
/* reset ends of all wires that *could* touch wire[n] */
if(incremental) for(wptr = wiretable[tmpi][tmpj] ; wptr ; wptr = wptr->next) {
wire[wptr->n].end1 = wire[wptr->n].end2 = -1;
}
}
}
@ -367,7 +367,8 @@ void hash_wires(void)
if(prepared_hash_wires) return;
del_wire_table();
for(n=0; n<xctx->wires; n++) hash_wire(XINSERT, n);
for(n=0; n<xctx->wires; n++) hash_wire(XINSERT, n, 0);
prepared_hash_wires=1;
}
@ -469,23 +470,24 @@ static void wirecheck(int k) /* recursive routine */
double x1, y1, x2, y2;
int x1a, x2a, y1a, y2a;
struct wireentry *ptr2;
xWire * const wire = xctx->wire;
x1=xctx->wire[k].x1;
x2=xctx->wire[k].x2;
y1=xctx->wire[k].y1;
y2=xctx->wire[k].y2;
x1=wire[k].x1;
x2=wire[k].x2;
y1=wire[k].y1;
y2=wire[k].y2;
/* ordered bbox */
RECTORDER(x1, y1, x2, y2);
/* calculate square 4 1st bbox point of xctx->wire[k] */
/* calculate square 4 1st bbox point of wire[k] */
x1a=floor(x1/BOXSIZE) ;
y1a=floor(y1/BOXSIZE) ;
/* calculate square 4 2nd bbox point of xctx->wire[k] */
/* calculate square 4 2nd bbox point of wire[k] */
x2a=floor(x2/BOXSIZE);
y2a=floor(y2/BOXSIZE);
/*loop thru all squares that intersect bbox of xctx->wire[k] */
/*loop thru all squares that intersect bbox of wire[k] */
counti=0;
for(i=x1a; i<=x2a && counti < NBOXES; i++)
{
@ -496,25 +498,25 @@ static void wirecheck(int k) /* recursive routine */
{
countj++;
tmpj=j%NBOXES; if(tmpj<0) tmpj+=NBOXES;
/*check if xctx->wire[k] touches wires in square [tmpi, tmpj] */
/*check if wire[k] touches wires in square [tmpi, tmpj] */
ptr2=wiretable[tmpi][tmpj];
while(ptr2)
{
if(xctx->wire[ptr2->n].node) {ptr2=ptr2->next; continue;} /* 20171207 net already checked. Move on */
if(wire[ptr2->n].node) {ptr2=ptr2->next; continue;} /* 20171207 net already checked. Move on */
if(ptr2->n != k) { /* 20171204 avoid checking wire against itself */
touches = touch(xctx->wire[k].x1,xctx->wire[k].y1,xctx->wire[k].x2,xctx->wire[k].y2,
xctx->wire[ptr2->n].x1,xctx->wire[ptr2->n].y1) ||
touch(xctx->wire[k].x1,xctx->wire[k].y1,xctx->wire[k].x2,xctx->wire[k].y2,
xctx->wire[ptr2->n].x2,xctx->wire[ptr2->n].y2) ||
touch(xctx->wire[ptr2->n].x1,xctx->wire[ptr2->n].y1,xctx->wire[ptr2->n].x2,
xctx->wire[ptr2->n].y2, xctx->wire[k].x1,xctx->wire[k].y1) ||
touch(xctx->wire[ptr2->n].x1,xctx->wire[ptr2->n].y1,xctx->wire[ptr2->n].x2,
xctx->wire[ptr2->n].y2, xctx->wire[k].x2,xctx->wire[k].y2);
touches = touch(wire[k].x1,wire[k].y1,wire[k].x2,wire[k].y2,
wire[ptr2->n].x1,wire[ptr2->n].y1) ||
touch(wire[k].x1,wire[k].y1,wire[k].x2,wire[k].y2,
wire[ptr2->n].x2,wire[ptr2->n].y2) ||
touch(wire[ptr2->n].x1,wire[ptr2->n].y1,wire[ptr2->n].x2,
wire[ptr2->n].y2, wire[k].x1,wire[k].y1) ||
touch(wire[ptr2->n].x1,wire[ptr2->n].y1,wire[ptr2->n].x2,
wire[ptr2->n].y2, wire[k].x2,wire[k].y2);
if( touches )
{
my_strdup(239, &xctx->wire[ptr2->n].node, xctx->wire[k].node);
my_strdup(240, &xctx->wire[ptr2->n].prop_ptr,
subst_token(xctx->wire[ptr2->n].prop_ptr, "lab", xctx->wire[ptr2->n].node));
my_strdup(239, &wire[ptr2->n].node, wire[k].node);
my_strdup(240, &wire[ptr2->n].prop_ptr,
subst_token(wire[ptr2->n].prop_ptr, "lab", wire[ptr2->n].node));
wirecheck(ptr2->n); /* recursive check */
}
}
@ -635,6 +637,8 @@ void prepare_netlist_structs(int for_netlist)
int inst_mult, pin_mult;
int print_erc;
static int startlevel = 0;
xInstance * const inst = xctx->inst;
int const instances = xctx->instances;
if (for_netlist>0 && prepared_netlist_structs) return;
else if (!for_netlist && prepared_hilight_structs) return;
@ -649,32 +653,32 @@ void prepare_netlist_structs(int for_netlist)
/* reset wire & inst node labels */
dbg(1, "prepare_netlist_structs(): resetting node hash tables\n");
hash_wires();
for (i=0;i<xctx->instances;i++)
for (i=0;i<instances;i++)
{
if (xctx->inst[i].ptr<0) continue;
if (inst[i].ptr<0) continue;
delete_inst_node(i);
rects=(xctx->inst[i].ptr+ xctx->sym)->rects[PINLAYER] +
(xctx->inst[i].ptr+ xctx->sym)->rects[GENERICLAYER];
rects=(inst[i].ptr+ xctx->sym)->rects[PINLAYER] +
(inst[i].ptr+ xctx->sym)->rects[GENERICLAYER];
if (rects > 0)
{
xctx->inst[i].node = my_malloc(247, sizeof(char *) * rects);
inst[i].node = my_malloc(247, sizeof(char *) * rects);
for (j=0;j<rects;j++)
{
xctx->inst[i].node[j]=NULL;
inst[i].node[j]=NULL;
hash_inst_pin(XINSERT, i, j);
}
}
}
dbg(2, "prepare_netlist_structs(): naming pins from attrs\n");
for (i=0;i<xctx->instances;i++)
for (i=0;i<instances;i++)
{
/* name ipin opin label node fields from prop_ptr attributes */
if (xctx->inst[i].ptr<0) continue;
if (inst[i].ptr<0) continue;
my_strdup(248, &type,(xctx->inst[i].ptr+ xctx->sym)->type);
if(print_erc && (!xctx->inst[i].instname || !xctx->inst[i].instname[0]) &&
!get_tok_value((xctx->inst[i].ptr+ xctx->sym)->templ, "name", 0)[0]
my_strdup(248, &type,(inst[i].ptr+ xctx->sym)->type);
if(print_erc && (!inst[i].instname || !inst[i].instname[0]) &&
!get_tok_value((inst[i].ptr+ xctx->sym)->templ, "name", 0)[0]
) {
char str[2048];
if( type &&
@ -684,30 +688,30 @@ void prepare_netlist_structs(int for_netlist)
strcmp(type, "arch_declarations") &&
strcmp(type, "attributes") &&
strcmp(type, "use")) {
my_snprintf(str, S(str), "instance: %d (%s): no name attribute set", i, xctx->inst[i].name);
my_snprintf(str, S(str), "instance: %d (%s): no name attribute set", i, inst[i].name);
statusmsg(str,2);
xctx->inst[i].flags |=4;
inst[i].flags |=4;
hilight_nets=1;
}
}
if(print_erc && (!type || !type[0]) ) {
char str[2048];
my_snprintf(str, S(str), "xSymbol: %s: no type attribute set", xctx->inst[i].name);
my_snprintf(str, S(str), "xSymbol: %s: no type attribute set", inst[i].name);
statusmsg(str,2);
xctx->inst[i].flags |=4;
inst[i].flags |=4;
hilight_nets=1;
}
if(type && xctx->inst[i].node && IS_LABEL_OR_PIN(type) ) { /* instance must have a pin! */
if(type && inst[i].node && IS_LABEL_OR_PIN(type) ) { /* instance must have a pin! */
if (for_netlist>0) {
/* 20150918 skip labels / pins if ignore property specified on instance */
if( netlist_type == CAD_VERILOG_NETLIST &&
strcmp(get_tok_value(xctx->inst[i].prop_ptr,"verilog_ignore",0),"true")==0 ) continue;
strcmp(get_tok_value(inst[i].prop_ptr,"verilog_ignore",0),"true")==0 ) continue;
if( netlist_type == CAD_SPICE_NETLIST &&
strcmp(get_tok_value(xctx->inst[i].prop_ptr,"spice_ignore",0),"true")==0 ) continue;
strcmp(get_tok_value(inst[i].prop_ptr,"spice_ignore",0),"true")==0 ) continue;
if( netlist_type == CAD_VHDL_NETLIST &&
strcmp(get_tok_value(xctx->inst[i].prop_ptr,"vhdl_ignore",0),"true")==0 ) continue;
strcmp(get_tok_value(inst[i].prop_ptr,"vhdl_ignore",0),"true")==0 ) continue;
if( netlist_type == CAD_TEDAX_NETLIST &&
strcmp(get_tok_value(xctx->inst[i].prop_ptr,"tedax_ignore",0),"true")==0 ) continue;
strcmp(get_tok_value(inst[i].prop_ptr,"tedax_ignore",0),"true")==0 ) continue;
}
port=0;
if (strcmp(type,"label")) { /* instance is a port (not a label) */
@ -715,11 +719,11 @@ void prepare_netlist_structs(int for_netlist)
/* 20071204 only define a dir property if instance is not a label */
if (!for_netlist) my_strdup(249, &dir, "");
else
my_strdup(250, &dir, get_tok_value( (xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][0].prop_ptr, "dir",0));
my_strdup(250, &dir, get_tok_value( (inst[i].ptr+ xctx->sym)->rect[PINLAYER][0].prop_ptr, "dir",0));
}
else {
/* handle global nodes (global=1 set as symbol property) 28032003 */
my_strdup(251, &global_node,get_tok_value((xctx->inst[i].ptr+ xctx->sym)->prop_ptr,"global",0));
my_strdup(251, &global_node,get_tok_value((inst[i].ptr+ xctx->sym)->prop_ptr,"global",0));
/*20071204 if instance is a label dont define a dir property for more precise erc checking */
my_strdup(252, &dir,"none");
}
@ -734,54 +738,54 @@ void prepare_netlist_structs(int for_netlist)
my_free(833, &value);
my_free(834, &class);
} else {
my_strdup(258, &sig_type,get_tok_value(xctx->inst[i].prop_ptr,"sig_type",0));
my_strdup(259, &verilog_type,get_tok_value(xctx->inst[i].prop_ptr,"verilog_type",0));
my_strdup(260, &value,get_tok_value(xctx->inst[i].prop_ptr,"value",2));
my_strdup(261, &class,get_tok_value(xctx->inst[i].prop_ptr,"class",0));
my_strdup(258, &sig_type,get_tok_value(inst[i].prop_ptr,"sig_type",0));
my_strdup(259, &verilog_type,get_tok_value(inst[i].prop_ptr,"verilog_type",0));
my_strdup(260, &value,get_tok_value(inst[i].prop_ptr,"value",2));
my_strdup(261, &class,get_tok_value(inst[i].prop_ptr,"class",0));
}
my_strdup(262, &xctx->inst[i].node[0], get_tok_value(xctx->inst[i].prop_ptr,"lab",1));
my_strdup(262, &inst[i].node[0], get_tok_value(inst[i].prop_ptr,"lab",1));
if (!(xctx->inst[i].node[0])) {
my_strdup(65, &xctx->inst[i].node[0], get_tok_value((xctx->inst[i].ptr+ xctx->sym)->templ, "lab",1));
dbg(1, "no lab attr on instance, pick from symbol: %s\n", xctx->inst[i].node[0]);
if (!(inst[i].node[0])) {
my_strdup(65, &inst[i].node[0], get_tok_value((inst[i].ptr+ xctx->sym)->templ, "lab",1));
dbg(1, "no lab attr on instance, pick from symbol: %s\n", inst[i].node[0]);
}
/* handle global nodes (global=1 set as symbol property) 28032003 */
if (!strcmp(type,"label") && global_node && !strcmp(global_node, "true")) {
dbg(1, "prepare_netlist_structs(): global node: %s\n",xctx->inst[i].node[0]);
record_global_node(1,NULL, xctx->inst[i].node[0]);
dbg(1, "prepare_netlist_structs(): global node: %s\n",inst[i].node[0]);
record_global_node(1,NULL, inst[i].node[0]);
}
/* do not count multiple labels/pins with same name */
bus_hash_lookup(xctx->inst[i].node[0], /* insert node in hash table */
bus_hash_lookup(inst[i].node[0], /* insert node in hash table */
dir, XINSERT, port, sig_type, verilog_type, value, class);
dbg(2, "prepare_netlist_structs(): name=%s\n",
get_tok_value( xctx->inst[i].prop_ptr, "lab",0));
get_tok_value( inst[i].prop_ptr, "lab",0));
dbg(2, "prepare_netlist_structs(): pin=%s\n",
get_tok_value( (xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][0].prop_ptr, "name",0));
get_tok_value( (inst[i].ptr+ xctx->sym)->rect[PINLAYER][0].prop_ptr, "name",0));
dbg(2, "prepare_netlist_structs(): dir=%s\n",
get_tok_value( (xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][0].prop_ptr, "dir",0));
get_tok_value( (inst[i].ptr+ xctx->sym)->rect[PINLAYER][0].prop_ptr, "dir",0));
/* name nets that touch ioin opin alias instances */
rct=(xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER];
rct=(inst[i].ptr+ xctx->sym)->rect[PINLAYER];
x0=(rct[0].x1+rct[0].x2)/2;
y0=(rct[0].y1+rct[0].y2)/2;
rot=xctx->inst[i].rot;
flip=xctx->inst[i].flip;
rot=inst[i].rot;
flip=inst[i].flip;
ROTATION(0.0,0.0,x0,y0,rx1,ry1);
x0=xctx->inst[i].x0+rx1;
y0=xctx->inst[i].y0+ry1;
x0=inst[i].x0+rx1;
y0=inst[i].y0+ry1;
get_square(x0, y0, &sqx, &sqy);
wptr=wiretable[sqx][sqy];
if (xctx->inst[i].node[0]) while(wptr)
if (inst[i].node[0]) while(wptr)
{
if (touch(xctx->wire[wptr->n].x1, xctx->wire[wptr->n].y1,
xctx->wire[wptr->n].x2, xctx->wire[wptr->n].y2, x0,y0))
{
/* short circuit check */
if (for_netlist>0) signal_short(xctx->wire[wptr->n].node, xctx->inst[i].node[0]);
my_strdup(263, &xctx->wire[wptr->n].node, xctx->inst[i].node[0]);
if (for_netlist>0) signal_short(xctx->wire[wptr->n].node, inst[i].node[0]);
my_strdup(263, &xctx->wire[wptr->n].node, inst[i].node[0]);
my_strdup(264, &xctx->wire[wptr->n].prop_ptr,
subst_token(xctx->wire[wptr->n].prop_ptr, "lab", xctx->wire[wptr->n].node));
wirecheck(wptr->n);
@ -789,7 +793,7 @@ void prepare_netlist_structs(int for_netlist)
wptr=wptr->next;
}
} /* if(type && ... */
} /* for(i=0;i<xctx->instances... */
} /* for(i=0;i<instances... */
/* name nets that do not touch ipin opin alias instances */
dbg(2, "prepare_netlist_structs(): naming nets that dont touch labels\n");
@ -817,24 +821,24 @@ void prepare_netlist_structs(int for_netlist)
/* name generic pins from attached labels */
dbg(2, "prepare_netlist_structs(): naming generics from attached labels\n");
if(for_netlist) for (i=0;i<xctx->instances;i++) { /* ... assign node fields on all (non label) instances */
if (xctx->inst[i].ptr<0) continue;
my_strdup(267, &type,(xctx->inst[i].ptr+ xctx->sym)->type);
if(for_netlist) for (i=0;i<instances;i++) { /* ... assign node fields on all (non label) instances */
if (inst[i].ptr<0) continue;
my_strdup(267, &type,(inst[i].ptr+ xctx->sym)->type);
if (type && !IS_LABEL_OR_PIN(type) ) {
if ((generic_rects = (xctx->inst[i].ptr+ xctx->sym)->rects[GENERICLAYER]) > 0)
if ((generic_rects = (inst[i].ptr+ xctx->sym)->rects[GENERICLAYER]) > 0)
{
rects = (xctx->inst[i].ptr+ xctx->sym)->rects[PINLAYER];
rects = (inst[i].ptr+ xctx->sym)->rects[PINLAYER];
for (j=rects;j<rects+generic_rects;j++)
{
if (xctx->inst[i].node[j]) continue; /* already named node */
rct=(xctx->inst[i].ptr+ xctx->sym)->rect[GENERICLAYER];
if (inst[i].node[j]) continue; /* already named node */
rct=(inst[i].ptr+ xctx->sym)->rect[GENERICLAYER];
x0=(rct[j-rects].x1+rct[j-rects].x2)/2;
y0=(rct[j-rects].y1+rct[j-rects].y2)/2;
rot=xctx->inst[i].rot;
flip=xctx->inst[i].flip;
rot=inst[i].rot;
flip=inst[i].flip;
ROTATION(0.0,0.0,x0,y0,rx1,ry1);
x0=xctx->inst[i].x0+rx1;
y0=xctx->inst[i].y0+ry1;
x0=inst[i].x0+rx1;
y0=inst[i].y0+ry1;
get_square(x0, y0, &sqx, &sqy);
iptr=instpintable[sqx][sqy];
@ -847,33 +851,33 @@ void prepare_netlist_structs(int for_netlist)
}
if ((iptr->x0==x0) && (iptr->y0==y0))
{
if ((xctx->inst[iptr->n].ptr+ xctx->sym)->type && xctx->inst[iptr->n].node[iptr->pin] != NULL &&
!strcmp((xctx->inst[iptr->n].ptr+ xctx->sym)->type, "label"))
if ((inst[iptr->n].ptr+ xctx->sym)->type && inst[iptr->n].node[iptr->pin] != NULL &&
!strcmp((inst[iptr->n].ptr+ xctx->sym)->type, "label"))
{
dbg(2, "prepare_netlist_structs(): naming generic %s\n",
xctx->inst[iptr->n].node[iptr->pin]);
inst[iptr->n].node[iptr->pin]);
my_strdup(268, &xctx->inst[i].node[j],
get_tok_value(xctx->inst[iptr->n].prop_ptr,"value",2) );
my_strdup(268, &inst[i].node[j],
get_tok_value(inst[iptr->n].prop_ptr,"value",2) );
/*my_strdup(269, &xctx->inst[i].node[j], xctx->inst[iptr->n].node[iptr->pin] ); */
/*my_strdup(269, &inst[i].node[j], inst[iptr->n].node[iptr->pin] ); */
if (!for_netlist) {
my_strdup(270, &sig_type,"");
bus_hash_lookup(xctx->inst[iptr->n].node[iptr->pin],"none",
bus_hash_lookup(inst[iptr->n].node[iptr->pin],"none",
XINSERT, 1, sig_type,"", "","");
} else {
my_strdup(271, &sig_type,get_tok_value(
(xctx->inst[i].ptr+ xctx->sym)->rect[GENERICLAYER][j-rects].prop_ptr, "sig_type",0));
(inst[i].ptr+ xctx->sym)->rect[GENERICLAYER][j-rects].prop_ptr, "sig_type",0));
/* insert generic label in hash table as a port so it will not */
/* be declared as a signal in the vhdl netlist. this is a workaround */
/* that should be fixed 25092001 */
bus_hash_lookup(xctx->inst[iptr->n].node[iptr->pin],
get_tok_value((xctx->inst[i].ptr+ xctx->sym)->rect[GENERICLAYER][j-rects].prop_ptr, "dir",0),
bus_hash_lookup(inst[iptr->n].node[iptr->pin],
get_tok_value((inst[i].ptr+ xctx->sym)->rect[GENERICLAYER][j-rects].prop_ptr, "dir",0),
XINSERT, 1, sig_type,"", "","");
}
} /* end if(xctx->inst[iptr->n].node[iptr->pin] != NULL) */
} /* end if(inst[iptr->n].node[iptr->pin] != NULL) */
} /* end if( (iptr->x0==x0) && (iptr->y0==y0) ) */
iptr=iptr->next;
}
@ -886,26 +890,26 @@ void prepare_netlist_structs(int for_netlist)
/* name instance pins of non (label,pin) instances */
dbg(2, "prepare_netlist_structs(): assigning node names on instance pins\n");
for (i=0;i<xctx->instances;i++) /* ... assign node fields on all (non label) instances */
for (i=0;i<instances;i++) /* ... assign node fields on all (non label) instances */
{
if(xctx->inst[i].ptr<0) continue;
expandlabel(xctx->inst[i].instname, &inst_mult);
my_strdup(272, &type,(xctx->inst[i].ptr+ xctx->sym)->type);
if(inst[i].ptr<0) continue;
expandlabel(inst[i].instname, &inst_mult);
my_strdup(272, &type,(inst[i].ptr+ xctx->sym)->type);
if (type && !IS_LABEL_OR_PIN(type) ) {
if ((rects = (xctx->inst[i].ptr+ xctx->sym)->rects[PINLAYER]) > 0)
if ((rects = (inst[i].ptr+ xctx->sym)->rects[PINLAYER]) > 0)
{
for (j=0;j<rects;j++)
{
touches=0;
if (xctx->inst[i].node[j]) continue; /* already named node */
rct=(xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER];
if (inst[i].node[j]) continue; /* already named node */
rct=(inst[i].ptr+ xctx->sym)->rect[PINLAYER];
x0=(rct[j].x1+rct[j].x2)/2;
y0=(rct[j].y1+rct[j].y2)/2;
rot=xctx->inst[i].rot;
flip=xctx->inst[i].flip;
rot=inst[i].rot;
flip=inst[i].flip;
ROTATION(0.0,0.0,x0,y0,rx1,ry1);
x0=xctx->inst[i].x0+rx1;
y0=xctx->inst[i].y0+ry1;
x0=inst[i].x0+rx1;
y0=inst[i].y0+ry1;
get_square(x0, y0, &sqx, &sqy);
/* name instance nodes that touch named nets */
wptr=wiretable[sqx][sqy];
@ -919,21 +923,21 @@ void prepare_netlist_structs(int for_netlist)
/* short circuit check */
if (touches)
{
if (for_netlist>0) signal_short(xctx->inst[i].node[j], xctx->wire[wptr->n].node);
if (for_netlist>0) signal_short(inst[i].node[j], xctx->wire[wptr->n].node);
}
if (!touches)
{
my_strdup(273, &xctx->inst[i].node[j], xctx->wire[wptr->n].node );
bus_hash_lookup(xctx->inst[i].node[j],
get_tok_value( (xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0),
my_strdup(273, &inst[i].node[j], xctx->wire[wptr->n].node );
bus_hash_lookup(inst[i].node[j],
get_tok_value( (inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0),
XINSERT, 0,"","","","");
if (xctx->wire[wptr->n].node[0]=='#') /* unnamed node, update its multiplicity */
{
expandlabel(get_tok_value(
(xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr,"name",0),&pin_mult);
(inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr,"name",0),&pin_mult);
get_unnamed_node(2, pin_mult * inst_mult, atoi((xctx->inst[i].node[j])+4) );
get_unnamed_node(2, pin_mult * inst_mult, atoi((inst[i].node[j])+4) );
}
} /* end if(!touches) */
touches=1;
@ -953,35 +957,35 @@ void prepare_netlist_structs(int for_netlist)
}
if ((iptr->x0==x0) && (iptr->y0==y0))
{
if (xctx->inst[iptr->n].node[iptr->pin] != NULL)
if (inst[iptr->n].node[iptr->pin] != NULL)
{
/* short circuit check */
if (touches)
{
if (for_netlist>0) signal_short(xctx->inst[i].node[j], xctx->inst[iptr->n].node[iptr->pin]);
if (for_netlist>0) signal_short(inst[i].node[j], inst[iptr->n].node[iptr->pin]);
}
if (!touches)
{
my_strdup(274, &xctx->inst[i].node[j], xctx->inst[iptr->n].node[iptr->pin] );
my_strdup(274, &inst[i].node[j], inst[iptr->n].node[iptr->pin] );
if (!for_netlist) {
bus_hash_lookup(xctx->inst[i].node[j],"none", XINSERT, 0,"","","","");
bus_hash_lookup(inst[i].node[j],"none", XINSERT, 0,"","","","");
} else {
bus_hash_lookup(xctx->inst[i].node[j],
get_tok_value( (xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0),
bus_hash_lookup(inst[i].node[j],
get_tok_value( (inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0),
XINSERT, 0,"","","","");
}
if ((xctx->inst[i].node[j])[0] == '#')
if ((inst[i].node[j])[0] == '#')
{
expandlabel(get_tok_value(
(xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr,"name",0),&pin_mult );
(inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr,"name",0),&pin_mult );
/* done at beginning of for(i) loop 20171210 */
/* expandlabel(get_tok_value( */
/* xctx->inst[i].prop_ptr,"name",0), &inst_mult); */
get_unnamed_node(2, pin_mult * inst_mult, atoi((xctx->inst[i].node[j])+4));
/* inst[i].prop_ptr,"name",0), &inst_mult); */
get_unnamed_node(2, pin_mult * inst_mult, atoi((inst[i].node[j])+4));
}
}
touches=1;
} /* end if(xctx->inst[iptr->n].node[iptr->pin] != NULL) */
} /* end if(inst[iptr->n].node[iptr->pin] != NULL) */
else /* touches instance with unnamed pins */
{
touches_unnamed=1;
@ -997,17 +1001,17 @@ void prepare_netlist_structs(int for_netlist)
if (!(CAD_VHDL_NETLIST && !touches_unnamed))
{
expandlabel(get_tok_value(
(xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr,"name",0), &pin_mult);
(inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr,"name",0), &pin_mult);
/* done at beginning of for(i) loop 20171210 */
/* expandlabel(get_tok_value( */
/* xctx->inst[i].prop_ptr,"name",0), &inst_mult); */
/* inst[i].prop_ptr,"name",0), &inst_mult); */
my_snprintf( tmp_str, S(tmp_str), "#net%d", get_unnamed_node(1, pin_mult * inst_mult, 0));
my_strdup(275, &xctx->inst[i].node[j], tmp_str );
my_strdup(275, &inst[i].node[j], tmp_str );
if (!for_netlist) {
bus_hash_lookup(xctx->inst[i].node[j],"none", XINSERT, 0,"","","","");
bus_hash_lookup(inst[i].node[j],"none", XINSERT, 0,"","","","");
} else {
bus_hash_lookup(xctx->inst[i].node[j],
get_tok_value( (xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0),
bus_hash_lookup(inst[i].node[j],
get_tok_value( (inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0),
XINSERT, 0,"","","","");
}
}

66
src/save.c
View File

@ -1544,6 +1544,8 @@ int load_sym_def(const char *name, FILE *embed_fd)
const char *str;
char *skip_line;
const char *dash;
xSymbol * const symbol = xctx->sym;
int const symbols = xctx->symbols;
dbg(1, "l_s_d(): recursion_counter=%d, name=%s\n", recursion_counter, name);
recursion_counter++;
@ -1581,11 +1583,11 @@ int load_sym_def(const char *name, FILE *embed_fd)
lastt=0;
tt=NULL;
check_symbol_storage();
xctx->sym[xctx->symbols].prop_ptr = NULL;
xctx->sym[xctx->symbols].type = NULL;
xctx->sym[xctx->symbols].templ = NULL;
xctx->sym[xctx->symbols].name=NULL;
my_strdup(352, &xctx->sym[xctx->symbols].name,name);
symbol[symbols].prop_ptr = NULL;
symbol[symbols].type = NULL;
symbol[symbols].templ = NULL;
symbol[symbols].name=NULL;
my_strdup(352, &symbol[symbols].name,name);
while(1)
{
if(endfile && embed_fd && level == 0) break; /* ']' line encountered --> exit */
@ -1620,25 +1622,25 @@ int load_sym_def(const char *name, FILE *embed_fd)
break;
case 'K': /* 1.2 file format: symbol attributes for schematics placed as symbols */
if (level==0) {
load_ascii_string(&xctx->sym[xctx->symbols].prop_ptr, lcc[level].fd);
if(!xctx->sym[xctx->symbols].prop_ptr) break;
my_strdup2(424, &xctx->sym[xctx->symbols].templ,
get_tok_value(xctx->sym[xctx->symbols].prop_ptr, "template",2));
my_strdup2(515, &xctx->sym[xctx->symbols].type,
get_tok_value(xctx->sym[xctx->symbols].prop_ptr, "type",0));
load_ascii_string(&symbol[symbols].prop_ptr, lcc[level].fd);
if(!symbol[symbols].prop_ptr) break;
my_strdup2(424, &symbol[symbols].templ,
get_tok_value(symbol[symbols].prop_ptr, "template",2));
my_strdup2(515, &symbol[symbols].type,
get_tok_value(symbol[symbols].prop_ptr, "type",0));
}
else {
load_ascii_string(&aux_ptr, lcc[level].fd);
}
break;
case 'G': /* .sym files or pre-1.2 symbol attributes for schematics placed as symbols */
if (level==0 && !xctx->sym[xctx->symbols].prop_ptr) {
load_ascii_string(&xctx->sym[xctx->symbols].prop_ptr, lcc[level].fd);
if(!xctx->sym[xctx->symbols].prop_ptr) break;
my_strdup2(341, &xctx->sym[xctx->symbols].templ,
get_tok_value(xctx->sym[xctx->symbols].prop_ptr, "template",2));
my_strdup2(342, &xctx->sym[xctx->symbols].type,
get_tok_value(xctx->sym[xctx->symbols].prop_ptr, "type",0));
if (level==0 && !symbol[symbols].prop_ptr) {
load_ascii_string(&symbol[symbols].prop_ptr, lcc[level].fd);
if(!symbol[symbols].prop_ptr) break;
my_strdup2(341, &symbol[symbols].templ,
get_tok_value(symbol[symbols].prop_ptr, "template",2));
my_strdup2(342, &symbol[symbols].type,
get_tok_value(symbol[symbols].prop_ptr, "type",0));
}
else {
load_ascii_string(&aux_ptr, lcc[level].fd);
@ -2017,28 +2019,28 @@ int load_sym_def(const char *name, FILE *embed_fd)
fclose(lcc[0].fd);
}
if(embed_fd || strstr(name, ".xschem_embedded_")) {
xctx->sym[xctx->symbols].flags |= EMBEDDED;
symbol[symbols].flags |= EMBEDDED;
} else {
xctx->sym[xctx->symbols].flags &= ~EMBEDDED;
symbol[symbols].flags &= ~EMBEDDED;
}
dbg(2, "l_d_s(): finished parsing file\n");
for(c=0;c<cadlayers;c++)
{
xctx->sym[xctx->symbols].arcs[c] = lasta[c];
xctx->sym[xctx->symbols].lines[c] = lastl[c];
xctx->sym[xctx->symbols].rects[c] = lastr[c];
xctx->sym[xctx->symbols].polygons[c] = lastp[c];
xctx->sym[xctx->symbols].arc[c] = aa[c];
xctx->sym[xctx->symbols].line[c] = ll[c];
xctx->sym[xctx->symbols].poly[c] = pp[c];
xctx->sym[xctx->symbols].rect[c] = bb[c];
symbol[symbols].arcs[c] = lasta[c];
symbol[symbols].lines[c] = lastl[c];
symbol[symbols].rects[c] = lastr[c];
symbol[symbols].polygons[c] = lastp[c];
symbol[symbols].arc[c] = aa[c];
symbol[symbols].line[c] = ll[c];
symbol[symbols].poly[c] = pp[c];
symbol[symbols].rect[c] = bb[c];
}
xctx->sym[xctx->symbols].texts = lastt;
xctx->sym[xctx->symbols].text = tt;
calc_symbol_bbox(xctx->symbols);
symbol[symbols].texts = lastt;
symbol[symbols].text = tt;
calc_symbol_bbox(symbols);
/* given a .sch file used as instance in LCC schematics, order its pin
* as in corresponding .sym file if it exists */
align_sch_pins_with_sym(name, xctx->symbols);
align_sch_pins_with_sym(name, symbols);
xctx->symbols++;
my_free(910, &prop_ptr);
my_free(901, &lastl);

129
src/token.c
View File

@ -306,8 +306,8 @@ int set_different_token(char **s,const char *new, const char *old, int object, i
else if( (state==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote && !escape) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&value, value_pos, &sizeval);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE) {
value[value_pos++]=c;
@ -353,8 +353,8 @@ int set_different_token(char **s,const char *new, const char *old, int object, i
else if( (state==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote && !escape) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&value, value_pos, &sizeval);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE) {
value[value_pos++]=c;
@ -421,7 +421,7 @@ const char *list_tokens(const char *s, int with_quotes)
else if( (state==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote && !escape ) state=XEND;
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&token, token_pos, &sizetok);
if(c=='"') {
if(!escape) quote=!quote;
}
@ -490,8 +490,15 @@ const char *get_tok_value(const char *s,const char *tok, int with_quotes)
else if( (state==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote && !escape ) state=XEND;
str_alloc(&result, 0, value_pos, &size);
str_alloc(&token, 0, token_pos, &sizetok);
/* don't use STR_ALLOC() for efficiency reasons */
if(value_pos>=size) {
size+=CADCHUNKALLOC;
my_realloc(436, &result,size);
}
if(token_pos>=sizetok) {
sizetok+=CADCHUNKALLOC;
my_realloc(437, &token,sizetok);
}
if(c=='"') {
if(!escape) quote=!quote;
}
@ -566,7 +573,7 @@ const char *get_sym_template(char *s,char *extra)
return "";
}
l = strlen(s);
str_alloc(&result, l+1, 0, &sizeres);
STR_ALLOC(&result, l+1, &sizeres);
sizetok = sizeval = CADCHUNKALLOC;
my_realloc(438, &value,sizeval);
my_realloc(439, &token,sizetok);
@ -578,8 +585,8 @@ const char *get_sym_template(char *s,char *extra)
else if( (state==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&value, value_pos, &sizeval);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XBEGIN) {
result[result_pos++] = c;
} else if(state==XTOKEN) {
@ -772,8 +779,8 @@ const char *subst_token(const char *s, const char *tok, const char *new_val)
space=SPACE(c);
if(c == '"' && !escape) quote=!quote;
/* alloc data */
str_alloc(&result, 0, result_pos, &size);
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&result, result_pos, &size);
STR_ALLOC(&token, token_pos, &sizetok);
/* parsing state machine */
/* states: */
@ -807,7 +814,7 @@ const char *subst_token(const char *s, const char *tok, const char *new_val)
tmp = 2;
}
str_alloc(&result, tmp+2, result_pos, &size);
STR_ALLOC(&result, tmp+2 + result_pos, &size);
memcpy(result + result_pos, "=", 1);
memcpy(result + result_pos+1, new_val, tmp);
memcpy(result + result_pos+1+tmp, " ", 1);
@ -845,7 +852,7 @@ const char *subst_token(const char *s, const char *tok, const char *new_val)
new_val = "\"\"";
tmp = 2;
}
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result + result_pos ,new_val, tmp + 1);
result_pos += tmp;
done_subst = 1;
@ -879,7 +886,7 @@ const char *subst_token(const char *s, const char *tok, const char *new_val)
if(new_val) {
if(!new_val[0]) new_val = "\"\"";
tmp = strlen(new_val) + strlen(tok) + 2;
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
my_snprintf(result + result_pos - 1, size, " %s=%s", tok, new_val ); /* result_pos guaranteed to be > 0 */
}
}
@ -1004,8 +1011,8 @@ void print_vhdl_element(FILE *fd, int inst)
else if( (state==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&value, value_pos, &sizeval);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE) {
if(c=='"' && !escape) quote=!quote;
@ -1143,8 +1150,8 @@ void print_generic(FILE *fd, char *ent_or_comp, int symbol)
else if( (state==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&value, value_pos, &sizeval);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE)
{
@ -1248,8 +1255,8 @@ void print_verilog_param(FILE *fd, int symbol)
else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&value, value_pos, &sizeval);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE)
{
@ -1340,7 +1347,7 @@ void print_spice_subckt(FILE *fd, int symbol)
state = XSEPARATOR;
}
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) {
token[token_pos++]=c;
}
@ -1443,7 +1450,7 @@ void print_spice_element(FILE *fd, int inst)
while(1)
{
/* always make room for some characters so the single char writes to result do not need reallocs */
str_alloc(&result, 100, result_pos, &size);
STR_ALLOC(&result, 100 + result_pos, &size);
c=*s++;
if(c=='\\') {
escape=1;
@ -1463,7 +1470,7 @@ void print_spice_element(FILE *fd, int inst)
dbg(1, "print_spice_element: c=%c, space=%d, escape=%d roken_pos=%d\n", c, space, escape, token_pos);
state=XSEPARATOR;
}
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) {
token[token_pos++]=c;
}
@ -1485,7 +1492,7 @@ void print_spice_element(FILE *fd, int inst)
tmp = strlen(token + 1) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
result_pos += my_snprintf(result + result_pos, tmp, "%s", token + 1);
/* fputs(token + 1, fd); */
} else if (value && value[0]!='\0') {
@ -1497,7 +1504,7 @@ void print_spice_element(FILE *fd, int inst)
tmp = strlen(lab) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
result_pos += my_snprintf(result + result_pos, tmp, "%s", lab);
/* fputs(lab,fd); */
@ -1507,7 +1514,7 @@ void print_spice_element(FILE *fd, int inst)
tmp = strlen(value) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
result_pos += my_snprintf(result + result_pos, tmp, "%s", value);
/* fputs(value,fd); */
}
@ -1518,7 +1525,7 @@ void print_spice_element(FILE *fd, int inst)
const char *s = skip_dir(xctx->inst[inst].name);
tmp = strlen(s) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
result_pos += my_snprintf(result + result_pos, tmp, "%s", s);
/* fputs(s,fd); */
}
@ -1528,7 +1535,7 @@ void print_spice_element(FILE *fd, int inst)
const char *s = get_cell_w_ext(xctx->inst[inst].name, 0);
tmp = strlen(s) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
result_pos += my_snprintf(result + result_pos, tmp, "%s", s);
/* fputs(s,fd); */
}
@ -1537,7 +1544,7 @@ void print_spice_element(FILE *fd, int inst)
{
tmp = strlen(xctx->current_name) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
result_pos += my_snprintf(result + result_pos, tmp, "%s", xctx->current_name);
/* fputs(xctx->current_name, fd); */
@ -1553,7 +1560,7 @@ void print_spice_element(FILE *fd, int inst)
tmp = strlen(str_ptr) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
result_pos += my_snprintf(result + result_pos, tmp, "?%d %s ", mult, str_ptr);
}
}
@ -1567,7 +1574,7 @@ void print_spice_element(FILE *fd, int inst)
tmp = strlen(str_ptr) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
result_pos += my_snprintf(result + result_pos, tmp, "?%d %s ", mult, str_ptr);
}
break;
@ -1586,7 +1593,7 @@ void print_spice_element(FILE *fd, int inst)
tmp = strlen(str_ptr) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
result_pos += my_snprintf(result + result_pos, tmp, "?%d %s ", mult, str_ptr);
}
}
@ -1604,7 +1611,7 @@ void print_spice_element(FILE *fd, int inst)
tmp = strlen(res) + 100; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
result_pos += my_snprintf(result + result_pos, tmp, "%s", res);
/* fprintf(fd, "%s", tclresult()); */
my_free(1018, &tclcmd);
@ -1775,7 +1782,7 @@ void print_tedax_element(FILE *fd, int inst)
state=XSEPARATOR;
}
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) {
token[token_pos++]=c; /* 20171029 remove escaping backslashes */
}
@ -1985,8 +1992,8 @@ void print_verilog_element(FILE *fd, int inst)
else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&value, value_pos, &sizeval);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE)
{
@ -2172,7 +2179,7 @@ void print_vhdl_primitive(FILE *fd, int inst) /* netlist primitives, 20071217 *
state=XSEPARATOR;
}
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) {
token[token_pos++]=c; /* 20171029 remove escaping backslashes */
}
@ -2345,7 +2352,7 @@ void print_verilog_primitive(FILE *fd, int inst) /* netlist switch level primiti
state=XSEPARATOR;
}
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) {
token[token_pos++]=c;
}
@ -2550,8 +2557,8 @@ const char *translate(int inst, const char* s)
&& token_pos > 1 ) state=XSEPARATOR;
str_alloc(&result, 0, result_pos, &size);
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&result, result_pos, &size);
STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c;
else if(state==XSEPARATOR)
{
@ -2568,7 +2575,7 @@ const char *translate(int inst, const char* s)
if(!get_tok_size && token[0] =='$') {
tmp=token_pos -1 ; /* we need token_pos -1 chars, ( strlen(token+1) ) , excluding leading '$' */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
dbg(2, "translate(): token=%s, token_pos = %d\n", token, token_pos);
memcpy(result+result_pos, token + 1, tmp+1);
result_pos+=tmp;
@ -2576,19 +2583,19 @@ const char *translate(int inst, const char* s)
token_pos = 0;
if(get_tok_size) {
tmp=get_tok_value_size; /* strlen(value); */
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos, value, tmp+1);
result_pos+=tmp;
} else if(strcmp(token,"@symname")==0) {
tmp_sym_name=xctx->inst[inst].name ? get_cell(xctx->inst[inst].name, 0) : "";
tmp=strlen(tmp_sym_name);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos,tmp_sym_name, tmp+1);
result_pos+=tmp;
} else if(strcmp(token,"@symname_ext")==0) {
tmp_sym_name=xctx->inst[inst].name ? get_cell_w_ext(xctx->inst[inst].name, 0) : "";
tmp=strlen(tmp_sym_name);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos,tmp_sym_name, tmp+1);
result_pos+=tmp;
@ -2655,7 +2662,7 @@ const char *translate(int inst, const char* s)
my_free(1177, &tmpstr);
}
tmp=strlen(value);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos, value, tmp+1);
result_pos+=tmp;
my_free(1064, &pin_attr_value);
@ -2673,7 +2680,7 @@ const char *translate(int inst, const char* s)
if(!stat(file_name , &time_buf)) {
tm=localtime(&(time_buf.st_mtime) );
tmp=strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", tm);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos, date, tmp+1);
result_pos+=tmp;
}
@ -2682,7 +2689,7 @@ const char *translate(int inst, const char* s)
if(!stat(file_name , &time_buf)) {
tm=localtime(&(time_buf.st_mtime) );
tmp=strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", tm);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos, date, tmp+1);
result_pos+=tmp;
}
@ -2691,27 +2698,27 @@ const char *translate(int inst, const char* s)
if(!stat(file_name , &time_buf)) {
tm=localtime(&(time_buf.st_mtime) );
tmp=strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", tm);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos, date, tmp+1);
result_pos+=tmp;
}
} else if(strcmp(token,"@schname")==0) {
/* tmp=strlen(xctx->sch[xctx->currsch]);*/
tmp = strlen(xctx->current_name);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
/* memcpy(result+result_pos,xctx->sch[xctx->currsch], tmp+1); */
memcpy(result+result_pos, xctx->current_name, tmp+1);
result_pos+=tmp;
} else if(strcmp(token,"@prop_ptr")==0 && xctx->inst[inst].prop_ptr) {
tmp=strlen(xctx->inst[inst].prop_ptr);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos,xctx->inst[inst].prop_ptr, tmp+1);
result_pos+=tmp;
}
else if(strcmp(token,"@schvhdlprop")==0 && xctx->schvhdlprop)
{
tmp=strlen(xctx->schvhdlprop);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos,xctx->schvhdlprop, tmp+1);
result_pos+=tmp;
}
@ -2719,7 +2726,7 @@ const char *translate(int inst, const char* s)
else if(strcmp(token,"@schprop")==0 && xctx->schprop)
{
tmp=strlen(xctx->schprop);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos,xctx->schprop, tmp+1);
result_pos+=tmp;
}
@ -2728,14 +2735,14 @@ const char *translate(int inst, const char* s)
else if(strcmp(token,"@schsymbolprop")==0 && xctx->schsymbolprop)
{
tmp=strlen(xctx->schsymbolprop);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos,xctx->schsymbolprop, tmp+1);
result_pos+=tmp;
}
else if(strcmp(token,"@schtedaxprop")==0 && xctx->schtedaxprop)
{
tmp=strlen(xctx->schtedaxprop);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos,xctx->schtedaxprop, tmp+1);
result_pos+=tmp;
}
@ -2744,7 +2751,7 @@ const char *translate(int inst, const char* s)
else if(strcmp(token,"@schverilogprop")==0 && xctx->schverilogprop)
{
tmp=strlen(xctx->schverilogprop);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos,xctx->schverilogprop, tmp+1);
result_pos+=tmp;
}
@ -2806,8 +2813,8 @@ const char *translate2(struct Lcc *lcc, int level, char* s)
else if (state == XTOKEN && ( (space && !escape) || c == '@' || (!space && escape)) && token_pos > 1) {
state = XSEPARATOR;
}
str_alloc(&result, 0, result_pos, &size);
str_alloc(&token, 0, token_pos, &sizetok);
STR_ALLOC(&result, result_pos, &size);
STR_ALLOC(&token, token_pos, &sizetok);
if (state == XTOKEN) token[token_pos++] = c;
else if (state == XSEPARATOR) {
token[token_pos] = '\0';
@ -2840,7 +2847,7 @@ const char *translate2(struct Lcc *lcc, int level, char* s)
i--;
}
tmp = get_tok_value_size; /* strlen(value); */
str_alloc(&result, tmp + 1, result_pos, &size); /* +1 to add leading '$' */
STR_ALLOC(&result, tmp + 1 + result_pos, &size); /* +1 to add leading '$' */
/* prefix substituted token with a '$' so it will be recognized by translate() for last level translation with
instance placement prop_ptr attributes at drawing/netlisting time. */
memcpy(result + result_pos , "$", 1);
@ -2850,14 +2857,14 @@ const char *translate2(struct Lcc *lcc, int level, char* s)
else if (strcmp(token, "@symname") == 0) {
tmp_sym_name = lcc[level].symname ? get_cell(lcc[level].symname, 0) : "";
tmp = strlen(tmp_sym_name);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result + result_pos, tmp_sym_name, tmp + 1);
result_pos += tmp;
}
else if (strcmp(token, "@symname_ext") == 0) {
tmp_sym_name = lcc[level].symname ? get_cell_w_ext(lcc[level].symname, 0) : "";
tmp = strlen(tmp_sym_name);
str_alloc(&result, tmp, result_pos, &size);
STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result + result_pos, tmp_sym_name, tmp + 1);
result_pos += tmp;
}

14
src/xschem.h
View File

@ -298,6 +298,17 @@ extern char win_temp_dir[PATH_MAX];
#define X_TO_XSCHEM(x) ((x)*xctx->zoom -xctx->xorigin)
#define Y_TO_XSCHEM(y) ((y)*xctx->zoom -xctx->yorigin)
/* given a dest_string of size 'size', allocate space to make sure it can
* hold additional 'add' characters starting at position 'pos' */
#define STR_ALLOC(dest_string, add, size) \
do { \
register int __str_alloc_tmp__ = add; \
if( __str_alloc_tmp__ >= *size) { \
*size = __str_alloc_tmp__ + CADCHUNKALLOC; \
my_realloc(1212, dest_string, *size); \
} \
} while(0) \
typedef struct
{
unsigned short type;
@ -753,7 +764,7 @@ extern void hash_inst(int what, int n);
extern void hash_inst_pin(int what, int i, int j);
extern void del_inst_table(void);
extern void hash_wires(void);
extern void hash_wire(int what, int n);
extern void hash_wire(int what, int n, int incremental);
extern void hash_instances(void); /* 20171203 insert instance bbox in spatial hash table */
#ifdef HAS_CAIRO
@ -941,7 +952,6 @@ extern char* strtolower(char* s);
extern char* strtoupper(char* s);
extern void *my_malloc(int id, size_t size);
extern void my_realloc(int id, void *ptr,size_t size);
extern void str_alloc( char **dest_string, int add, int pos, int *size);
extern void *my_calloc(int id, size_t nmemb, size_t size);
extern void my_free(int id, void *ptr);
extern size_t my_strcat(int id, char **, const char *);