ULP: Create reliable temp filename for scripts

On 06/20/2013 09:06 AM, Axel Jäger wrote:

Hello,

as far as I understand, the only way to manipulate the data structure of

either an eagle schematic, board or library through an ULP is to collect

the necessary commands in a text file and execute it using exit ("script

<filename>").

Axel,

Rather than collecting commands into a file, collect them into a string

then pass the string as the single argument to exit().

    string cmd = "";

    cmd += "display all;\n";    // display all layers

    cmd += "group all;\n";      // Group all objects

    cmd += "lock (CS> 0 0);\n"; // Unlock everything.

    cmd += "display last;\n";   // restore the original display

    ... add more useful commands to cmd

    exit(cmd);

No files are used here.

HTH,

    - Chuck

Chuck: THIS is the solution, many thanks.

Axel Jäger wrote:

Chuck: THIS is the solution, many thanks.

 

--

Chuck's solution is used often but is slow when you perform many cmd +=

Concatenating strings in a ULP is slow.

When that becomes and issue you can have your ULP create your script file in

the directory of the current  editor file you have open. You  know you can

write to that place.

You create the file using  open ("text file",wtD) so that that file is

deleted when Eagle is closed. Hence the file is temporary.

I think that covers your needs

Warren

--

Viewed / responded via the newsgroup at

news.cadsoft.de

Chuck's solution is used often but is slow when you perform many cmd +=

Concatenating strings in a ULP is slow.

Well, don't use string concatenation. Collect all the commands in a

string array and only as last step do the concatenation with strjoin().

Another benefit is you can use sprintf() and generate complex command

strings much easier. See the code below.

Kim

====================================

int ns;          //define counter

string scr[];     //define cmd array

//insert simple command/s

scr[ns++] = "set undo_log off; set confirm yes;";

//insert complex commands

sprintf(scr[ns++], "edit %s.brd;", name);

sprintf(scr[ns++], "text '%s' %s%sR%f (%fmm %fmm);", t[i].value, spin,

mirr, t[i].angle, u2mm(t[i].x), u2mm(t[i].y));

//concatenate array->string

string cmd = strjoin(scr,' ');

//exit and execute the script

exit(cmd);

====================================

Kim,

I like that even better.  I am aware of the inefficiencies of doing

multiple string concatenations.  Underneath the covers, I assume that

each concatination does a strlen() on both strings to determine the

memory required, then copies both strings to the newly allocated space.

So the cost goes up with the number and length of the strings exponentially.

strjoin(), however, looks like it can scan all the strings once to

determine memory requirements, then copying each string into the

allocated space.  So the cost is at worst 2n - more of a linear increase

in cost.  Much more CPU friendly than successive concatenations.

Thanks for pointing out a better method.  I'll put it to good use.

    - Chuck

On 06/21/2013 08:52 AM, KimP wrote:

Chuck's solution is used often but is slow when you perform many cmd +=

Concatenating strings in a ULP is slow.

 

Well, don't use string concatenation. Collect all the commands in a

string array and only as last step do the concatenation with

strjoin(). Another benefit is you can use sprintf() and generate

complex command strings much easier. See the code below.

 

Kim

 

====================================

int ns;        //define counter

string scr[];    //define cmd array

 

//insert simple command/s

scr[ns++] = "set undo_log off; set confirm yes;";

 

//insert complex commands

sprintf(scr[ns++], "edit %s.brd;", name);

sprintf(scr[ns++], "text '%s' %s%sR%f (%fmm %fmm);", t[i].value, spin,

mirr, t[i].angle, u2mm(t[i].x), u2mm(t[i].y));

 

//concatenate array->string

string cmd = strjoin(scr,' ');

 

//exit and execute the script

exit(cmd);

====================================

 

Kim,

I like that even better.  I am aware of the inefficiencies of doing

multiple string concatenations.  Underneath the covers, I assume that

each concatination does a strlen() on both strings to determine the

memory required, then copies both strings to the newly allocated space.

So the cost goes up with the number and length of the strings exponentially.

strjoin(), however, looks like it can scan all the strings once to

determine memory requirements, then copying each string into the

allocated space.  So the cost is at worst 2n - more of a linear increase

in cost.  Much more CPU friendly than successive concatenations.

Thanks for pointing out a better method.  I'll put it to good use.

    - Chuck

On 06/21/2013 08:52 AM, KimP wrote:

Chuck's solution is used often but is slow when you perform many cmd +=

Concatenating strings in a ULP is slow.

 

Well, don't use string concatenation. Collect all the commands in a

string array and only as last step do the concatenation with

strjoin(). Another benefit is you can use sprintf() and generate

complex command strings much easier. See the code below.

 

Kim

 

====================================

int ns;        //define counter

string scr[];    //define cmd array

 

//insert simple command/s

scr[ns++] = "set undo_log off; set confirm yes;";

 

//insert complex commands

sprintf(scr[ns++], "edit %s.brd;", name);

sprintf(scr[ns++], "text '%s' %s%sR%f (%fmm %fmm);", t[i].value, spin,

mirr, t[i].angle, u2mm(t[i].x), u2mm(t[i].y));

 

//concatenate array->string

string cmd = strjoin(scr,' ');

 

//exit and execute the script

exit(cmd);

====================================