1. Looking for Program
Hi everyone,
Somewhere in the Archives or Euforum, I saw something about an
Euphoria Program that analized your program and gave you a list of
all the Constants , Atoms, Integers, Sequences, objects and especially
Procedures and Functions that were used,
How often they were used and what for.
Does anyone know what this program is or was?
Don Cole,
SF
2. Re: Looking for Program
> Somewhere in the Archives or Euforum, I saw something about an
> Euphoria Program that analized your program and gave you a list of
> all the Constants , Atoms, Integers, Sequences, objects and especially
>
> Does anyone know what this program is or was?
Parser for Euphoria Programs by Humberto Yeverino
http://www.rapideuphoria.com/euparse.zip
I've used it before, but I think it needs work. It just grabs all the
info without really organizing it too well. One thing I'd like it to
do is tell me what the parameters of a routine are and their types, in
order. Then I could use it to parse include files for dll wrappers.
~Greg
3. Re: Looking for Program
Greg Haberek wrote:
> don cole wrote:
> > Somewhere in the Archives or Euforum, I saw something about an
> > Euphoria Program that analized your program and gave you a list of
> > all the Constants , Atoms, Integers, Sequences, objects and especially
> >
> > Does anyone know what this program is or was?
>
> Parser for Euphoria Programs by Humberto Yeverino
> <a
> href="http://www.rapideuphoria.com/euparse.zip">http://www.rapideuphoria.com/euparse.zip</a>
>
> I've used it before, but I think it needs work. It just grabs all the
> info without really organizing it too well. One thing I'd like it to
> do is tell me what the parameters of a routine are and their types, in
> order. Then I could use it to parse include files for dll wrappers.
It should be pretty easy to make a program like this now,
using the PD interpreter source (euphoria\source).
After parsing, instead of executing the program, you'd display the
symbol table (SymTab). (skip the temps and literal values,
and see global.e for the symbol table fields).
Regards,
Rob Craig
Rapid Deployment Software
http://www.RapidEuphoria.com
4. Re: Looking for Program
Robert Craig wrote:
>
> Greg Haberek wrote:
> > don cole wrote:
> > > Somewhere in the Archives or Euforum, I saw something about an
> > > Euphoria Program that analized your program and gave you a list of
> > > all the Constants , Atoms, Integers, Sequences, objects and especially
> > >
> > > Does anyone know what this program is or was?
> >
> > Parser for Euphoria Programs by Humberto Yeverino
> > <a
> > href="http://www.rapideuphoria.com/euparse.zip">http://www.rapideuphoria.com/euparse.zip</a>
> >
> > I've used it before, but I think it needs work. It just grabs all the
> > info without really organizing it too well. One thing I'd like it to
> > do is tell me what the parameters of a routine are and their types, in
> > order. Then I could use it to parse include files for dll wrappers.
>
> It should be pretty easy to make a program like this now,
> using the PD interpreter source (euphoria\source).
> After parsing, instead of executing the program, you'd display the
> symbol table (SymTab). (skip the temps and literal values,
> and see global.e for the symbol table fields).
>
> Regards,
> Rob Craig
> Rapid Deployment Software
> <a href="http://www.RapidEuphoria.com">http://www.RapidEuphoria.com</a>
>
Hi,
As to Robert's suggestion, I tried it quickly and managed to send all the tokens
to a file, and to indicate they were one of the following:
1)keywords had no S_TOKEN (identifying number) but themselves (i.e. "if" is
represented by "IF")
2)procedure names are S-TOKENed by "PROC"
3)function names are S-TOKENed by "FUNC"
4)type names are S-TOKENed by "TYPE"
5)just about everything else is S-TOKENed by "VARIABLE"
It's a start, but so far I am hesitant to use the word "easy" for outputting
really useful information for programmers with the PD interpreter. Any hints?
At my level of programming, a lot of things are not so easy :^D
--Quark
5. Re: Looking for Program
DB James wrote:
>
> Robert Craig wrote:
> >
> > Greg Haberek wrote:
> > > don cole wrote:
> > > > Somewhere in the Archives or Euforum, I saw something about an
> > > > Euphoria Program that analized your program and gave you a list of
> > > > all the Constants , Atoms, Integers, Sequences, objects and especially
> > > >
> > > > Does anyone know what this program is or was?
> > >
> > > Parser for Euphoria Programs by Humberto Yeverino
> > > <a
> > > href="http://www.rapideuphoria.com/euparse.zip">http://www.rapideuphoria.com/euparse.zip</a>
> > >
> > > I've used it before, but I think it needs work. It just grabs all the
> > > info without really organizing it too well. One thing I'd like it to
> > > do is tell me what the parameters of a routine are and their types, in
> > > order. Then I could use it to parse include files for dll wrappers.
> >
> > It should be pretty easy to make a program like this now,
> > using the PD interpreter source (euphoria\source).
> > After parsing, instead of executing the program, you'd display the
> > symbol table (SymTab). (skip the temps and literal values,
> > and see global.e for the symbol table fields).
> >
> > Regards,
> > Rob Craig
> > Rapid Deployment Software
> > <a href="http://www.RapidEuphoria.com">http://www.RapidEuphoria.com</a>
> >
>
> Hi,
>
> As to Robert's suggestion, I tried it quickly and managed to send all the
> tokens to
> a file, and to indicate they were one of the following:
>
> 1)keywords had no S_TOKEN (identifying number) but themselves (i.e. "if" is
> represented
> by "IF")
>
> 2)procedure names are S-TOKENed by "PROC"
>
> 3)function names are S-TOKENed by "FUNC"
>
> 4)type names are S-TOKENed by "TYPE"
>
> 5)just about everything else is S-TOKENed by "VARIABLE"
>
> It's a start, but so far I am hesitant to use the word "easy" for outputting
> really
> useful information for programmers with the PD interpreter. Any hints? At my
> level
> of programming, a lot of things are not so easy :^D
>
> --Quark
>
make a small test program and then write Symtab to Symtab.txt and comprare what
you see - that is the easiest and surest way to do it.
S_VTYPE is for routines 0, for variables it is integer_type, sequence_type...
S_NAME is name of routine or variable.
You can get list of all arguments of routine like this:
sub = routine's symtab_index
sym = SymTab[sub][S_NEXT]
for i = 1 to SymTab[sub][S_NUM_ARGS] do
<sym is argument>
sym = SymTab[sym][S_NEXT]
end for
You can get list of all variables of routine like this:
sub = routine's symtab_index
<first skip arguments like in the code above>
v = SymTab[sub][S_NEXT]
while v != 0 and
(SymTab[v][S_SCOPE] = SC_PRIVATE do
<v is private variable of routine>
v = SymTab[v][S_NEXT]
end while
As for the GUI I think a html page with hyperlinks would work good and would be
easy to write.
make a html page for every source file, put them in directory named after main
program file + "_analyze". if directory already exists show msgbox() to user and
abort.
- main page is "all_files.htm". on that page is a list of hyperlinks of all
files program includes, in order as they are included
- for every source file make a page. on top of page is a list of hyperlinks to
all global and global-to-file things in file, in order as they appear in file.
only routines have links.
- for every routine make a list of variables it declares, in order as they
appear in file:
procedure test (sequence msg)
atom answer
sequence built_msg
integer do_delete -- maybe group them by type to save space
i'm not sure if it is possible to get line number of symbol table entry.
6. Re: Looking for Program
DB James wrote:
>
> Hi,
>
> As to Robert's suggestion, I tried it quickly and managed to send all the
> tokens to
> a file, and to indicate they were one of the following:
>
> 1)keywords had no S_TOKEN (identifying number) but themselves (i.e. "if" is
> represented
> by "IF")
>
> 2)procedure names are S-TOKENed by "PROC"
>
> 3)function names are S-TOKENed by "FUNC"
>
> 4)type names are S-TOKENed by "TYPE"
>
> 5)just about everything else is S-TOKENed by "VARIABLE"
>
> It's a start, but so far I am hesitant to use the word "easy" for outputting
> really
> useful information for programmers with the PD interpreter. Any hints? At my
> level
> of programming, a lot of things are not so easy :^D
>
>
You might take a look at Pete's IL disassembler:
http://palacebuilders.pwp.blueyonder.co.uk/pdeuex.htm
Also, ooeu comes with an il disassembler:
http://wxeuphoria.sf.net/apps.htm
Matt Lewis
7. Re: Looking for Program
- Posted by DB James <larch at adelphia.net>
Aug 26, 2005
-
Last edited Aug 27, 2005
Tone Škoda wrote:
>
> DB James wrote:
> >
> > Robert Craig wrote:
> > >
> > > Greg Haberek wrote:
> > > > don cole wrote:
> > > > > Somewhere in the Archives or Euforum, I saw something about an
> > > > > Euphoria Program that analized your program and gave you a list of
> > > > > all the Constants , Atoms, Integers, Sequences, objects and especially
> > > > >
> > > > > Does anyone know what this program is or was?
> > > >
> > > > Parser for Euphoria Programs by Humberto Yeverino
> > > > <a
> > > > href="http://www.rapideuphoria.com/euparse.zip">http://www.rapideuphoria.com/euparse.zip</a>
> > > >
> > > > I've used it before, but I think it needs work. It just grabs all the
> > > > info without really organizing it too well. One thing I'd like it to
> > > > do is tell me what the parameters of a routine are and their types, in
> > > > order. Then I could use it to parse include files for dll wrappers.
> > >
> > > It should be pretty easy to make a program like this now,
> > > using the PD interpreter source (euphoria\source).
> > > After parsing, instead of executing the program, you'd display the
> > > symbol table (SymTab). (skip the temps and literal values,
> > > and see global.e for the symbol table fields).
> > >
> > > Regards,
> > > Rob Craig
> > > Rapid Deployment Software
> > > <a href="http://www.RapidEuphoria.com">http://www.RapidEuphoria.com</a>
> > >
> >
> > Hi,
> >
> > As to Robert's suggestion, I tried it quickly and managed to send all the
> > tokens to
> > a file, and to indicate they were one of the following:
> >
> > 1)keywords had no S_TOKEN (identifying number) but themselves (i.e. "if" is
> > represented
> > by "IF")
> >
> > 2)procedure names are S-TOKENed by "PROC"
> >
> > 3)function names are S-TOKENed by "FUNC"
> >
> > 4)type names are S-TOKENed by "TYPE"
> >
> > 5)just about everything else is S-TOKENed by "VARIABLE"
> >
> > It's a start, but so far I am hesitant to use the word "easy" for outputting
> > really
> > useful information for programmers with the PD interpreter. Any hints? At
> > my level
> > of programming, a lot of things are not so easy :^D
> >
> > --Quark
> >
>
> make a small test program and then write Symtab to Symtab.txt and comprare
> what you
> see - that is the easiest and surest way to do it.
>
>
> S_VTYPE is for routines 0, for variables it is integer_type, sequence_type...
>
> S_NAME is name of routine or variable.
>
> You can get list of all arguments of routine like this:
> sub = routine's symtab_index
> sym = SymTab[sub][S_NEXT]
> for i = 1 to SymTab[sub][S_NUM_ARGS] do
> <sym is argument>
> sym = SymTab[sym][S_NEXT]
> end for
>
> You can get list of all variables of routine like this:
> sub = routine's symtab_index
> <first skip arguments like in the code above>
> v = SymTab[sub][S_NEXT]
> while v != 0 and
> (SymTab[v][S_SCOPE] = SC_PRIVATE do
> <v is private variable of routine>
> v = SymTab[v][S_NEXT]
> end while
>
>
> As for the GUI I think a html page with hyperlinks would work good and would
> be easy
> to write.
>
> make a html page for every source file, put them in directory named after main
> program
> file + "_analyze". if directory already exists show msgbox() to user and
> abort.
>
> - main page is "all_files.htm". on that page is a list of hyperlinks of all
> files program
> includes, in order as they are included
>
> - for every source file make a page. on top of page is a list of hyperlinks to
> all
> global and global-to-file things in file, in order as they appear in file.
> only routines
> have links.
>
> - for every routine make a list of variables it declares, in order as they
> appear in
> file:
> procedure test (sequence msg)
> atom answer
> sequence built_msg
> integer do_delete -- maybe group them by type to save space
>
>
> i'm not sure if it is possible to get line number of symbol table entry.
Hello Tone,
Thanks much for this reply. It gives me quite a bit to think about and to try,
especially the list of variables in routines. I found your speculations about
using HTML for the report interesting, though I haven't done much with it before.
I remember having written a little program to convert a long chunk of text to
linked HTML pages, but that's all I've done with it so far.
My guess at the moment is that what would be useful to the programmer is not
defined clearly now. A way to start would be to write a clear simple report of
all the components to a text file: all the routines and variables and constants,
possibly with actual line numbers where they first occur, the number of calls,
etc. Then people would have something concrete to react to, and they would say
it should have this or that feature (including hyperlinks, maybe). Then anyone
interested could try modifying the report, this would continue until enough
people say "this is helpful, my coding is being improved".
My main problem so far in working at this sort of thing has been parsing issues.
Robert's parser plows ahead flawlessly and it would be nice to capitolize on it.
--Quark
8. Re: Looking for Program
- Posted by DB James <larch at adelphia.net>
Aug 26, 2005
-
Last edited Aug 27, 2005
Matt Lewis wrote:
>
> DB James wrote:
> >
> > Hi,
> >
> > As to Robert's suggestion, I tried it quickly and managed to send all the
> > tokens to
> > a file, and to indicate they were one of the following:
> >
> > 1)keywords had no S_TOKEN (identifying number) but themselves (i.e. "if" is
> > represented
> > by "IF")
> >
> > 2)procedure names are S-TOKENed by "PROC"
> >
> > 3)function names are S-TOKENed by "FUNC"
> >
> > 4)type names are S-TOKENed by "TYPE"
> >
> > 5)just about everything else is S-TOKENed by "VARIABLE"
> >
> > It's a start, but so far I am hesitant to use the word "easy" for outputting
> > really
> > useful information for programmers with the PD interpreter. Any hints? At
> > my level
> > of programming, a lot of things are not so easy :^D
> >
> >
> You might take a look at Pete's IL disassembler:
> <a
> href="http://palacebuilders.pwp.blueyonder.co.uk/pdeuex.htm">http://palacebuilders.pwp.blueyonder.co.uk/pdeuex.htm</a>
>
> Also, ooeu comes with an il disassembler:
> <a
> href="http://wxeuphoria.sf.net/apps.htm">http://wxeuphoria.sf.net/apps.htm</a>
>
> Matt Lewis
>
Hi,
Thanks for the links. I downloaded the executable, then downloaded the source
because the executable zip lacked the OOEU.HTM that explains things (maybe add
that to the executable zip?)
THe IL translations are interesting, but it is more the text info (the plain
meaning) that I'm wanting to extract. For me at this stage, it is OOEU's eval()
that is really intriguing. Years ago I wrote a C program (laboriously) that used
a sort of genetic population to evolve math formulas in answer to a series of
inputs that were generated by existing formulas. The population had to figure
out what the formula was that created the inputs and outputs that were given.
This worked, but it was made ridiculously awkward because I didn't know how to do
other than hard-code the formulas that generated the answers. I wanted to be
able to enter any formula, and watch the unfortunate population (a lot of
mortality for poor answers) evolve. Eval() maybe could solve that problem.
--Quark
9. Re: Looking for Program
DB James wrote:
>
> Thanks for the links. I downloaded the executable, then downloaded the source
> because
> the executable zip lacked the OOEU.HTM that explains things (maybe add that to
> the
> executable zip?)
>
> THe IL translations are interesting, but it is more the text info (the plain
> meaning)
> that I'm wanting to extract. For me at this stage, it is OOEU's eval() that
> is really
> intriguing. Years ago I wrote a C program (laboriously) that used a sort of
> genetic
> population to evolve math formulas in answer to a series of inputs that were
> generated
> by existing formulas. The population had to figure out what the formula was
> that created
> the inputs and outputs that were given. This worked, but it was made
> ridiculously
> awkward because I didn't know how to do other than hard-code the formulas that
> generated
> the answers. I wanted to be able to enter any formula, and watch the
> unfortunate population
> (a lot of mortality for poor answers) evolve. Eval() maybe could solve that
> problem.
>
I think that probably matheval would be better for something like this:
http://www.rapideuphoria.com/matheval.zip
Matt Lewis
10. Re: Looking for Program
Matt Lewis wrote:
>
> DB James wrote:
> >
> > Thanks for the links. I downloaded the executable, then downloaded the
> > source because
> > the executable zip lacked the OOEU.HTM that explains things (maybe add that
> > to the
> > executable zip?)
> >
> > THe IL translations are interesting, but it is more the text info (the plain
> > meaning)
> > that I'm wanting to extract. For me at this stage, it is OOEU's eval() that
> > is really
> > intriguing. Years ago I wrote a C program (laboriously) that used a sort of
> > genetic
> > population to evolve math formulas in answer to a series of inputs that were
> > generated
> > by existing formulas. The population had to figure out what the formula was
> > that created
> > the inputs and outputs that were given. This worked, but it was made
> > ridiculously
> > awkward because I didn't know how to do other than hard-code the formulas
> > that generated
> > the answers. I wanted to be able to enter any formula, and watch the
> > unfortunate population
> > (a lot of mortality for poor answers) evolve. Eval() maybe could solve that
> > problem.
> >
>
> I think that probably matheval would be better for something like this:
>
> <a
> href="http://www.rapideuphoria.com/matheval.zip">http://www.rapideuphoria.com/matheval.zip</a>
>
> Matt Lewis
>
Hello,
And hmm, that does look like the right thing for the job. Now all I have to do
is reconstruct what I did in a former millenium... Thanks.
--Quark
11. Re: Looking for Program
On Fri, 26 Aug 2005 13:16:52 -0700, DB James <guest at RapidEuphoria.com>
wrote:
>My guess at the moment is that what would be useful to the programmer is not
>defined clearly now.
I rely on a global file search for this kind of thing. For example, a
search of the Edita sources for 'token' might output this:
Searching for: token
D:\edita\easynclr.e:232 if ctype=TokenStart then
D:\edita\easynclr.e:238 if ctype>TokenChar then
D:\edita\easynclr.e:239 -- if ctype=TokenLast then
chidx2+=1 end if
D:\edita\easynclr.e:287 elsif ctype=TokenChar then
D:\edita\easynclr.e:289 and
charMap[text[chidx2]+1]=TokenChar do
D:\edita\easynld.e:43 TokenStart = 1,
D:\edita\easynld.e:44 TokenChar = 2,
D:\edita\easynld.e:45 -- TokenFirst = n(), -- Not yet supported
D:\edita\easynld.e:46 -- TokenLast = n(), -- Not yet supported
...
Then I can double click on any line to jump to that source code line.
The other thing I use is F1 on a procedure or function call to view
the parameters and comments, and/or jump to the actual code. One thing
I often find myself doing is typing eg 'showWindow' just so I can
press F1 on it.
While I accept that I have a biased view, I do think this kind of
detail really deserves to be integrated into an editor, rather than
some flat text report. If you figure out what it is you really want,
I'll see if I can integrate it into Edita.
Regards,
Pete
12. Re: Looking for Program
Pete Lomax wrote:
>
> On Fri, 26 Aug 2005 13:16:52 -0700, DB James <guest at RapidEuphoria.com>
> wrote:
>
> >My guess at the moment is that what would be useful to the programmer is not
> >defined clearly
> now.</font></i>
>
> I rely on a global file search for this kind of thing. For example, a
> search of the Edita sources for 'token' might output this:
>
> Searching for: token
> D:\edita\easynclr.e:232 if ctype=TokenStart then
> D:\edita\easynclr.e:238 if ctype>TokenChar then
> D:\edita\easynclr.e:239 -- if ctype=TokenLast then
> chidx2+=1 end if
> D:\edita\easynclr.e:287 elsif ctype=TokenChar then
> D:\edita\easynclr.e:289 and
> charMap[text[chidx2]+1]=TokenChar do
> D:\edita\easynld.e:43 TokenStart = 1,
> D:\edita\easynld.e:44 TokenChar = 2,
> D:\edita\easynld.e:45 -- TokenFirst = n(), -- Not yet supported
> D:\edita\easynld.e:46 -- TokenLast = n(), -- Not yet supported
> ...
>
> Then I can double click on any line to jump to that source code line.
>
> The other thing I use is F1 on a procedure or function call to view
> the parameters and comments, and/or jump to the actual code. One thing
> I often find myself doing is typing eg 'showWindow' just so I can
> press F1 on it.
>
> While I accept that I have a biased view, I do think this kind of
> detail really deserves to be integrated into an editor, rather than
> some flat text report. If you figure out what it is you really want,
> I'll see if I can integrate it into Edita.
>
> Regards,
> Pete
>
Hi Pete,
As you know, I use Edita as my editor. Thanks for the tips on how to use it
effectively to ferret out needed information. I'll use them.
And I think you may be right that integrating program analysis into an editor is
a good idea. In fact, I've always wondered why there is a tendency away from
language specific editors, when there are so many reasons to have them. Your
editor has features already that make it easier to program in Eu than with any
other editor I know of. The only tools that were comparable in usefullness (to
me anyway) were the compact QuickC and QhickAssembler type of tool that
integrated writing, editing, linking, compiling, running, debugging into one nice
GUI. I have used the more complex programs, such as MASM, but never was
comfortable with them due to complexity. Borland's Turbo programs were also
nicely integrated. Now we have "projects" and I haven't quite made that mental
jump yet. That is probably because I have always focused on simpler programs
than others do.
As to "what you really want", I was continuing to respond in the general
direction of Don Cole's request:
Quote-------
Somewhere in the Archives or Euforum, I saw something about an
Euphoria Program that analized your program and gave you a list of
all the Constants , Atoms, Integers, Sequences, objects and especially
Procedures and Functions that were used,
How often they were used and what for.
Does anyone know what this program is or was?
Don Cole,
End quote-------
You have already done some work along these lines with common code analysis.
And Robert's with trace and with profile give a lot of information. When I said
I didn't think it is clear yet what is the most useful information, I mean that
different programmers have different ideas about what information is needed and
in what form it should be. I even contributed a while ago to this information
need in a small way with my program that lists all routines to the top of the
code. Maybe we need a survey?
--Quark
13. Re: Looking for Program
DB James wrote:
>
> Pete Lomax wrote:
> >
> > On Fri, 26 Aug 2005 13:16:52 -0700, DB James <guest at RapidEuphoria.com>
> > wrote:
> >
> > >My guess at the moment is that what would be useful to the programmer is
> > >not defined clearly
> > now.</font></i>
> >
> > I rely on a global file search for this kind of thing. For example, a
> > search of the Edita sources for 'token' might output this:
> >
> > Searching for: token
> > D:\edita\easynclr.e:232 if ctype=TokenStart then
> > D:\edita\easynclr.e:238 if ctype>TokenChar then
> > D:\edita\easynclr.e:239 -- if ctype=TokenLast then
> > chidx2+=1 end if
> > D:\edita\easynclr.e:287 elsif ctype=TokenChar then
> > D:\edita\easynclr.e:289 and
> > charMap[text[chidx2]+1]=TokenChar do
> > D:\edita\easynld.e:43 TokenStart = 1,
> > D:\edita\easynld.e:44 TokenChar = 2,
> > D:\edita\easynld.e:45 -- TokenFirst = n(), -- Not yet supported
> > D:\edita\easynld.e:46 -- TokenLast = n(), -- Not yet supported
> > ...
> >
> > Then I can double click on any line to jump to that source code line.
> >
> > The other thing I use is F1 on a procedure or function call to view
> > the parameters and comments, and/or jump to the actual code. One thing
> > I often find myself doing is typing eg 'showWindow' just so I can
> > press F1 on it.
> >
> > While I accept that I have a biased view, I do think this kind of
> > detail really deserves to be integrated into an editor, rather than
> > some flat text report. If you figure out what it is you really want,
> > I'll see if I can integrate it into Edita.
> >
> > Regards,
> > Pete
> >
> Hi Pete,
>
> As you know, I use Edita as my editor. Thanks for the tips on how to use it
> effectively
> to ferret out needed information. I'll use them.
>
> And I think you may be right that integrating program analysis into an editor
> is a
> good idea. In fact, I've always wondered why there is a tendency away from
> language
> specific editors, when there are so many reasons to have them. Your editor
> has features
> already that make it easier to program in Eu than with any other editor I know
> of.
> The only tools that were comparable in usefullness (to me anyway) were the
> compact
> QuickC and QhickAssembler type of tool that integrated writing, editing,
> linking, compiling,
> running, debugging into one nice GUI. I have used the more complex programs,
> such
> as MASM, but never was comfortable with them due to complexity. Borland's
> Turbo programs
> were also nicely integrated. Now we have "projects" and I haven't quite made
> that
> mental jump yet. That is probably because I have always focused on simpler
> programs
> than others do.
>
> As to "what you really want", I was continuing to respond in the general
> direction
> of Don Cole's request:
> Quote-------
> Somewhere in the Archives or Euforum, I saw something about an
> Euphoria Program that analized your program and gave you a list of
> all the Constants , Atoms, Integers, Sequences, objects and especially
>
> Procedures and Functions that were used,
>
> How often they were used and what for.
>
> Does anyone know what this program is or was?
>
> Don Cole,
> End quote-------
>
> You have already done some work along these lines with common code analysis.
> And Robert's
> with trace and with profile give a lot of information. When I said I didn't
> think
> it is clear yet what is the most useful information, I mean that different
> programmers
> have different ideas about what information is needed and in what form it
> should be.
> I even contributed a while ago to this information need in a small way with
> my program
> that lists all routines to the top of the code. Maybe we need a survey?
>
> --Quark
>
I download and tried Parser for Euphoria Programs by Humberto Yeverino,
as suggested by ~Greg.
I also found it unorganized and not very clear to use.
I did mention variables but all I really needed to analize were funtion and
procedures. Because I have lengthy program with a lot convoluted includes. I
thought I could it clean up.
I decided I don't really need a program to do this at all. Just in the future
organize my
includes in my mind in a better order before I start. I know that's not always
posible because something new always comes up after I start.
Thanks all for the input,
Don Cole,
SF
14. Re: Looking for Program
don cole wrote:
> I download and tried Parser for Euphoria Programs by Humberto Yeverino,
> as suggested by ~Greg.
>
> I also found it unorganized and not very clear to use.
I forgot mention here that it made no printable report.
>
> I did mention variables but all I really needed to analize were funtion and
> procedures.
Here I wanted say I thought of writing my own program to do this.
> Because I have lengthy program with a lot convoluted includes. I
> thought I could it clean up.
>
> I decided I don't really need a program to do this at all. Just in the
> future organize
> my
> includes in my mind in a better order before I start. I know that's not always
> posible because something new always comes up after I start.
>
> Thanks all for the input,
> Don Cole,
> SF
>
