Is const really that much better than value?

Hi Chaps,

Quick question - when passing a variable value to a subprocedure, and the
passed variable does not have the same length/precision as that defined on
the prototype, what is the real difference between passing it by constant
reference or by value? Why choose one over the other? For passing long
strings by constant reference and options(*varsize) is not used then doesn't
the OS simply copy the variable to a temporary field anyway if the variable
length does not match the prototype definition? Isn't this the same as
passing by value in all real respects?

I mean, when parameters are passed to a subprocedure the OS passes an array
of pointers together with operational descriptors doesn't it? for passing by
value the pointers will point to temporary variables containing copies of
the original data. These are cast/padded/truncated accordingly. When passing
by constant reference doesn't the OS also do this if the original variable
definition does not exactly match that on the prototype? This is why we can
pass zoned fields even though the prototype defines a packed parm, etc.

I guess I'm basicaly asking - in this scenario is there any real performance
reason for passing a long string by constant reference over passing it by
value? Do we only get a performance gain when we have an exact match and a
temporary field is not necessary when passing by constant reference? (I must
stress thet I'm talking about scenarios when options(*varsize) and/or opdesc
are NOT used).

I'm very interested to know the mechanics behind this so I can make the
right design choices. If I have it all wrong then I'd rather know now. :-)

Cheers

Larry Ducie