RE: [Axiom-developer] Re: aldor patches

[Page, Bill]

Peter,

On Wednesday, August 24, 2005 2:19 PM you wrote:
> >
> >   \begin{aldor}
> >   Aldor code
> >   \end{aldor}
> >
> 
> This ought to work, but not immediately; One problem may be compiling
> several aldor stanzas together - in this case you need to be able to
> refer to earlier stanzas within the aldor block.
> 
> Eg:
> 
> \begin{aldor}
>       AldorCat: Category == with { funstuff }
> \end{aldor}
> 
> \begin{aldor}
>       AldorDomain: AldorCat with { ... } == add { ... }
> \end{aldor}
>

In the case of \begin{axiom} sections, what MathAction does is
generate a .input or .spad file for each section and then calls
Axiom just once using stdin to pass )read or )compile commands
for each section as appropriate. So, for each web page there is
only one Axiom session and the namespace is the same for the
entire page. (Except for comments containing \begin{axiom}
sections which are initially each run in their own Axiom session
before being appended to the page.)

Perhaps I can do the same thing for Aldor? Can I run Aldor
with a series of 'include' files - one for each \begin{aldor}
section? Would that solve the problem of referring to earlier
sections?

To make this work properly I also need some kind of unique separator
string between the Aldor compiler output for each include file.
In the case of Axiom that separator is the interpreter '(99) -> '
prompt sequence. For Spad sections, the \begin{axiom} \end{axiom}
group is replaced with <pre>formatted</pre> HTML tag containing
the Spad code followed by a <div> ... </div> section containing
the Spad compiler output (which appears as "folded" text"). Can
you suggest a way to generate such a separator for Aldor compiler
output if the input consists of a series of 'include' files?

> To compile the second you'll need access to the .ao file generated
> by the first.  One solution may be to keep a list of .ao files
> within MathAction's session.  Alternatively, each stanza could
> implicitly contain all the previous ones.

The use of 'include' files above should handle this case, right?

Where do the .ao files need to be stored in order to be accessible
to Axiom commands? Can more than one .ao file be generate per run
of the Aldor compiler? Is it sufficient if they are saved in the
current working directory?

> 
> >
> > In the log file you will note that the make failes starting
> > at this point:
> >
> > ...
> > /home/page/repository/axiom--main--1/src/aldor/Make.rules:31:
> 
> Yes, this is due to me not testing stuff terribly well.  I've sent Tim
a
> new .tgz - appended below.
>

Thanks for sending this revised file. It gets further, but
Unfortunately it still does not complete.

The new src_aldor.tgs file that you sent does not contain any
Makefile, however I figured that you expected me to initially
do

  # document Makefile.pamphlet

in order to generate the Makefile and the type

  # make 2>&1 | tee aldor.log

The result of doing this is contained in the new attached log
file.

The log file contains two runs of make in sequence. The first run
stops with the message:

make[1]: *** No rule to make target
`/home/page/repository/axiom--main--1/int/aldor/dep_spad.stamp', needed
by `/home/page/repository/axiom--main--1/int/aldor/saxiom/spadset.mk'.
Stop.

To continue I did

  # touch ../../int/aldor/dep_spad.stamp
  # make 2>&1 | tee -a aldor.log

Is this due to another missing file? I noticed that your new src_aldor
File is a smaller than the previous one. Should I have first untarred
the previous file and then overlayed it with the new one?

The build progressed further but then apparently stopped because
a statement in the generated Makefile exceeded some command line
length limit for either make or /bin/sh.

What linux operating system and utility versions are you using
to do your development? I am trying to build this on the
axiom-developer/MathAction server which is running RedHat 9
(updated almost, I think, to the level when RedHat discontinued
it's development about two years ago in favor of Fedora). The
server runs in shared virtual server mode.

Is there some way your java program can easily generate a more
Portable Makefile? Or do you know of anyway to allocate a
Larger command line buffer?

Regards,
Bill Page.

aldor2.log
Description: aldor2.log