That function namd indicates that it comes from the Access
Developer's Handbook.

What language are you working in that you don't have native registry
editing functions?

If you're programming *in* Access, then there's no need to declare
an Access API -- just use the VBA functions for writing to the
Registry.

Now, perhaps the ADH has extended functionality there, but I
strongly doubt they'd have declared a reference to the MSAccess
executable. That just makes absolutely no sense. Ah, yes, I see the
function you've quoted above referenced in the Access 2000 ADH on p.
1288 of the first volume.

The authors of the ADH have written their own registry functions to
get around limits to VBA's registry functions. The main reason they
give is that the VBA functions only have access to the CurrentUser
registry hive. But that's the only *correct* way to write to the
registry -- you shouldn't count on a user running Access under an
administrative logon which would give them permission to write to
LocalMachine hive, which is normally read-only for a user-level
Windows logon.

What you write above about the adhcHKEY_LOCAL_MACHINE makes no
sense. It's defined as a Long, so there should be no need for a # if
you use the literal value. And if you're using the ADH code, the
constant should be defined and you shouldn't have any problems using
it.

My guess is that there's a difference in the permissions on the A2K
registry keys vs. the A2K3 registry keys under the LocalMachine
hive, and the A2K keys are user-writable while the A2K3 keys are
not.

So, this isn't a code problem, but a registry permissions problem,
seems to me.

Actually, just pulling up the code from the ADH CD, it appears that
you were using some kind of vastly altered version of the code, as
there is no function definition in the code for adh_accRegWriteVal.
There is just an elaborate custom function. The declaration you
quoted with Declare Function adh_accRegWriteVal Lib "msaccess.exe"
Alias "#71" is not found in the original ADH code, and really
doesn't make any sense to me at all. There *are* such msaccess.exe
function declarations in other modules of the sample CD, but none of
them has Alias #71. Perhaps that reference is from one of the other
ADH chapters. It certainly doesn't have anything to do with the ADH
registry functions, though.

I would suggest you study the reason for these registry writes.
Speculating I think it is saving the X,Y location of some object,
perhaps a form. Such coordinates should probably be user-specific: I
want my form here while you want it there.  If that is the case, all
this code can be replaced by simple calls to the built-in VBA
functions GetSetting and SaveSetting, which save to HKCU. They work in
any version of Access.

-Tom.

Take a look at this site: http://www.allapi.net/

Piter

MSAccess was not created with the notion that its functions would be
called in the method you are suggesting. Many Windows functions are.
This is because Windows is an OS. Applications do their things by
calling OS functions, a basic understanding of programming that many or
most discussions, classes and textbooks ignore.
To use MSAccess functions one would have to find an entry point. And
then one would have to find some documentation for parameters, types
and return values. TTBOMK this documentation is not public. Its
possible that parameters would be of such types that they could not be
emulated in VBA. And its possible that misuse of  these functions could
result in massive damage to one's database and perhaps many of the
programs on the machine where the attempt is made.
The task you are describing is most unusual and difficult. If it were
attempted by an eperienced and resourceful programmer of VBA and C+ it
would be challenging. You will know if it's appropriate for you, but
one guess that since you are not familiar with the fundamentals of
using the Windows API, it is not.
If you are a genius, I suggest you work your way through your problem
and astound us with your solution. If not, I suggest you content
yourself with simple  questions such as, "How can I write a value to
the Registry?"