dummy fields

[John Esak]

	> > Dummy fields that are declared in the automatic processing 
> table will be 
> > shared among all processing tables(*).  Those that are not, 
> are not shared 
> > at all.
> > 
> > (*) The exception, of course, being those called via "CALL NOAUTO".
> 
> Questions...
> 
> 1) I'm not familiar with CALL NOAUTO; please explain what 
> this does?  The
> 4.8 docs that Bob Stockler gave me in man page format don't 
> contain any
> reference to "noauto" (case insensitive grep yielded nothing).  I'm
> assuming it's a 5.0 or 5.6-ism.
> 

Ken's description is actually exact.  Can't do much better other than to
describe it this way. Imagine you have a huge AUTO table full of
variables... Regular, global, declared, two-character... The works....  And
you do a CALL "some_table"... Well you have to deal with these variables
according to the "rules" for each of them... On your CALL table.  However,
if you do CALL NOAUTO "sometable", the original AUTO table is replaced by a
BLANK one for the existence of that CALLED process.  When you return to the
CALLING table, the original AUTO processing is back in effect.


> 2) Possibly more importantly...  Let's say you're in file 
> "file1" and have
> a dummy variable "tn" defined in automatic processing.  Now, 
> let's say that
> somewhere in the input processing table, there's a CALL 
> "file2/specialtable".
> Is "tn" shared between file1's automatic and file2's 
> specialtable?  Or is
> the scope limited to only processing tables within file1?

No, the AUTO table is shared with the CALLED table.  (Again unless you do
'CALL NOAUTO "specialtable"', then as explained above there will be no AUTO
table and TN will be non-existent unless you bring it into existence on that
CALLED table.... It doesn't matter what file the CALLED table comes from,
the current file or some other file.


> 
> 3) Are dummy variables matching reserved operators valid?  
> Examples:  co,
> eq, gt, et, le, lt.  My recollection is that thoy -are- 
> valid, but I wanted
> to doublecheck.  And if they are valid, how does fP's parser go about
> detecting whether "gt" is greater than, or a field for a 
> grand total, for
> instance?  What's the methodology, placement within a 
> statement that is
> either within an argument list (as with MID(), for example), 
> or if one of
> those reserved combinations essentially -doesn't- fall between two
> "objects", then it's considered a dummy field, but if it's 
> not part of an
> argument list and it does fall between two "objects/clauses", 
> then it's
> considered an operator?  I'm imagining that detecting the 
> non-argument-list
> semantics is essentially done by breaking up the statement into its
> component clauses and then seeing if something falls in 
> position 1, 2, or
> 3...if it's in position 2, it's an operator, if not, it's a 
> dummy field.
> Is this even remotely a sane way to tell which something 
> is...assuming that
> dummies that match reserved operators are even valid?
> 

All the operators can be dummies.  GE, EQ, NE, etc.   As for how this is all
parsed, well that's the secret sauce... Isn't it! :-)

Seriously, Ken is just a genius and that's all there is to it. Really, there
are just lots of tables... You know of the various things filePro uses,
labels, selsets, keywords, operators, etc., etc. All of them have a place in
an order of precednce before (and I'm sure after) the dummy pool. Hell, it's
even more complicated by the later "long variable naming" isn't it... But as
the parser of each line is checked against the entire massive glot of
"stuff" it is easy to tell by position what:

    if: GE GE GE - EQ 

Means.  :-)

Did I actually use the word "easy" in that description...  And didn't you
like how deeply technical and thorough it was.  I especially liked my use of
the newly coined term "glot".  :-)   Sorry, Mark, I really can't help you on
the precise parser and compiler inter relation.  Only Ken or Ron could do
that... And maybe Ryan.  I'm not supposed to even have a copy of the source
code... And besides, the copy I have is is at the end of 4.5 and dawn of
4.8... Making it essentially useless.  I don't think I've even looked at it
twice in the past 10 years. 

Incidentally, I did not get it by hook or crook.  Ken was called in to a
client I had back way pre-millenium... And he had to put the source ona
local machine to run the whole debugger and such.  By some accident, he left
it deep in one of his temporary directories... Which he normally completely
removes.  I found it by accident.  Still, even without that, I was shown the
source code lots of time by various programmers at Small to demonstrate a
point or demo a new feature ... Or just to discuss some of what was being
implemented.  However, trying to understand the parser  and compiler of cabe
with that kind of incidental knowledge of the source would be like... Well,
I'll let you pull some really good analogy out of, well I'll let you pick
the place you pull it out of, too. :-)    Let's just say, I really can't
answer your 3rd question... And I doubt Ken will do much more than laugh at
this and move on to the next message. :-)

> Thanks in advance...

Your welcome... I tried....

John Esak