ULP: Create reliable temp filename for scripts

MD5 or some other hash of say the date is normally quite good.... Unlikely to randomly generate two of these together.

by date I mean date and time of course. Depending on the rate you are opening files the second time maybe enough but you may need the millisecond timer.

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

The problem is not to generate a unique filename but to find path to write to. This is plattform dependant so I cannot just assume /tmp

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);

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

 

Hi

It appears there is no real speed advantage using the array/string join

method in Eagle ULP. The method is used in other coding to advantage. It is

said that many browsers have optimised their treatment of string

concatenation and have it running faster than array/string join.

I got curious to see what the advantage gain was in Eagle. Run the attached

ULP that times the two methods. The first time its run there is no

difference in time between the two methods but run it again (Go) and you

see concatenation take the same time but array/string gets quicker. I

suspect the array is still in place so the ULP processor does not need to

create it. Normally a ULP would build the exit(command string) only once so

both methods are as quick as each other.

I feel the advantage of running a script is that Eagle appears to perform

the commands from the script far faster than it processes the commands in

an exit command and advantages like speed of rendering the result in the

editor. You can see the difference on slower PCs. You can see from the ULP

that saving the text string (from the concatenation test) only adds a few

milliseconds so for me its often the preferred technique.

Enjoy

Warren

--

Web access to CadSoft support forums at www.eaglecentral.ca.  Where the CadSoft EAGLE community meets.

Interesting,

I consistently get results showing that strjoin() is about twice as fast

as the concatenate.  This is on a 3GHz Pentium running Linux 2.6.34.

But as you mentioned, it's miniscule compared to the time it takes to

execute the script.

See attached screen shot.

    - Chuck

On 06/22/2013 03:37 AM, Warren Brayshaw wrote:

Hi

 

It appears there is no real speed advantage using the array/string join

method in Eagle ULP. The method is used in other coding to advantage. It is

said that many browsers have optimised their treatment of string

concatenation and have it running faster than array/string join.

 

I got curious to see what the advantage gain was in Eagle. Run the attached

ULP that times the two methods. The first time its run there is no

difference in time between the two methods but run it again (Go) and you

see concatenation take the same time but array/string gets quicker. I

suspect the array is still in place so the ULP processor does not need to

create it. Normally a ULP would build the exit(command string) only once so

both methods are as quick as each other.

 

I feel the advantage of running a script is that Eagle appears to perform

the commands from the script far faster than it processes the commands in

an exit command and advantages like speed of rendering the result in the

editor. You can see the difference on slower PCs. You can see from the ULP

that saving the text string (from the concatenation test) only adds a few

milliseconds so for me its often the preferred technique.

 

Enjoy

 

Warren

 

 

Attachments: