static void
move_one_thermal (int old_index, int new_index, PinType *pin)
{
int t1=0, i;
int oi=old_index, ni=new_index;
if (old_index != -1)
t1 = GET_THERM (old_index, pin);
if (oi == -1)
oi = MAX_LAYER-1; /* inserting a layer */
if (ni == -1)
ni = MAX_LAYER-1; /* deleting a layer */
if (oi < ni)
{
for (i=oi; i<ni; i++)
ASSIGN_THERM (i, GET_THERM (i+1, pin), pin);
}
else
{
for (i=oi; i>ni; i--)
ASSIGN_THERM (i, GET_THERM (i-1, pin), pin);
}
if (new_index != -1)
ASSIGN_THERM (new_index, t1, pin);
else
ASSIGN_THERM (ni, 0, pin);
}
int
mptl_pin_callback (const BoxType *b, void *cl)
{
struct mptlc *d = (struct mptlc *) cl;
PinTypePtr pin = (PinTypePtr) b;
if (!TEST_THERM (d->snum, pin) || !
IsPointInPolygon (pin->X, pin->Y, pin->Thickness + pin->Clearance + 2,
d->polygon))
return 0;
if (d->type == PIN_TYPE)
AddObjectToFlagUndoList (PIN_TYPE, pin->Element, pin, pin);
else
AddObjectToFlagUndoList (VIA_TYPE, pin, pin, pin);
ASSIGN_THERM (d->dnum, GET_THERM (d->snum, pin), pin);
CLEAR_THERM (d->snum, pin);
return 1;
}
int
main ()
{
time_t now;
int i;
int errors = 0, count = 0;
time (&now);
srandom ((unsigned int) now + getpid ());
grow_layer_list (0);
for (i = 0; i < 16; i++)
{
int j;
char *p;
if (i != 1 && i != 4 && i != 5 && i != 9)
set_layer_list (i, 1);
else
set_layer_list (i, 0);
p = print_layer_list ();
printf ("%2d : %20s =", i, p);
parse_layer_list (p + 1, 0);
for (j = 0; j < num_layers; j++)
printf (" %d", layers[j]);
printf ("\n");
}
while (count < 1000000)
{
FlagHolder fh;
char *str;
FlagType new_flags;
int i;
int otype;
otype = ALL_TYPES;
fh.Flags = empty_flags;
for (i = 0; i < ENTRIES (object_flagbits); i++)
{
if (TEST_FLAG (object_flagbits[i].mask, &fh))
continue;
if ((otype & object_flagbits[i].object_types) == 0)
continue;
if ((random () & 4) == 0)
continue;
otype &= object_flagbits[i].object_types;
SET_FLAG (object_flagbits[i].mask, &fh);
}
if (otype & PIN_TYPES)
for (i = 0; i < MAX_LAYER; i++)
if (random () & 4)
ASSIGN_THERM (i, 3, &fh);
str = flags_to_string (fh.Flags, otype);
new_flags = string_to_flags (str, 0);
count++;
if (FLAGS_EQUAL (fh.Flags, new_flags))
continue;
dump_flag (&fh.Flags);
printf (" ");
dump_flag (&new_flags);
printf ("\n");
if (++errors == 5)
exit (1);
}
while (count < 1000000)
{
FlagHolder fh;
char *str;
FlagType new_flags;
int i;
int otype;
otype = ALL_TYPES;
fh.Flags = empty_flags;
for (i = 0; i < ENTRIES (pcb_flagbits); i++)
{
if (TEST_FLAG (pcb_flagbits[i].mask, &fh))
continue;
if ((random () & 4) == 0)
continue;
otype &= pcb_flagbits[i].object_types;
SET_FLAG (pcb_flagbits[i].mask, &fh);
}
str = pcbflags_to_string (fh.Flags);
new_flags = string_to_pcbflags (str, 0);
count++;
if (FLAGS_EQUAL (fh.Flags, new_flags))
continue;
dump_flag (&fh.Flags);
printf (" ");
dump_flag (&new_flags);
printf ("\n");
if (++errors == 5)
exit (1);
}
printf ("%d out of %d failed\n", errors, count);
return errors;
}
static FlagType
common_string_to_flags (const char *flagstring,
int (*error) (const char *msg),
FlagBitsType *flagbits,
int n_flagbits)
{
const char *fp, *ep;
int flen;
FlagHolder rv;
int i;
rv.Flags = empty_flags;
if (error == 0)
error = error_ignore;
if (flagstring == NULL)
return empty_flags;
fp = ep = flagstring;
if (*fp == '"')
ep = ++fp;
while (*ep && *ep != '"')
{
int found = 0;
for (ep = fp; *ep && *ep != ',' && *ep != '"' && *ep != '('; ep++)
;
flen = ep - fp;
if (*ep == '(')
ep = parse_layer_list (ep + 1, error);
if (flen == 7 && memcmp (fp, "thermal", 7) == 0)
{
for (i = 0; i < MAX_LAYER && i < num_layers; i++)
if (layers[i])
ASSIGN_THERM (i, layers[i], &rv);
}
else
{
for (i = 0; i < n_flagbits; i++)
if (flagbits[i].nlen == flen
&& memcmp (flagbits[i].name, fp, flen) == 0)
{
found = 1;
SET_FLAG (flagbits[i].mask, &rv);
break;
}
if (!found)
{
const char *fmt = "Unknown flag: \"%.*s\" ignored";
char *msg = alloc_buf (strlen (fmt) + flen);
sprintf (msg, fmt, flen, fp);
error (msg);
}
}
fp = ep + 1;
}
return rv.Flags;
}
/* ---------------------------------------------------------------------------
* flip components/tracks from one side to the other
*/
static void
SwapBuffer (BufferType *Buffer)
{
int j, k;
Cardinal sgroup, cgroup;
LayerType swap;
ELEMENT_LOOP (Buffer->Data);
{
r_delete_element (Buffer->Data, element);
MirrorElementCoordinates (Buffer->Data, element, 0);
}
END_LOOP;
/* set buffer offset to 'mark' position */
Buffer->X = SWAP_X (Buffer->X);
Buffer->Y = SWAP_Y (Buffer->Y);
VIA_LOOP (Buffer->Data);
{
r_delete_entry (Buffer->Data->via_tree, (BoxType *)via);
via->X = SWAP_X (via->X);
via->Y = SWAP_Y (via->Y);
SetPinBoundingBox (via);
r_insert_entry (Buffer->Data->via_tree, (BoxType *)via, 0);
}
END_LOOP;
ALLLINE_LOOP (Buffer->Data);
{
r_delete_entry (layer->line_tree, (BoxType *)line);
line->Point1.X = SWAP_X (line->Point1.X);
line->Point1.Y = SWAP_Y (line->Point1.Y);
line->Point2.X = SWAP_X (line->Point2.X);
line->Point2.Y = SWAP_Y (line->Point2.Y);
SetLineBoundingBox (line);
r_insert_entry (layer->line_tree, (BoxType *)line, 0);
}
ENDALL_LOOP;
ALLARC_LOOP (Buffer->Data);
{
r_delete_entry (layer->arc_tree, (BoxType *)arc);
arc->X = SWAP_X (arc->X);
arc->Y = SWAP_Y (arc->Y);
arc->StartAngle = SWAP_ANGLE (arc->StartAngle);
arc->Delta = SWAP_DELTA (arc->Delta);
SetArcBoundingBox (arc);
r_insert_entry (layer->arc_tree, (BoxType *)arc, 0);
}
ENDALL_LOOP;
ALLPOLYGON_LOOP (Buffer->Data);
{
r_delete_entry (layer->polygon_tree, (BoxType *)polygon);
POLYGONPOINT_LOOP (polygon);
{
point->X = SWAP_X (point->X);
point->Y = SWAP_Y (point->Y);
}
END_LOOP;
SetPolygonBoundingBox (polygon);
r_insert_entry (layer->polygon_tree, (BoxType *)polygon, 0);
/* hmmm, how to handle clip */
}
ENDALL_LOOP;
ALLTEXT_LOOP (Buffer->Data);
{
r_delete_entry (layer->text_tree, (BoxType *)text);
text->X = SWAP_X (text->X);
text->Y = SWAP_Y (text->Y);
TOGGLE_FLAG (ONSOLDERFLAG, text);
SetTextBoundingBox (&PCB->Font, text);
r_insert_entry (layer->text_tree, (BoxType *)text, 0);
}
ENDALL_LOOP;
/* swap silkscreen layers */
swap = Buffer->Data->Layer[solder_silk_layer];
Buffer->Data->Layer[solder_silk_layer] =
Buffer->Data->Layer[component_silk_layer];
Buffer->Data->Layer[component_silk_layer] = swap;
/* swap layer groups when balanced */
sgroup = GetLayerGroupNumberByNumber (solder_silk_layer);
cgroup = GetLayerGroupNumberByNumber (component_silk_layer);
if (PCB->LayerGroups.Number[cgroup] == PCB->LayerGroups.Number[sgroup])
{
for (j = k = 0; j < PCB->LayerGroups.Number[sgroup]; j++)
{
int t1, t2;
Cardinal cnumber = PCB->LayerGroups.Entries[cgroup][k];
Cardinal snumber = PCB->LayerGroups.Entries[sgroup][j];
if (snumber >= max_copper_layer)
continue;
swap = Buffer->Data->Layer[snumber];
while (cnumber >= max_copper_layer)
{
k++;
cnumber = PCB->LayerGroups.Entries[cgroup][k];
}
Buffer->Data->Layer[snumber] = Buffer->Data->Layer[cnumber];
Buffer->Data->Layer[cnumber] = swap;
k++;
/* move the thermal flags with the layers */
ALLPIN_LOOP (Buffer->Data);
{
t1 = TEST_THERM (snumber, pin);
t2 = TEST_THERM (cnumber, pin);
ASSIGN_THERM (snumber, t2, pin);
ASSIGN_THERM (cnumber, t1, pin);
}
ENDALL_LOOP;
VIA_LOOP (Buffer->Data);
{
t1 = TEST_THERM (snumber, via);
t2 = TEST_THERM (cnumber, via);
ASSIGN_THERM (snumber, t2, via);
ASSIGN_THERM (cnumber, t1, via);
}
END_LOOP;
}
}
SetBufferBoundingBox (Buffer);
SetCrosshairRangeToBuffer ();
}
static FlagType
common_string_to_flags (const char *flagstring,
int (*error) (const char *msg),
FlagBitsType *flagbits,
int n_flagbits)
{
const char *fp, *ep;
int flen;
FlagHolder rv;
int i;
rv.Flags = empty_flags;
if (error == 0)
error = error_ignore;
if (flagstring == NULL)
return empty_flags;
fp = ep = flagstring;
if (*fp == '"')
ep = ++fp;
while (*ep && *ep != '"')
{
int found = 0;
for (ep = fp; *ep && *ep != ',' && *ep != '"' && *ep != '('; ep++)
;
flen = ep - fp;
if (*ep == '(')
ep = parse_layer_list (ep + 1, error);
if (flen == 7 && memcmp (fp, "thermal", 7) == 0)
{
for (i = 0; i < MAX_LAYER && i < num_layers; i++)
if (layers[i])
ASSIGN_THERM (i, layers[i], &rv);
}
else
if (flen == 5 && memcmp (fp, "shape", 5) == 0)
{
rv.Flags.q=atoi(fp+6);
}
else
if (flen == 7 && memcmp (fp, "intconn", 7) == 0)
{
rv.Flags.int_conn_grp=atoi(fp+8);
}
else
{
for (i = 0; i < n_flagbits; i++)
if (flagbits[i].nlen == flen
&& memcmp (flagbits[i].name, fp, flen) == 0)
{
found = 1;
SET_FLAG (flagbits[i].mask, &rv);
break;
}
if (!found)
{
const char *fmt = "Unknown flag: \"%.*s\" ignored";
unknown_flag_t *u;
char *msg, *s;
/* include () */
s = fp + flen;
if (*s == '(') {
while(*s != ')') {
flen++;
s++;
}
}
if (*s == ')')
flen++;
msg = alloc_buf (strlen (fmt) + flen);
sprintf (msg, fmt, flen, fp);
error (msg);
u = malloc(sizeof(unknown_flag_t));
u->str = strndup(fp, flen);
u->next = NULL;
/* need to append, to keep order of flags */
if (rv.Flags.unknowns != NULL) {
unknown_flag_t *n;
for(n = rv.Flags.unknowns; n->next != NULL; n = n->next) ;
n->next = u;
}
else
rv.Flags.unknowns = u;
}
}
fp = ep + 1;
}
return rv.Flags;
}
