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

10
src/editprop.c
View File

@ -376,16 +376,6 @@ char *strtoupper(char* s) {
return 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) void set_inst_prop(int i)
{ {
char *ptr = NULL; char *ptr = NULL;

261
src/move.c
View File

@ -506,6 +506,10 @@ void copy_objects(int what)
/* int customfont; */ /* int customfont; */
#endif #endif
int const instances = xctx->instances;
xInstance * const inst = xctx->inst;
xLine ** const line = xctx->line;
xWire * const wire = xctx->wire;
if(what & BEGIN) if(what & BEGIN)
{ {
rotatelocal=0; rotatelocal=0;
@ -573,33 +577,33 @@ void copy_objects(int what)
} }
check_wire_storage(); check_wire_storage();
/* /*
if(xctx->wire[n].bus){ if(wire[n].bus){
int ov, y1, y2; int ov, y1, y2;
ov = bus_width> cadhalfdotsize ? bus_width : CADHALFDOTSIZE; 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; } if(wire[n].y1 < wire[n].y2) { y1 = wire[n].y1-ov; y2 = wire[n].y2+ov; }
else { y1 = xctx->wire[n].y1+ov; y2 = xctx->wire[n].y2-ov; } else { y1 = wire[n].y1+ov; y2 = wire[n].y2-ov; }
bbox(ADD, xctx->wire[n].x1-ov, y1 , xctx->wire[n].x2+ov , y2 ); bbox(ADD, wire[n].x1-ov, y1 , wire[n].x2+ov , y2 );
} else { } else {
int ov, y1, y2; int ov, y1, y2;
ov = cadhalfdotsize; ov = cadhalfdotsize;
if(xctx->wire[n].y1 < xctx->wire[n].y2) { y1 = xctx->wire[n].y1-ov; y2 = xctx->wire[n].y2+ov; } if(wire[n].y1 < wire[n].y2) { y1 = wire[n].y1-ov; y2 = wire[n].y2+ov; }
else { y1 = xctx->wire[n].y1+ov; y2 = xctx->wire[n].y2-ov; } else { y1 = wire[n].y1+ov; y2 = wire[n].y2-ov; }
bbox(ADD, xctx->wire[n].x1-ov, y1 , xctx->wire[n].x2+ov , y2 ); bbox(ADD, wire[n].x1-ov, y1 , wire[n].x2+ov , y2 );
} }
*/ */
if(rotatelocal) { if(rotatelocal) {
ROTATION(xctx->wire[n].x1, xctx->wire[n].y1, xctx->wire[n].x1, xctx->wire[n].y1, rx1,ry1); ROTATION(wire[n].x1, wire[n].y1, wire[n].x1, 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].x2, wire[n].y2, rx2,ry2);
} else { } else {
ROTATION(x1, y_1, xctx->wire[n].x1, xctx->wire[n].y1, rx1,ry1); ROTATION(x1, y_1, wire[n].x1, 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].x2, wire[n].y2, rx2,ry2);
} }
if( xctx->wire[n].sel & (SELECTED|SELECTED1) ) if( wire[n].sel & (SELECTED|SELECTED1) )
{ {
rx1+=deltax; rx1+=deltax;
ry1+=deltay; ry1+=deltay;
} }
if( xctx->wire[n].sel & (SELECTED|SELECTED2) ) if( wire[n].sel & (SELECTED|SELECTED2) )
{ {
rx2+=deltax; rx2+=deltax;
ry2+=deltay; ry2+=deltay;
@ -609,13 +613,13 @@ void copy_objects(int what)
ORDER(rx1,ry1,rx2,ry2); ORDER(rx1,ry1,rx2,ry2);
if( tmpx == rx2 && tmpy == ry2) if( tmpx == rx2 && tmpy == ry2)
{ {
if(xctx->wire[n].sel == SELECTED1) xctx->wire[n].sel = SELECTED2; if(wire[n].sel == SELECTED1) wire[n].sel = SELECTED2;
else if(xctx->wire[n].sel == SELECTED2) xctx->wire[n].sel = SELECTED1; else if(wire[n].sel == SELECTED2) wire[n].sel = SELECTED1;
} }
selectedgroup[i].n=xctx->wires; selectedgroup[i].n=xctx->wires;
storeobject(-1, rx1,ry1,rx2,ry2,WIRE,0,xctx->wire[n].sel,xctx->wire[n].prop_ptr); storeobject(-1, rx1,ry1,rx2,ry2,WIRE,0,wire[n].sel,wire[n].prop_ptr);
xctx->wire[n].sel=0; wire[n].sel=0;
if(xctx->wire[n].bus) if(wire[n].bus)
drawline(WIRELAYER, THICK, rx1,ry1,rx2,ry2, 0); drawline(WIRELAYER, THICK, rx1,ry1,rx2,ry2, 0);
else else
drawline(WIRELAYER, ADD, rx1,ry1,rx2,ry2, 0); drawline(WIRELAYER, ADD, rx1,ry1,rx2,ry2, 0);
@ -633,20 +637,20 @@ void copy_objects(int what)
{ {
case LINE: case LINE:
if(c!=k) break; 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) { 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(line[c][n].x1, line[c][n].y1, line[c][n].x1, 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].x2, line[c][n].y2, rx2,ry2);
} else { } else {
ROTATION(x1, y_1, xctx->line[c][n].x1, xctx->line[c][n].y1, rx1,ry1); ROTATION(x1, y_1, line[c][n].x1, 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].x2, line[c][n].y2, rx2,ry2);
} }
if( xctx->line[c][n].sel & (SELECTED|SELECTED1) ) if( line[c][n].sel & (SELECTED|SELECTED1) )
{ {
rx1+=deltax; rx1+=deltax;
ry1+=deltay; ry1+=deltay;
} }
if( xctx->line[c][n].sel & (SELECTED|SELECTED2) ) if( line[c][n].sel & (SELECTED|SELECTED2) )
{ {
rx2+=deltax; rx2+=deltax;
ry2+=deltay; ry2+=deltay;
@ -656,16 +660,16 @@ void copy_objects(int what)
ORDER(rx1,ry1,rx2,ry2); ORDER(rx1,ry1,rx2,ry2);
if( tmpx == rx2 && tmpy == ry2) if( tmpx == rx2 && tmpy == ry2)
{ {
if(xctx->line[c][n].sel == SELECTED1) xctx->line[c][n].sel = SELECTED2; if(line[c][n].sel == SELECTED1) line[c][n].sel = SELECTED2;
else if(xctx->line[c][n].sel == SELECTED2) xctx->line[c][n].sel = SELECTED1; else if(line[c][n].sel == SELECTED2) line[c][n].sel = SELECTED1;
} }
if(xctx->line[c][n].bus) if(line[c][n].bus)
drawline(k, THICK, rx1,ry1,rx2,ry2, xctx->line[c][n].dash); drawline(k, THICK, rx1,ry1,rx2,ry2, line[c][n].dash);
else 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]; 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); storeobject(-1, rx1, ry1, rx2, ry2, LINE, c, line[c][n].sel, line[c][n].prop_ptr);
xctx->line[c][n].sel=0; line[c][n].sel=0;
break; break;
case POLYGON: case POLYGON:
@ -862,34 +866,34 @@ void copy_objects(int what)
check_inst_storage(); check_inst_storage();
if(rotatelocal) { 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 { } 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]; inst[instances] = inst[n];
xctx->inst[xctx->instances].prop_ptr=NULL; inst[instances].prop_ptr=NULL;
xctx->inst[xctx->instances].instname=NULL; inst[instances].instname=NULL;
xctx->inst[xctx->instances].node=NULL; inst[instances].node=NULL;
xctx->inst[xctx->instances].name=NULL; inst[instances].name=NULL;
my_strdup(232, &xctx->inst[xctx->instances].name, xctx->inst[n].name); my_strdup(232, &inst[instances].name, inst[n].name);
my_strdup(233, &xctx->inst[xctx->instances].prop_ptr, xctx->inst[n].prop_ptr); my_strdup(233, &inst[instances].prop_ptr, inst[n].prop_ptr);
my_strdup2(234, &xctx->inst[xctx->instances].instname, get_tok_value(xctx->inst[n].prop_ptr, "name",0)); my_strdup2(234, &inst[instances].instname, get_tok_value(inst[n].prop_ptr, "name",0));
xctx->inst[n].sel=0; inst[n].sel=0;
xctx->inst[xctx->instances].flags = xctx->inst[n].flags; inst[instances].flags = inst[n].flags;
xctx->inst[xctx->instances].flags &= ~4; /* do not propagate hilight */ inst[instances].flags &= ~4; /* do not propagate hilight */
xctx->inst[xctx->instances].x0 = rx1+deltax; inst[instances].x0 = rx1+deltax;
xctx->inst[xctx->instances].y0 = ry1+deltay; inst[instances].y0 = ry1+deltay;
xctx->inst[xctx->instances].sel = SELECTED; inst[instances].sel = SELECTED;
xctx->inst[xctx->instances].rot = (xctx->inst[xctx->instances].rot + inst[instances].rot = (inst[instances].rot +
( (flip && (xctx->inst[xctx->instances].rot & 1) ) ? rot+2 : rot) ) & 0x3; ( (flip && (inst[instances].rot & 1) ) ? rot+2 : rot) ) & 0x3;
xctx->inst[xctx->instances].flip = (flip? !xctx->inst[n].flip:xctx->inst[n].flip); inst[instances].flip = (flip? !inst[n].flip:inst[n].flip);
/* the newpropcnt argument is zero for the 1st call and used in */ /* the newpropcnt argument is zero for the 1st call and used in */
/* new_prop_string() for cleaning some internal caches. */ /* new_prop_string() for cleaning some internal caches. */
if(!newpropcnt) hash_all_names(xctx->instances); if(!newpropcnt) hash_all_names(instances);
new_prop_string(xctx->instances, xctx->inst[n].prop_ptr,newpropcnt++, dis_uniq_names); new_prop_string(instances, inst[n].prop_ptr,newpropcnt++, dis_uniq_names);
my_strdup2(235, &xctx->inst[xctx->instances].instname, my_strdup2(235, &inst[instances].instname,
get_tok_value(xctx->inst[xctx->instances].prop_ptr, "name", 0)); get_tok_value(inst[instances].prop_ptr, "name", 0));
n=selectedgroup[i].n=xctx->instances; n=selectedgroup[i].n=instances;
xctx->instances++; xctx->instances++;
} }
@ -918,16 +922,16 @@ void copy_objects(int what)
if(k == 0) { if(k == 0) {
if(selectedgroup[i].type == ELEMENT) { if(selectedgroup[i].type == ELEMENT) {
int p; int p;
symbol_bbox(n, &xctx->inst[n].x1, &xctx->inst[n].y1, &xctx->inst[n].x2, &xctx->inst[n].y2 ); symbol_bbox(n, &inst[n].x1, &inst[n].y1, &inst[n].x2, &inst[n].y2 );
bbox(ADD, xctx->inst[n].x1, xctx->inst[n].y1, xctx->inst[n].x2, xctx->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 < (xctx->inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) { if(show_pin_net_names) for(p = 0; p < (inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) {
if( xctx->inst[n].node && xctx->inst[n].node[p]) { if( inst[n].node && inst[n].node[p]) {
find_inst_to_be_redrawn(xctx->inst[n].node[p]); find_inst_to_be_redrawn(inst[n].node[p]);
} }
} }
} }
if(show_pin_net_names && selectedgroup[i].type == WIRE) { 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 #ifdef HAS_CAIRO
char *textfont; char *textfont;
#endif #endif
xInstance * const inst = xctx->inst;
xLine ** const line = xctx->line;
xWire * const wire = xctx->wire;
if(what & BEGIN) if(what & BEGIN)
{ {
@ -1042,16 +1049,16 @@ void move_objects(int what, int merge, double dx, double dy)
n = selectedgroup[i].n; n = selectedgroup[i].n;
if( selectedgroup[i].type == ELEMENT) { if( selectedgroup[i].type == ELEMENT) {
int p; int p;
symbol_bbox(n, &xctx->inst[n].x1, &xctx->inst[n].y1, &xctx->inst[n].x2, &xctx->inst[n].y2 ); symbol_bbox(n, &inst[n].x1, &inst[n].y1, &inst[n].x2, &inst[n].y2 );
bbox(ADD, xctx->inst[n].x1, xctx->inst[n].y1, xctx->inst[n].x2, xctx->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 < (xctx->inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) { if(show_pin_net_names) for(p = 0; p < (inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) {
if( xctx->inst[n].node && xctx->inst[n].node[p]) { if( inst[n].node && inst[n].node[p]) {
find_inst_to_be_redrawn(xctx->inst[n].node[p]); find_inst_to_be_redrawn(inst[n].node[p]);
} }
} }
} }
if(show_pin_net_names && selectedgroup[i].type == WIRE) { 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(); 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; firstw = 0;
} }
if(k == 0) { if(k == 0) {
if(xctx->wire[n].bus){ if(wire[n].bus){
int ov, y1, y2; int ov, y1, y2;
ov = bus_width> cadhalfdotsize ? bus_width : CADHALFDOTSIZE; 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; } if(wire[n].y1 < wire[n].y2) { y1 = wire[n].y1-ov; y2 = wire[n].y2+ov; }
else { y1 = xctx->wire[n].y1+ov; y2 = xctx->wire[n].y2-ov; } else { y1 = wire[n].y1+ov; y2 = wire[n].y2-ov; }
bbox(ADD, xctx->wire[n].x1-ov, y1 , xctx->wire[n].x2+ov , y2 ); bbox(ADD, wire[n].x1-ov, y1 , wire[n].x2+ov , y2 );
} else { } else {
int ov, y1, y2; int ov, y1, y2;
ov = cadhalfdotsize; ov = cadhalfdotsize;
if(xctx->wire[n].y1 < xctx->wire[n].y2) { y1 = xctx->wire[n].y1-ov; y2 = xctx->wire[n].y2+ov; } if(wire[n].y1 < wire[n].y2) { y1 = wire[n].y1-ov; y2 = wire[n].y2+ov; }
else { y1 = xctx->wire[n].y1+ov; y2 = xctx->wire[n].y2-ov; } else { y1 = wire[n].y1+ov; y2 = wire[n].y2-ov; }
bbox(ADD, xctx->wire[n].x1-ov, y1 , xctx->wire[n].x2+ov , y2 ); bbox(ADD, wire[n].x1-ov, y1 , wire[n].x2+ov , y2 );
} }
if(rotatelocal) { if(rotatelocal) {
ROTATION(xctx->wire[n].x1, xctx->wire[n].y1, xctx->wire[n].x1, xctx->wire[n].y1, rx1,ry1); ROTATION(wire[n].x1, wire[n].y1, wire[n].x1, 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].x2, wire[n].y2, rx2,ry2);
} else { } else {
ROTATION(x1, y_1, xctx->wire[n].x1, xctx->wire[n].y1, rx1,ry1); ROTATION(x1, y_1, wire[n].x1, 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].x2, wire[n].y2, rx2,ry2);
} }
if( xctx->wire[n].sel & (SELECTED|SELECTED1) ) if( wire[n].sel & (SELECTED|SELECTED1) )
{ {
rx1+=deltax; rx1+=deltax;
ry1+=deltay; ry1+=deltay;
} }
if( xctx->wire[n].sel & (SELECTED|SELECTED2) ) if( wire[n].sel & (SELECTED|SELECTED2) )
{ {
rx2+=deltax; rx2+=deltax;
ry2+=deltay; ry2+=deltay;
} }
xctx->wire[n].x1=rx1; wire[n].x1=rx1;
xctx->wire[n].y1=ry1; wire[n].y1=ry1;
ORDER(rx1,ry1,rx2,ry2); 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; if(wire[n].sel == SELECTED1) wire[n].sel = SELECTED2;
else if(xctx->wire[n].sel == SELECTED2) xctx->wire[n].sel = SELECTED1; else if(wire[n].sel == SELECTED2) wire[n].sel = SELECTED1;
} }
xctx->wire[n].x1=rx1; wire[n].x1=rx1;
xctx->wire[n].y1=ry1; wire[n].y1=ry1;
xctx->wire[n].x2=rx2; wire[n].x2=rx2;
xctx->wire[n].y2=ry2; wire[n].y2=ry2;
} else if(k == WIRELAYER) { } else if(k == WIRELAYER) {
if(xctx->wire[n].bus) if(wire[n].bus)
drawline(WIRELAYER, THICK, xctx->wire[n].x1, xctx->wire[n].y1, xctx->wire[n].x2, xctx->wire[n].y2, 0); drawline(WIRELAYER, THICK, wire[n].x1, wire[n].y1, wire[n].x2, wire[n].y2, 0);
else 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; break;
case LINE: case LINE:
if(c!=k) break; 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) { 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(line[c][n].x1, line[c][n].y1, line[c][n].x1, 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].x2, line[c][n].y2, rx2,ry2);
} else { } else {
ROTATION(x1, y_1, xctx->line[c][n].x1, xctx->line[c][n].y1, rx1,ry1); ROTATION(x1, y_1, line[c][n].x1, 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].x2, line[c][n].y2, rx2,ry2);
} }
if( xctx->line[c][n].sel & (SELECTED|SELECTED1) ) if( line[c][n].sel & (SELECTED|SELECTED1) )
{ {
rx1+=deltax; rx1+=deltax;
ry1+=deltay; ry1+=deltay;
} }
if( xctx->line[c][n].sel & (SELECTED|SELECTED2) ) if( line[c][n].sel & (SELECTED|SELECTED2) )
{ {
rx2+=deltax; rx2+=deltax;
ry2+=deltay; ry2+=deltay;
} }
xctx->line[c][n].x1=rx1; line[c][n].x1=rx1;
xctx->line[c][n].y1=ry1; line[c][n].y1=ry1;
ORDER(rx1,ry1,rx2,ry2); 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; if(line[c][n].sel == SELECTED1) line[c][n].sel = SELECTED2;
else if(xctx->line[c][n].sel == SELECTED2) xctx->line[c][n].sel = SELECTED1; else if(line[c][n].sel == SELECTED2) line[c][n].sel = SELECTED1;
} }
xctx->line[c][n].x1=rx1; line[c][n].x1=rx1;
xctx->line[c][n].y1=ry1; line[c][n].y1=ry1;
xctx->line[c][n].x2=rx2; line[c][n].x2=rx2;
xctx->line[c][n].y2=ry2; line[c][n].y2=ry2;
if(xctx->line[c][n].bus) if(line[c][n].bus)
drawline(k, THICK, xctx->line[c][n].x1, xctx->line[c][n].y1, drawline(k, THICK, line[c][n].x1, line[c][n].y1,
xctx->line[c][n].x2, xctx->line[c][n].y2, xctx->line[c][n].dash); line[c][n].x2, line[c][n].y2, line[c][n].dash);
else else
drawline(k, ADD, xctx->line[c][n].x1, xctx->line[c][n].y1, drawline(k, ADD, line[c][n].x1, line[c][n].y1,
xctx->line[c][n].x2, xctx->line[c][n].y2, xctx->line[c][n].dash); line[c][n].x2, line[c][n].y2, line[c][n].dash);
break; break;
case POLYGON: case POLYGON:
@ -1389,15 +1396,15 @@ void move_objects(int what, int merge, double dx, double dy)
firsti = 0; firsti = 0;
} }
if(rotatelocal) { 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 { } 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; inst[n].x0 = rx1+deltax;
xctx->inst[n].y0 = ry1+deltay; inst[n].y0 = ry1+deltay;
xctx->inst[n].rot = (xctx->inst[n].rot + inst[n].rot = (inst[n].rot +
( (flip && (xctx->inst[n].rot & 1) ) ? rot+2 : rot) ) & 0x3; ( (flip && (inst[n].rot & 1) ) ? rot+2 : rot) ) & 0x3;
xctx->inst[n].flip = flip ^ xctx->inst[n].flip; inst[n].flip = flip ^ inst[n].flip;
} }
break; break;
@ -1420,16 +1427,16 @@ void move_objects(int what, int merge, double dx, double dy)
if(k == 0) { if(k == 0) {
if(selectedgroup[i].type == ELEMENT) { if(selectedgroup[i].type == ELEMENT) {
int p; int p;
symbol_bbox(n, &xctx->inst[n].x1, &xctx->inst[n].y1, &xctx->inst[n].x2, &xctx->inst[n].y2 ); symbol_bbox(n, &inst[n].x1, &inst[n].y1, &inst[n].x2, &inst[n].y2 );
bbox(ADD, xctx->inst[n].x1, xctx->inst[n].y1, xctx->inst[n].x2, xctx->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 < (xctx->inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) { if(show_pin_net_names) for(p = 0; p < (inst[n].ptr + xctx->sym)->rects[PINLAYER]; p++) {
if( xctx->inst[n].node && xctx->inst[n].node[p]) { if( inst[n].node && inst[n].node[p]) {
find_inst_to_be_redrawn(xctx->inst[n].node[p]); find_inst_to_be_redrawn(inst[n].node[p]);
} }
} }
} }
if(show_pin_net_names && selectedgroup[i].type == WIRE) { 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); */ /* 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 * 0, XINSERT : add to hash
* 1, XDELETE : remove from 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; int tmpi,tmpj, counti,countj,i,j;
double tmpd; double tmpd;
double x1, y1, x2, y2; double x1, y1, x2, y2;
int x1a, x2a, y1a, y2a; int x1a, x2a, y1a, y2a;
struct wireentry *wptr; struct wireentry *wptr;
xWire * const wire = xctx->wire;
/* wire[n].node=NULL; */
my_free(827, &wire[n].node);
/* xctx->wire[n].node=NULL; */ wire[n].end1 = wire[n].end2=-1;
my_free(827, &xctx->wire[n].node); x1=wire[n].x1;
x2=wire[n].x2;
xctx->wire[n].end1 = xctx->wire[n].end2=-1; y1=wire[n].y1;
x1=xctx->wire[n].x1; y2=wire[n].y2;
x2=xctx->wire[n].x2;
y1=xctx->wire[n].y1;
y2=xctx->wire[n].y2;
/* ordered bbox */ /* ordered bbox */
if( x2 < x1) { tmpd=x2;x2=x1;x1=tmpd;} if( x2 < x1) { tmpd=x2;x2=x1;x1=tmpd;}
if( y2 < y1) { tmpd=y2;y2=y1;y1=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) ; x1a=floor(x1/BOXSIZE) ;
y1a=floor(y1/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); x2a=floor(x2/BOXSIZE);
y2a=floor(y2/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; counti=0;
for(i=x1a; i<=x2a && counti < NBOXES; i++) for(i=x1a; i<=x2a && counti < NBOXES; i++)
{ {
@ -349,13 +349,13 @@ void hash_wire(int what, int n)
{ {
countj++; countj++;
tmpj=j%NBOXES; if(tmpj<0) tmpj+=NBOXES; 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); if(what==XINSERT) wireinsert(n, tmpi, tmpj);
else wiredelete(n, tmpi, tmpj); else wiredelete(n, tmpi, tmpj);
/* reset ends of all wires that *could* touch xctx->wire[n] */ /* reset ends of all wires that *could* touch wire[n] */
for(wptr = wiretable[tmpi][tmpj] ; wptr ; wptr = wptr->next) { if(incremental) for(wptr = wiretable[tmpi][tmpj] ; wptr ; wptr = wptr->next) {
xctx->wire[wptr->n].end1 = xctx->wire[wptr->n].end2 = -1; wire[wptr->n].end1 = wire[wptr->n].end2 = -1;
} }
} }
} }
@ -367,7 +367,8 @@ void hash_wires(void)
if(prepared_hash_wires) return; if(prepared_hash_wires) return;
del_wire_table(); 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; prepared_hash_wires=1;
} }
@ -469,23 +470,24 @@ static void wirecheck(int k) /* recursive routine */
double x1, y1, x2, y2; double x1, y1, x2, y2;
int x1a, x2a, y1a, y2a; int x1a, x2a, y1a, y2a;
struct wireentry *ptr2; struct wireentry *ptr2;
xWire * const wire = xctx->wire;
x1=xctx->wire[k].x1; x1=wire[k].x1;
x2=xctx->wire[k].x2; x2=wire[k].x2;
y1=xctx->wire[k].y1; y1=wire[k].y1;
y2=xctx->wire[k].y2; y2=wire[k].y2;
/* ordered bbox */ /* ordered bbox */
RECTORDER(x1, y1, x2, y2); 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) ; x1a=floor(x1/BOXSIZE) ;
y1a=floor(y1/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); x2a=floor(x2/BOXSIZE);
y2a=floor(y2/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; counti=0;
for(i=x1a; i<=x2a && counti < NBOXES; i++) for(i=x1a; i<=x2a && counti < NBOXES; i++)
{ {
@ -496,25 +498,25 @@ static void wirecheck(int k) /* recursive routine */
{ {
countj++; countj++;
tmpj=j%NBOXES; if(tmpj<0) tmpj+=NBOXES; 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]; ptr2=wiretable[tmpi][tmpj];
while(ptr2) 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 */ 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, touches = touch(wire[k].x1,wire[k].y1,wire[k].x2,wire[k].y2,
xctx->wire[ptr2->n].x1,xctx->wire[ptr2->n].y1) || wire[ptr2->n].x1,wire[ptr2->n].y1) ||
touch(xctx->wire[k].x1,xctx->wire[k].y1,xctx->wire[k].x2,xctx->wire[k].y2, touch(wire[k].x1,wire[k].y1,wire[k].x2,wire[k].y2,
xctx->wire[ptr2->n].x2,xctx->wire[ptr2->n].y2) || wire[ptr2->n].x2,wire[ptr2->n].y2) ||
touch(xctx->wire[ptr2->n].x1,xctx->wire[ptr2->n].y1,xctx->wire[ptr2->n].x2, touch(wire[ptr2->n].x1,wire[ptr2->n].y1,wire[ptr2->n].x2,
xctx->wire[ptr2->n].y2, xctx->wire[k].x1,xctx->wire[k].y1) || wire[ptr2->n].y2, wire[k].x1,wire[k].y1) ||
touch(xctx->wire[ptr2->n].x1,xctx->wire[ptr2->n].y1,xctx->wire[ptr2->n].x2, touch(wire[ptr2->n].x1,wire[ptr2->n].y1,wire[ptr2->n].x2,
xctx->wire[ptr2->n].y2, xctx->wire[k].x2,xctx->wire[k].y2); wire[ptr2->n].y2, wire[k].x2,wire[k].y2);
if( touches ) if( touches )
{ {
my_strdup(239, &xctx->wire[ptr2->n].node, xctx->wire[k].node); my_strdup(239, &wire[ptr2->n].node, wire[k].node);
my_strdup(240, &xctx->wire[ptr2->n].prop_ptr, my_strdup(240, &wire[ptr2->n].prop_ptr,
subst_token(xctx->wire[ptr2->n].prop_ptr, "lab", xctx->wire[ptr2->n].node)); subst_token(wire[ptr2->n].prop_ptr, "lab", wire[ptr2->n].node));
wirecheck(ptr2->n); /* recursive check */ wirecheck(ptr2->n); /* recursive check */
} }
} }
@ -635,6 +637,8 @@ void prepare_netlist_structs(int for_netlist)
int inst_mult, pin_mult; int inst_mult, pin_mult;
int print_erc; int print_erc;
static int startlevel = 0; static int startlevel = 0;
xInstance * const inst = xctx->inst;
int const instances = xctx->instances;
if (for_netlist>0 && prepared_netlist_structs) return; if (for_netlist>0 && prepared_netlist_structs) return;
else if (!for_netlist && prepared_hilight_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 */ /* reset wire & inst node labels */
dbg(1, "prepare_netlist_structs(): resetting node hash tables\n"); dbg(1, "prepare_netlist_structs(): resetting node hash tables\n");
hash_wires(); 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); delete_inst_node(i);
rects=(xctx->inst[i].ptr+ xctx->sym)->rects[PINLAYER] + rects=(inst[i].ptr+ xctx->sym)->rects[PINLAYER] +
(xctx->inst[i].ptr+ xctx->sym)->rects[GENERICLAYER]; (inst[i].ptr+ xctx->sym)->rects[GENERICLAYER];
if (rects > 0) 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++) for (j=0;j<rects;j++)
{ {
xctx->inst[i].node[j]=NULL; inst[i].node[j]=NULL;
hash_inst_pin(XINSERT, i, j); hash_inst_pin(XINSERT, i, j);
} }
} }
} }
dbg(2, "prepare_netlist_structs(): naming pins from attrs\n"); 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 */ /* 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); my_strdup(248, &type,(inst[i].ptr+ xctx->sym)->type);
if(print_erc && (!xctx->inst[i].instname || !xctx->inst[i].instname[0]) && if(print_erc && (!inst[i].instname || !inst[i].instname[0]) &&
!get_tok_value((xctx->inst[i].ptr+ xctx->sym)->templ, "name", 0)[0] !get_tok_value((inst[i].ptr+ xctx->sym)->templ, "name", 0)[0]
) { ) {
char str[2048]; char str[2048];
if( type && if( type &&
@ -684,30 +688,30 @@ void prepare_netlist_structs(int for_netlist)
strcmp(type, "arch_declarations") && strcmp(type, "arch_declarations") &&
strcmp(type, "attributes") && strcmp(type, "attributes") &&
strcmp(type, "use")) { 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); statusmsg(str,2);
xctx->inst[i].flags |=4; inst[i].flags |=4;
hilight_nets=1; hilight_nets=1;
} }
} }
if(print_erc && (!type || !type[0]) ) { if(print_erc && (!type || !type[0]) ) {
char str[2048]; 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); statusmsg(str,2);
xctx->inst[i].flags |=4; inst[i].flags |=4;
hilight_nets=1; 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) { if (for_netlist>0) {
/* 20150918 skip labels / pins if ignore property specified on instance */ /* 20150918 skip labels / pins if ignore property specified on instance */
if( netlist_type == CAD_VERILOG_NETLIST && 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 && 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 && 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 && 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; port=0;
if (strcmp(type,"label")) { /* instance is a port (not a label) */ 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 */ /* 20071204 only define a dir property if instance is not a label */
if (!for_netlist) my_strdup(249, &dir, ""); if (!for_netlist) my_strdup(249, &dir, "");
else 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 { else {
/* handle global nodes (global=1 set as symbol property) 28032003 */ /* 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 */ /*20071204 if instance is a label dont define a dir property for more precise erc checking */
my_strdup(252, &dir,"none"); my_strdup(252, &dir,"none");
} }
@ -734,54 +738,54 @@ void prepare_netlist_structs(int for_netlist)
my_free(833, &value); my_free(833, &value);
my_free(834, &class); my_free(834, &class);
} else { } else {
my_strdup(258, &sig_type,get_tok_value(xctx->inst[i].prop_ptr,"sig_type",0)); my_strdup(258, &sig_type,get_tok_value(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(259, &verilog_type,get_tok_value(inst[i].prop_ptr,"verilog_type",0));
my_strdup(260, &value,get_tok_value(xctx->inst[i].prop_ptr,"value",2)); my_strdup(260, &value,get_tok_value(inst[i].prop_ptr,"value",2));
my_strdup(261, &class,get_tok_value(xctx->inst[i].prop_ptr,"class",0)); 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])) { if (!(inst[i].node[0])) {
my_strdup(65, &xctx->inst[i].node[0], get_tok_value((xctx->inst[i].ptr+ xctx->sym)->templ, "lab",1)); 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", xctx->inst[i].node[0]); 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 */ /* handle global nodes (global=1 set as symbol property) 28032003 */
if (!strcmp(type,"label") && global_node && !strcmp(global_node, "true")) { if (!strcmp(type,"label") && global_node && !strcmp(global_node, "true")) {
dbg(1, "prepare_netlist_structs(): global node: %s\n",xctx->inst[i].node[0]); dbg(1, "prepare_netlist_structs(): global node: %s\n",inst[i].node[0]);
record_global_node(1,NULL, xctx->inst[i].node[0]); record_global_node(1,NULL, inst[i].node[0]);
} }
/* do not count multiple labels/pins with same name */ /* 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); dir, XINSERT, port, sig_type, verilog_type, value, class);
dbg(2, "prepare_netlist_structs(): name=%s\n", 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", 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", 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 */ /* 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; x0=(rct[0].x1+rct[0].x2)/2;
y0=(rct[0].y1+rct[0].y2)/2; y0=(rct[0].y1+rct[0].y2)/2;
rot=xctx->inst[i].rot; rot=inst[i].rot;
flip=xctx->inst[i].flip; flip=inst[i].flip;
ROTATION(0.0,0.0,x0,y0,rx1,ry1); ROTATION(0.0,0.0,x0,y0,rx1,ry1);
x0=xctx->inst[i].x0+rx1; x0=inst[i].x0+rx1;
y0=xctx->inst[i].y0+ry1; y0=inst[i].y0+ry1;
get_square(x0, y0, &sqx, &sqy); get_square(x0, y0, &sqx, &sqy);
wptr=wiretable[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, if (touch(xctx->wire[wptr->n].x1, xctx->wire[wptr->n].y1,
xctx->wire[wptr->n].x2, xctx->wire[wptr->n].y2, x0,y0)) xctx->wire[wptr->n].x2, xctx->wire[wptr->n].y2, x0,y0))
{ {
/* short circuit check */ /* short circuit check */
if (for_netlist>0) signal_short(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, xctx->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, my_strdup(264, &xctx->wire[wptr->n].prop_ptr,
subst_token(xctx->wire[wptr->n].prop_ptr, "lab", xctx->wire[wptr->n].node)); subst_token(xctx->wire[wptr->n].prop_ptr, "lab", xctx->wire[wptr->n].node));
wirecheck(wptr->n); wirecheck(wptr->n);
@ -789,7 +793,7 @@ void prepare_netlist_structs(int for_netlist)
wptr=wptr->next; wptr=wptr->next;
} }
} /* if(type && ... */ } /* if(type && ... */
} /* for(i=0;i<xctx->instances... */ } /* for(i=0;i<instances... */
/* name nets that do not touch ipin opin alias instances */ /* name nets that do not touch ipin opin alias instances */
dbg(2, "prepare_netlist_structs(): naming nets that dont touch labels\n"); 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 */ /* name generic pins from attached labels */
dbg(2, "prepare_netlist_structs(): naming generics from attached labels\n"); 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(for_netlist) for (i=0;i<instances;i++) { /* ... assign node fields on all (non label) instances */
if (xctx->inst[i].ptr<0) continue; if (inst[i].ptr<0) continue;
my_strdup(267, &type,(xctx->inst[i].ptr+ xctx->sym)->type); my_strdup(267, &type,(inst[i].ptr+ xctx->sym)->type);
if (type && !IS_LABEL_OR_PIN(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++) for (j=rects;j<rects+generic_rects;j++)
{ {
if (xctx->inst[i].node[j]) continue; /* already named node */ if (inst[i].node[j]) continue; /* already named node */
rct=(xctx->inst[i].ptr+ xctx->sym)->rect[GENERICLAYER]; rct=(inst[i].ptr+ xctx->sym)->rect[GENERICLAYER];
x0=(rct[j-rects].x1+rct[j-rects].x2)/2; x0=(rct[j-rects].x1+rct[j-rects].x2)/2;
y0=(rct[j-rects].y1+rct[j-rects].y2)/2; y0=(rct[j-rects].y1+rct[j-rects].y2)/2;
rot=xctx->inst[i].rot; rot=inst[i].rot;
flip=xctx->inst[i].flip; flip=inst[i].flip;
ROTATION(0.0,0.0,x0,y0,rx1,ry1); ROTATION(0.0,0.0,x0,y0,rx1,ry1);
x0=xctx->inst[i].x0+rx1; x0=inst[i].x0+rx1;
y0=xctx->inst[i].y0+ry1; y0=inst[i].y0+ry1;
get_square(x0, y0, &sqx, &sqy); get_square(x0, y0, &sqx, &sqy);
iptr=instpintable[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 ((iptr->x0==x0) && (iptr->y0==y0))
{ {
if ((xctx->inst[iptr->n].ptr+ xctx->sym)->type && xctx->inst[iptr->n].node[iptr->pin] != NULL && if ((inst[iptr->n].ptr+ xctx->sym)->type && inst[iptr->n].node[iptr->pin] != NULL &&
!strcmp((xctx->inst[iptr->n].ptr+ xctx->sym)->type, "label")) !strcmp((inst[iptr->n].ptr+ xctx->sym)->type, "label"))
{ {
dbg(2, "prepare_netlist_structs(): naming generic %s\n", 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], my_strdup(268, &inst[i].node[j],
get_tok_value(xctx->inst[iptr->n].prop_ptr,"value",2) ); 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) { if (!for_netlist) {
my_strdup(270, &sig_type,""); 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,"", "",""); XINSERT, 1, sig_type,"", "","");
} else { } else {
my_strdup(271, &sig_type,get_tok_value( 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 */ /* 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 */ /* be declared as a signal in the vhdl netlist. this is a workaround */
/* that should be fixed 25092001 */ /* that should be fixed 25092001 */
bus_hash_lookup(xctx->inst[iptr->n].node[iptr->pin], bus_hash_lookup(inst[iptr->n].node[iptr->pin],
get_tok_value((xctx->inst[i].ptr+ xctx->sym)->rect[GENERICLAYER][j-rects].prop_ptr, "dir",0), get_tok_value((inst[i].ptr+ xctx->sym)->rect[GENERICLAYER][j-rects].prop_ptr, "dir",0),
XINSERT, 1, sig_type,"", "",""); 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) ) */ } /* end if( (iptr->x0==x0) && (iptr->y0==y0) ) */
iptr=iptr->next; iptr=iptr->next;
} }
@ -886,26 +890,26 @@ void prepare_netlist_structs(int for_netlist)
/* name instance pins of non (label,pin) instances */ /* name instance pins of non (label,pin) instances */
dbg(2, "prepare_netlist_structs(): assigning node names on instance pins\n"); 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; if(inst[i].ptr<0) continue;
expandlabel(xctx->inst[i].instname, &inst_mult); expandlabel(inst[i].instname, &inst_mult);
my_strdup(272, &type,(xctx->inst[i].ptr+ xctx->sym)->type); my_strdup(272, &type,(inst[i].ptr+ xctx->sym)->type);
if (type && !IS_LABEL_OR_PIN(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++) for (j=0;j<rects;j++)
{ {
touches=0; touches=0;
if (xctx->inst[i].node[j]) continue; /* already named node */ if (inst[i].node[j]) continue; /* already named node */
rct=(xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER]; rct=(inst[i].ptr+ xctx->sym)->rect[PINLAYER];
x0=(rct[j].x1+rct[j].x2)/2; x0=(rct[j].x1+rct[j].x2)/2;
y0=(rct[j].y1+rct[j].y2)/2; y0=(rct[j].y1+rct[j].y2)/2;
rot=xctx->inst[i].rot; rot=inst[i].rot;
flip=xctx->inst[i].flip; flip=inst[i].flip;
ROTATION(0.0,0.0,x0,y0,rx1,ry1); ROTATION(0.0,0.0,x0,y0,rx1,ry1);
x0=xctx->inst[i].x0+rx1; x0=inst[i].x0+rx1;
y0=xctx->inst[i].y0+ry1; y0=inst[i].y0+ry1;
get_square(x0, y0, &sqx, &sqy); get_square(x0, y0, &sqx, &sqy);
/* name instance nodes that touch named nets */ /* name instance nodes that touch named nets */
wptr=wiretable[sqx][sqy]; wptr=wiretable[sqx][sqy];
@ -919,21 +923,21 @@ void prepare_netlist_structs(int for_netlist)
/* short circuit check */ /* short circuit check */
if (touches) 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) if (!touches)
{ {
my_strdup(273, &xctx->inst[i].node[j], xctx->wire[wptr->n].node ); my_strdup(273, &inst[i].node[j], xctx->wire[wptr->n].node );
bus_hash_lookup(xctx->inst[i].node[j], bus_hash_lookup(inst[i].node[j],
get_tok_value( (xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0), get_tok_value( (inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0),
XINSERT, 0,"","","",""); XINSERT, 0,"","","","");
if (xctx->wire[wptr->n].node[0]=='#') /* unnamed node, update its multiplicity */ if (xctx->wire[wptr->n].node[0]=='#') /* unnamed node, update its multiplicity */
{ {
expandlabel(get_tok_value( 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) */ } /* end if(!touches) */
touches=1; touches=1;
@ -953,35 +957,35 @@ void prepare_netlist_structs(int for_netlist)
} }
if ((iptr->x0==x0) && (iptr->y0==y0)) 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 */ /* short circuit check */
if (touches) 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) 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) { 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 { } else {
bus_hash_lookup(xctx->inst[i].node[j], bus_hash_lookup(inst[i].node[j],
get_tok_value( (xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0), get_tok_value( (inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0),
XINSERT, 0,"","","",""); XINSERT, 0,"","","","");
} }
if ((xctx->inst[i].node[j])[0] == '#') if ((inst[i].node[j])[0] == '#')
{ {
expandlabel(get_tok_value( 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 */ /* done at beginning of for(i) loop 20171210 */
/* expandlabel(get_tok_value( */ /* expandlabel(get_tok_value( */
/* xctx->inst[i].prop_ptr,"name",0), &inst_mult); */ /* inst[i].prop_ptr,"name",0), &inst_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));
} }
} }
touches=1; 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 */ else /* touches instance with unnamed pins */
{ {
touches_unnamed=1; touches_unnamed=1;
@ -997,17 +1001,17 @@ void prepare_netlist_structs(int for_netlist)
if (!(CAD_VHDL_NETLIST && !touches_unnamed)) if (!(CAD_VHDL_NETLIST && !touches_unnamed))
{ {
expandlabel(get_tok_value( 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 */ /* done at beginning of for(i) loop 20171210 */
/* expandlabel(get_tok_value( */ /* 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_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) { 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 { } else {
bus_hash_lookup(xctx->inst[i].node[j], bus_hash_lookup(inst[i].node[j],
get_tok_value( (xctx->inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0), get_tok_value( (inst[i].ptr+ xctx->sym)->rect[PINLAYER][j].prop_ptr, "dir",0),
XINSERT, 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; const char *str;
char *skip_line; char *skip_line;
const char *dash; 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); dbg(1, "l_s_d(): recursion_counter=%d, name=%s\n", recursion_counter, name);
recursion_counter++; recursion_counter++;
@ -1581,11 +1583,11 @@ int load_sym_def(const char *name, FILE *embed_fd)
lastt=0; lastt=0;
tt=NULL; tt=NULL;
check_symbol_storage(); check_symbol_storage();
xctx->sym[xctx->symbols].prop_ptr = NULL; symbol[symbols].prop_ptr = NULL;
xctx->sym[xctx->symbols].type = NULL; symbol[symbols].type = NULL;
xctx->sym[xctx->symbols].templ = NULL; symbol[symbols].templ = NULL;
xctx->sym[xctx->symbols].name=NULL; symbol[symbols].name=NULL;
my_strdup(352, &xctx->sym[xctx->symbols].name,name); my_strdup(352, &symbol[symbols].name,name);
while(1) while(1)
{ {
if(endfile && embed_fd && level == 0) break; /* ']' line encountered --> exit */ 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; break;
case 'K': /* 1.2 file format: symbol attributes for schematics placed as symbols */ case 'K': /* 1.2 file format: symbol attributes for schematics placed as symbols */
if (level==0) { if (level==0) {
load_ascii_string(&xctx->sym[xctx->symbols].prop_ptr, lcc[level].fd); load_ascii_string(&symbol[symbols].prop_ptr, lcc[level].fd);
if(!xctx->sym[xctx->symbols].prop_ptr) break; if(!symbol[symbols].prop_ptr) break;
my_strdup2(424, &xctx->sym[xctx->symbols].templ, my_strdup2(424, &symbol[symbols].templ,
get_tok_value(xctx->sym[xctx->symbols].prop_ptr, "template",2)); get_tok_value(symbol[symbols].prop_ptr, "template",2));
my_strdup2(515, &xctx->sym[xctx->symbols].type, my_strdup2(515, &symbol[symbols].type,
get_tok_value(xctx->sym[xctx->symbols].prop_ptr, "type",0)); get_tok_value(symbol[symbols].prop_ptr, "type",0));
} }
else { else {
load_ascii_string(&aux_ptr, lcc[level].fd); load_ascii_string(&aux_ptr, lcc[level].fd);
} }
break; break;
case 'G': /* .sym files or pre-1.2 symbol attributes for schematics placed as symbols */ case 'G': /* .sym files or pre-1.2 symbol attributes for schematics placed as symbols */
if (level==0 && !xctx->sym[xctx->symbols].prop_ptr) { if (level==0 && !symbol[symbols].prop_ptr) {
load_ascii_string(&xctx->sym[xctx->symbols].prop_ptr, lcc[level].fd); load_ascii_string(&symbol[symbols].prop_ptr, lcc[level].fd);
if(!xctx->sym[xctx->symbols].prop_ptr) break; if(!symbol[symbols].prop_ptr) break;
my_strdup2(341, &xctx->sym[xctx->symbols].templ, my_strdup2(341, &symbol[symbols].templ,
get_tok_value(xctx->sym[xctx->symbols].prop_ptr, "template",2)); get_tok_value(symbol[symbols].prop_ptr, "template",2));
my_strdup2(342, &xctx->sym[xctx->symbols].type, my_strdup2(342, &symbol[symbols].type,
get_tok_value(xctx->sym[xctx->symbols].prop_ptr, "type",0)); get_tok_value(symbol[symbols].prop_ptr, "type",0));
} }
else { else {
load_ascii_string(&aux_ptr, lcc[level].fd); 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); fclose(lcc[0].fd);
} }
if(embed_fd || strstr(name, ".xschem_embedded_")) { if(embed_fd || strstr(name, ".xschem_embedded_")) {
xctx->sym[xctx->symbols].flags |= EMBEDDED; symbol[symbols].flags |= EMBEDDED;
} else { } else {
xctx->sym[xctx->symbols].flags &= ~EMBEDDED; symbol[symbols].flags &= ~EMBEDDED;
} }
dbg(2, "l_d_s(): finished parsing file\n"); dbg(2, "l_d_s(): finished parsing file\n");
for(c=0;c<cadlayers;c++) for(c=0;c<cadlayers;c++)
{ {
xctx->sym[xctx->symbols].arcs[c] = lasta[c]; symbol[symbols].arcs[c] = lasta[c];
xctx->sym[xctx->symbols].lines[c] = lastl[c]; symbol[symbols].lines[c] = lastl[c];
xctx->sym[xctx->symbols].rects[c] = lastr[c]; symbol[symbols].rects[c] = lastr[c];
xctx->sym[xctx->symbols].polygons[c] = lastp[c]; symbol[symbols].polygons[c] = lastp[c];
xctx->sym[xctx->symbols].arc[c] = aa[c]; symbol[symbols].arc[c] = aa[c];
xctx->sym[xctx->symbols].line[c] = ll[c]; symbol[symbols].line[c] = ll[c];
xctx->sym[xctx->symbols].poly[c] = pp[c]; symbol[symbols].poly[c] = pp[c];
xctx->sym[xctx->symbols].rect[c] = bb[c]; symbol[symbols].rect[c] = bb[c];
} }
xctx->sym[xctx->symbols].texts = lastt; symbol[symbols].texts = lastt;
xctx->sym[xctx->symbols].text = tt; symbol[symbols].text = tt;
calc_symbol_bbox(xctx->symbols); calc_symbol_bbox(symbols);
/* given a .sch file used as instance in LCC schematics, order its pin /* given a .sch file used as instance in LCC schematics, order its pin
* as in corresponding .sym file if it exists */ * 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++; xctx->symbols++;
my_free(910, &prop_ptr); my_free(910, &prop_ptr);
my_free(901, &lastl); 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==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE; else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote && !escape) state=XEND; else if( state==XVALUE && space && !quote && !escape) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval); STR_ALLOC(&value, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c; if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE) { else if(state==XVALUE) {
value[value_pos++]=c; 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==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE; else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote && !escape) state=XEND; else if( state==XVALUE && space && !quote && !escape) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval); STR_ALLOC(&value, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c; if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE) { else if(state==XVALUE) {
value[value_pos++]=c; 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==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE; else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote && !escape ) state=XEND; 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(c=='"') {
if(!escape) quote=!quote; 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==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE; else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote && !escape ) state=XEND; else if( state==XVALUE && space && !quote && !escape ) state=XEND;
str_alloc(&result, 0, value_pos, &size); /* don't use STR_ALLOC() for efficiency reasons */
str_alloc(&token, 0, token_pos, &sizetok); 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(c=='"') {
if(!escape) quote=!quote; if(!escape) quote=!quote;
} }
@ -566,7 +573,7 @@ const char *get_sym_template(char *s,char *extra)
return ""; return "";
} }
l = strlen(s); l = strlen(s);
str_alloc(&result, l+1, 0, &sizeres); STR_ALLOC(&result, l+1, &sizeres);
sizetok = sizeval = CADCHUNKALLOC; sizetok = sizeval = CADCHUNKALLOC;
my_realloc(438, &value,sizeval); my_realloc(438, &value,sizeval);
my_realloc(439, &token,sizetok); 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==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE; else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote) state=XEND; else if( state==XVALUE && space && !quote) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval); STR_ALLOC(&value, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XBEGIN) { if(state==XBEGIN) {
result[result_pos++] = c; result[result_pos++] = c;
} else if(state==XTOKEN) { } 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); space=SPACE(c);
if(c == '"' && !escape) quote=!quote; if(c == '"' && !escape) quote=!quote;
/* alloc data */ /* alloc data */
str_alloc(&result, 0, result_pos, &size); STR_ALLOC(&result, result_pos, &size);
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
/* parsing state machine */ /* parsing state machine */
/* states: */ /* states: */
@ -807,7 +814,7 @@ const char *subst_token(const char *s, const char *tok, const char *new_val)
tmp = 2; 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);
memcpy(result + result_pos+1, new_val, tmp); memcpy(result + result_pos+1, new_val, tmp);
memcpy(result + result_pos+1+tmp, " ", 1); 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 = "\"\""; new_val = "\"\"";
tmp = 2; tmp = 2;
} }
str_alloc(&result, tmp, result_pos, &size); STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result + result_pos ,new_val, tmp + 1); memcpy(result + result_pos ,new_val, tmp + 1);
result_pos += tmp; result_pos += tmp;
done_subst = 1; 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) {
if(!new_val[0]) new_val = "\"\""; if(!new_val[0]) new_val = "\"\"";
tmp = strlen(new_val) + strlen(tok) + 2; 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 */ 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==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE; else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote) state=XEND; else if( state==XVALUE && space && !quote) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval); STR_ALLOC(&value, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c; if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE) { else if(state==XVALUE) {
if(c=='"' && !escape) quote=!quote; 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==XTOKEN || state==XENDTOK) && c=='=') state=XSEPARATOR;
else if( state==XSEPARATOR && !space) state=XVALUE; else if( state==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote) state=XEND; else if( state==XVALUE && space && !quote) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval); STR_ALLOC(&value, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c; if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE) 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==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote) state=XEND; else if( state==XVALUE && space && !quote) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval); STR_ALLOC(&value, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c; if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE) else if(state==XVALUE)
{ {
@ -1340,7 +1347,7 @@ void print_spice_subckt(FILE *fd, int symbol)
state = XSEPARATOR; state = XSEPARATOR;
} }
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) { if(state==XTOKEN) {
token[token_pos++]=c; token[token_pos++]=c;
} }
@ -1443,7 +1450,7 @@ void print_spice_element(FILE *fd, int inst)
while(1) while(1)
{ {
/* always make room for some characters so the single char writes to result do not need reallocs */ /* 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++; c=*s++;
if(c=='\\') { if(c=='\\') {
escape=1; 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); dbg(1, "print_spice_element: c=%c, space=%d, escape=%d roken_pos=%d\n", c, space, escape, token_pos);
state=XSEPARATOR; state=XSEPARATOR;
} }
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) { if(state==XTOKEN) {
token[token_pos++]=c; 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 tmp = strlen(token + 1) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */ * 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); result_pos += my_snprintf(result + result_pos, tmp, "%s", token + 1);
/* fputs(token + 1, fd); */ /* fputs(token + 1, fd); */
} else if (value && value[0]!='\0') { } 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 tmp = strlen(lab) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */ * 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); result_pos += my_snprintf(result + result_pos, tmp, "%s", lab);
/* fputs(lab,fd); */ /* 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 tmp = strlen(value) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */ * 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); result_pos += my_snprintf(result + result_pos, tmp, "%s", value);
/* fputs(value,fd); */ /* fputs(value,fd); */
} }
@ -1518,7 +1525,7 @@ void print_spice_element(FILE *fd, int inst)
const char *s = skip_dir(xctx->inst[inst].name); const char *s = skip_dir(xctx->inst[inst].name);
tmp = strlen(s) +100 ; /* always make room for some extra chars tmp = strlen(s) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */ * 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); result_pos += my_snprintf(result + result_pos, tmp, "%s", s);
/* fputs(s,fd); */ /* 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); const char *s = get_cell_w_ext(xctx->inst[inst].name, 0);
tmp = strlen(s) +100 ; /* always make room for some extra chars tmp = strlen(s) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */ * 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); result_pos += my_snprintf(result + result_pos, tmp, "%s", s);
/* fputs(s,fd); */ /* 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 tmp = strlen(xctx->current_name) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */ * 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); result_pos += my_snprintf(result + result_pos, tmp, "%s", xctx->current_name);
/* fputs(xctx->current_name, fd); */ /* 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 tmp = strlen(str_ptr) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */ * 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); 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 tmp = strlen(str_ptr) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */ * 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); result_pos += my_snprintf(result + result_pos, tmp, "?%d %s ", mult, str_ptr);
} }
break; 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 tmp = strlen(str_ptr) +100 ; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */ * 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); 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 tmp = strlen(res) + 100; /* always make room for some extra chars
* so 1-char writes to result do not need reallocs */ * 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); result_pos += my_snprintf(result + result_pos, tmp, "%s", res);
/* fprintf(fd, "%s", tclresult()); */ /* fprintf(fd, "%s", tclresult()); */
my_free(1018, &tclcmd); my_free(1018, &tclcmd);
@ -1775,7 +1782,7 @@ void print_tedax_element(FILE *fd, int inst)
state=XSEPARATOR; state=XSEPARATOR;
} }
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) { if(state==XTOKEN) {
token[token_pos++]=c; /* 20171029 remove escaping backslashes */ 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==XSEPARATOR && !space) state=XVALUE;
else if( state==XVALUE && space && !quote) state=XEND; else if( state==XVALUE && space && !quote) state=XEND;
str_alloc(&value, 0, value_pos, &sizeval); STR_ALLOC(&value, value_pos, &sizeval);
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c; if(state==XTOKEN) token[token_pos++]=c;
else if(state==XVALUE) else if(state==XVALUE)
{ {
@ -2172,7 +2179,7 @@ void print_vhdl_primitive(FILE *fd, int inst) /* netlist primitives, 20071217 *
state=XSEPARATOR; state=XSEPARATOR;
} }
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) { if(state==XTOKEN) {
token[token_pos++]=c; /* 20171029 remove escaping backslashes */ 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; state=XSEPARATOR;
} }
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) { if(state==XTOKEN) {
token[token_pos++]=c; token[token_pos++]=c;
} }
@ -2550,8 +2557,8 @@ const char *translate(int inst, const char* s)
&& token_pos > 1 ) state=XSEPARATOR; && token_pos > 1 ) state=XSEPARATOR;
str_alloc(&result, 0, result_pos, &size); STR_ALLOC(&result, result_pos, &size);
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if(state==XTOKEN) token[token_pos++]=c; if(state==XTOKEN) token[token_pos++]=c;
else if(state==XSEPARATOR) else if(state==XSEPARATOR)
{ {
@ -2568,7 +2575,7 @@ const char *translate(int inst, const char* s)
if(!get_tok_size && token[0] =='$') { if(!get_tok_size && token[0] =='$') {
tmp=token_pos -1 ; /* we need token_pos -1 chars, ( strlen(token+1) ) , excluding leading '$' */ 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); dbg(2, "translate(): token=%s, token_pos = %d\n", token, token_pos);
memcpy(result+result_pos, token + 1, tmp+1); memcpy(result+result_pos, token + 1, tmp+1);
result_pos+=tmp; result_pos+=tmp;
@ -2576,19 +2583,19 @@ const char *translate(int inst, const char* s)
token_pos = 0; token_pos = 0;
if(get_tok_size) { if(get_tok_size) {
tmp=get_tok_value_size; /* strlen(value); */ 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); memcpy(result+result_pos, value, tmp+1);
result_pos+=tmp; result_pos+=tmp;
} else if(strcmp(token,"@symname")==0) { } else if(strcmp(token,"@symname")==0) {
tmp_sym_name=xctx->inst[inst].name ? get_cell(xctx->inst[inst].name, 0) : ""; tmp_sym_name=xctx->inst[inst].name ? get_cell(xctx->inst[inst].name, 0) : "";
tmp=strlen(tmp_sym_name); 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); memcpy(result+result_pos,tmp_sym_name, tmp+1);
result_pos+=tmp; result_pos+=tmp;
} else if(strcmp(token,"@symname_ext")==0) { } else if(strcmp(token,"@symname_ext")==0) {
tmp_sym_name=xctx->inst[inst].name ? get_cell_w_ext(xctx->inst[inst].name, 0) : ""; tmp_sym_name=xctx->inst[inst].name ? get_cell_w_ext(xctx->inst[inst].name, 0) : "";
tmp=strlen(tmp_sym_name); 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); memcpy(result+result_pos,tmp_sym_name, tmp+1);
result_pos+=tmp; result_pos+=tmp;
@ -2655,7 +2662,7 @@ const char *translate(int inst, const char* s)
my_free(1177, &tmpstr); my_free(1177, &tmpstr);
} }
tmp=strlen(value); tmp=strlen(value);
str_alloc(&result, tmp, result_pos, &size); STR_ALLOC(&result, tmp + result_pos, &size);
memcpy(result+result_pos, value, tmp+1); memcpy(result+result_pos, value, tmp+1);
result_pos+=tmp; result_pos+=tmp;
my_free(1064, &pin_attr_value); my_free(1064, &pin_attr_value);
@ -2673,7 +2680,7 @@ const char *translate(int inst, const char* s)
if(!stat(file_name , &time_buf)) { if(!stat(file_name , &time_buf)) {
tm=localtime(&(time_buf.st_mtime) ); tm=localtime(&(time_buf.st_mtime) );
tmp=strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", tm); 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); memcpy(result+result_pos, date, tmp+1);
result_pos+=tmp; result_pos+=tmp;
} }
@ -2682,7 +2689,7 @@ const char *translate(int inst, const char* s)
if(!stat(file_name , &time_buf)) { if(!stat(file_name , &time_buf)) {
tm=localtime(&(time_buf.st_mtime) ); tm=localtime(&(time_buf.st_mtime) );
tmp=strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", tm); 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); memcpy(result+result_pos, date, tmp+1);
result_pos+=tmp; result_pos+=tmp;
} }
@ -2691,27 +2698,27 @@ const char *translate(int inst, const char* s)
if(!stat(file_name , &time_buf)) { if(!stat(file_name , &time_buf)) {
tm=localtime(&(time_buf.st_mtime) ); tm=localtime(&(time_buf.st_mtime) );
tmp=strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", tm); 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); memcpy(result+result_pos, date, tmp+1);
result_pos+=tmp; result_pos+=tmp;
} }
} else if(strcmp(token,"@schname")==0) { } else if(strcmp(token,"@schname")==0) {
/* tmp=strlen(xctx->sch[xctx->currsch]);*/ /* tmp=strlen(xctx->sch[xctx->currsch]);*/
tmp = strlen(xctx->current_name); 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->sch[xctx->currsch], tmp+1); */
memcpy(result+result_pos, xctx->current_name, tmp+1); memcpy(result+result_pos, xctx->current_name, tmp+1);
result_pos+=tmp; result_pos+=tmp;
} else if(strcmp(token,"@prop_ptr")==0 && xctx->inst[inst].prop_ptr) { } else if(strcmp(token,"@prop_ptr")==0 && xctx->inst[inst].prop_ptr) {
tmp=strlen(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); memcpy(result+result_pos,xctx->inst[inst].prop_ptr, tmp+1);
result_pos+=tmp; result_pos+=tmp;
} }
else if(strcmp(token,"@schvhdlprop")==0 && xctx->schvhdlprop) else if(strcmp(token,"@schvhdlprop")==0 && xctx->schvhdlprop)
{ {
tmp=strlen(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); memcpy(result+result_pos,xctx->schvhdlprop, tmp+1);
result_pos+=tmp; result_pos+=tmp;
} }
@ -2719,7 +2726,7 @@ const char *translate(int inst, const char* s)
else if(strcmp(token,"@schprop")==0 && xctx->schprop) else if(strcmp(token,"@schprop")==0 && xctx->schprop)
{ {
tmp=strlen(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); memcpy(result+result_pos,xctx->schprop, tmp+1);
result_pos+=tmp; result_pos+=tmp;
} }
@ -2728,14 +2735,14 @@ const char *translate(int inst, const char* s)
else if(strcmp(token,"@schsymbolprop")==0 && xctx->schsymbolprop) else if(strcmp(token,"@schsymbolprop")==0 && xctx->schsymbolprop)
{ {
tmp=strlen(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); memcpy(result+result_pos,xctx->schsymbolprop, tmp+1);
result_pos+=tmp; result_pos+=tmp;
} }
else if(strcmp(token,"@schtedaxprop")==0 && xctx->schtedaxprop) else if(strcmp(token,"@schtedaxprop")==0 && xctx->schtedaxprop)
{ {
tmp=strlen(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); memcpy(result+result_pos,xctx->schtedaxprop, tmp+1);
result_pos+=tmp; result_pos+=tmp;
} }
@ -2744,7 +2751,7 @@ const char *translate(int inst, const char* s)
else if(strcmp(token,"@schverilogprop")==0 && xctx->schverilogprop) else if(strcmp(token,"@schverilogprop")==0 && xctx->schverilogprop)
{ {
tmp=strlen(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); memcpy(result+result_pos,xctx->schverilogprop, tmp+1);
result_pos+=tmp; 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) { else if (state == XTOKEN && ( (space && !escape) || c == '@' || (!space && escape)) && token_pos > 1) {
state = XSEPARATOR; state = XSEPARATOR;
} }
str_alloc(&result, 0, result_pos, &size); STR_ALLOC(&result, result_pos, &size);
str_alloc(&token, 0, token_pos, &sizetok); STR_ALLOC(&token, token_pos, &sizetok);
if (state == XTOKEN) token[token_pos++] = c; if (state == XTOKEN) token[token_pos++] = c;
else if (state == XSEPARATOR) { else if (state == XSEPARATOR) {
token[token_pos] = '\0'; token[token_pos] = '\0';
@ -2840,7 +2847,7 @@ const char *translate2(struct Lcc *lcc, int level, char* s)
i--; i--;
} }
tmp = get_tok_value_size; /* strlen(value); */ 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 /* 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. */ instance placement prop_ptr attributes at drawing/netlisting time. */
memcpy(result + result_pos , "$", 1); 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) { else if (strcmp(token, "@symname") == 0) {
tmp_sym_name = lcc[level].symname ? get_cell(lcc[level].symname, 0) : ""; tmp_sym_name = lcc[level].symname ? get_cell(lcc[level].symname, 0) : "";
tmp = strlen(tmp_sym_name); 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); memcpy(result + result_pos, tmp_sym_name, tmp + 1);
result_pos += tmp; result_pos += tmp;
} }
else if (strcmp(token, "@symname_ext") == 0) { else if (strcmp(token, "@symname_ext") == 0) {
tmp_sym_name = lcc[level].symname ? get_cell_w_ext(lcc[level].symname, 0) : ""; tmp_sym_name = lcc[level].symname ? get_cell_w_ext(lcc[level].symname, 0) : "";
tmp = strlen(tmp_sym_name); 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); memcpy(result + result_pos, tmp_sym_name, tmp + 1);
result_pos += tmp; 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 X_TO_XSCHEM(x) ((x)*xctx->zoom -xctx->xorigin)
#define Y_TO_XSCHEM(y) ((y)*xctx->zoom -xctx->yorigin) #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 typedef struct
{ {
unsigned short type; 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 hash_inst_pin(int what, int i, int j);
extern void del_inst_table(void); extern void del_inst_table(void);
extern void hash_wires(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 */ extern void hash_instances(void); /* 20171203 insert instance bbox in spatial hash table */
#ifdef HAS_CAIRO #ifdef HAS_CAIRO
@ -941,7 +952,6 @@ extern char* strtolower(char* s);
extern char* strtoupper(char* s); extern char* strtoupper(char* s);
extern void *my_malloc(int id, size_t size); extern void *my_malloc(int id, size_t size);
extern void my_realloc(int id, void *ptr,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_calloc(int id, size_t nmemb, size_t size);
extern void my_free(int id, void *ptr); extern void my_free(int id, void *ptr);
extern size_t my_strcat(int id, char **, const char *); extern size_t my_strcat(int id, char **, const char *);