Cuestión : Registro, Winlogon, errores de KEY_WOW64_64KEY

¡Esto me está conduciendo NUTS!

In Windows 7 x64 que necesito cambiar, programatically, la cáscara de Windows de mi uso, de nuevo a explorador, entonces de nuevo los míos. Si usted quiere un explination en cuanto a porqué apenas ask.

Anyway: Quiero básicamente abrir esta llave: class= " lineNumbers " >
1 del >

HKLM \ SOFTWARE \ Microsoft codeBody \ Windows NT \ CurrentVersion \ Winlogon del " prettyprint " del class= del id= " codeSnippet751631 " del >


I de 
1 del >

:
2:
3:
4:
5:
el >With codeBody TRegistry.Create del " prettyprint " del class= del id= " codeSnippet735020 " del >


But de 
1 del >
HKEY_LOCAL_MACHINE \ SOFTWARE \ Wow6432Node \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon
class= >

So de 

Any? 


  
  class= del

Respuesta : Registro, Winlogon, errores de KEY_WOW64_64KEY

Hola,

Tenía este problema también… así que con algunas modificaciones y usar otra manera de tener acceso al registro de Windows (no usar Registry.pas) he hecho sin problemas…

El código abajo es un reemplazo del litghtweight para Registry.pas con modificaciones al trabajo con las banderas de KEY_WOW64_64KEY/KEY_WOW64_32KEY

Uso básico en su caso

Determinación de su programa como Shell
[código] WinRegSetString (HKEY_LOCAL_MACHINE, “SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell”, “YourProgram.exe”, verdad); [/code]

si usted pone un “Blackslash” en la llave como (“SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell \ ") creará una nueva “llave” Shell llamado… sin blackslash que tendrá acceso a un valor llamado Shell… iguales para todas las funciones

Volver a Windows Shell
[código] WinRegSetString (HKEY_LOCAL_MACHINE, “SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell”, “Explorer.exe”, verdad); [/code]

Lectura de la cáscara actual
[código] var
 szBuff: Secuencia;
comenzar
 WinRegGetString (HKEY_LOCAL_MACHINE, “SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell”, szBuff, verdad);
  ShowMessage (““” + szBuff + ““"); [/code]

¡Esperanza él ayuda usted!
Respetos,
Carlos

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:

unidad UTILS_Reg;

interfaz

aplicaciones
  Windows,
  SysUtils,
  Clases;

  función WinRegConnect (MachineName: Secuencia; RootKey: HKEY; var RemoteKey: HKEY): boleano;
  función WinRegDisconnect (RemoteKey: HKEY): boleano;
  función WinRegValueExists (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
  función WinRegGetValueType (RootKey: HKEY; Nombre: Secuencia; valor del var: Cardinal; Wow64: Boleano): boleano;
  función WinRegKeyExists (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
  función WinRegDelValue (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
  función WinRegDelKey (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
  función WinRegEnum (hRootKey: HKEY; szKey: Secuencia; Almacenador intermediario: TStringList; bKeys: Boleano; Wow64: Boleano): Boleano;
  función WinRegSetString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
  función WinRegSetMultiString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
  función WinRegSetExpandString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
  función WinRegSetDword (RootKey: HKEY; Nombre: Secuencia; Valor: Cardinal; Wow64: Boleano): boleano;
  función WinRegSetBinary (RootKey: HKEY; Nombre: Secuencia; Valor: Arsenal del octeto; Wow64: Boleano): boleano;
  función WinRegGetString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
  función WinRegGetMultiString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
  función WinRegGetExpandString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
  función WinRegGetDWORD (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Cardinal; Wow64: Boleano): boleano;
  función WinRegGetBinary (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
  función Binary2DateTime (RootKey: HKEY; Nombre: Secuencia; valor del var: TDateTime; Wow64: Boleano): Boleano;
  función DateTime2Binary (RootKey: HKEY; Nombre: Secuencia; valor del var: TDateTime; Wow64: Boleano): Boleano;
  función Binary2Integer (RootKey: HKEY; Nombre: Secuencia; valor del var: Número entero; Wow64: Boleano): Boleano;
  función Integer2Binary (RootKey: HKEY; Nombre: Secuencia; valor del var: Número entero; Wow64: Boleano): Boleano;

puesta en práctica

función IsWow64: Boleano;
tipo
  TIsWow64Process = función (tipo de // de IsWow64Process API fn
    Manija: Windows.THandle; var Res: Windows.BOOL
  ): Windows.BOOL; stdcall;
var
  IsWow64Result: Windows.BOOL;      Resultado de // de IsWow64Process
  IsWow64Process: TIsWow64Process;  Referencia de // IsWow64Process fn
comenzar
  Intento de // para cargar la función required de kernel32
  IsWow64Process: = Windows.GetProcAddress (
    Windows.GetModuleHandle (“kernel32.dll "), “IsWow64Process”
  );
  si entonces está asignado (IsWow64Process)
  comenzar
    Se ejecuta la función de //: llamarla
    si no IsWow64Process (
      Windows.GetCurrentProcess, IsWow64Result
    ) entonces
      aumento SysUtils.Exception.Create (“IsWow64: mala manija de proceso ");
    Resultado de vuelta de // de la función
    Resultado: = IsWow64Result;
  extremo
  
    Función de // no ejecutada: no puede funcionar en Wow64
    Resultado: = falso;
extremo;

función Binary2DateTime (RootKey: HKEY; Nombre: Secuencia; valor del var: TDateTime; Wow64: Boleano): Boleano;
var
  dtBuff: TDateTime;
  dtBytes: arsenal [1..8] de dtBuff del absoluto del octeto;
  szBin: secuencia;
  i: número entero;
comenzar
  Resultado: = WinRegGetBinary (RootKey, nombre, szBin, Wow64);

  si resultado entonces
  Resultado: = longitud (szBin) = 8;

  si resultado entonces
  comenzar
    para i: = 1 a 8 hace
    dtBytes [i]: = ord (szBin [i]);
    Valor: = dtBuff;
  extremo;
extremo;

función DateTime2Binary (RootKey: HKEY; Nombre: Secuencia; valor del var: TDateTime; Wow64: Boleano): Boleano;
var
  dtBuff: TDateTime;
  dtBytes: arsenal [1..8] de dtBuff del absoluto del octeto;
comenzar
  dtBuff: = valor;
  Resultado: = WinRegSetBinary (RootKey, nombre, dtBytes, Wow64);
extremo;

función Binary2Integer (RootKey: HKEY; Nombre: Secuencia; valor del var: Número entero; Wow64: Boleano): Boleano;
var
  iBuff: Número entero;
  dtBytes: arsenal [1..4] de iBuff del absoluto del octeto;
  szBin: secuencia;
  i: número entero;
comenzar
  Resultado: = WinRegGetBinary (RootKey, nombre, szBin, Wow64);

  si resultado entonces
  Resultado: = longitud (szBin) = 4;

  si resultado entonces
  comenzar
    para i: = 1 a 4 hace
    dtBytes [i]: = ord (szBin [i]);
    Valor: = iBuff;
  extremo;
extremo;

función Integer2Binary (RootKey: HKEY; Nombre: Secuencia; valor del var: Número entero; Wow64: Boleano): Boleano;
var
  iBuff: Número entero;
  dtBytes: arsenal [1..4] de iBuff del absoluto del octeto;
comenzar
  iBuff: = valor;
  Resultado: = WinRegSetBinary (RootKey, nombre, dtBytes, Wow64);
extremo;

función LastPos (aguja: Carbón de leña; Haystack: Secuencia): número entero;
comenzar
  para el resultado: = el downto 1 de la longitud (Haystack) hace
  si Haystack [resultado] = aguja entonces
  Rotura;
extremo;

función WinRegConnect (MachineName: Secuencia; RootKey: HKEY; var RemoteKey: HKEY): boleano;
comenzar
  Resultado: = (RegConnectRegistry (PChar (MachineName), RootKey, RemoteKey) = ERROR_SUCCESS);
extremo;

función WinRegDisconnect (RemoteKey: HKEY): boleano;
comenzar
  Resultado: = (RegCloseKey (RemoteKey) = ERROR_SUCCESS);
extremo;

función RegSetValue (RootKey: HKEY; Nombre: Secuencia; ValType: Cardinal; PVal: Indicador; ValSize: Cardinal; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  dispo: DWORD;
  hTemp: HKEY;
  bSuccess: Boleano;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_WRITE o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_WRITE o KEY_WOW64_32KEY 
    _hKey: = KEY_WRITE;

    bSuccess: = RegCreateKeyEx (RootKey, PChar (SubKey), 0, nada, REG_OPTION_NON_VOLATILE, _hKey, nada, hTemp, @dispo) = ERROR_SUCCESS;

    si bSuccess entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      Resultado: = (RegSetValueEx (hTemp, PChar (SubKey), 0, ValType, PVal, ValSize) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función RegGetValue (RootKey: HKEY; Nombre: Secuencia; ValType: Cardinal; var PVal: Indicador;
  var ValSize: Cardinal; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  MyValType: DWORD;
  hTemp: HKEY;
  Buf: Indicador;
  BufSize: Cardinal;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_READ o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_READ o KEY_WOW64_32KEY 
    _hKey: = KEY_READ;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      si RegQueryValueEx (el hTemp, PChar (SubKey), nada, @MyValType, nada, @BufSize) = ERROR_SUCCESS entonces
      comenzar
        GetMem (Buf, BufSize);
        si RegQueryValueEx (el hTemp, PChar (SubKey), nada, @MyValType, Buf, @BufSize) = ERROR_SUCCESS entonces
        comenzar
          si ValType = MyValType después
          comenzar
            PVal: = Buf;
            ValSize: = BufSize;
            Resultado: = verdad;
          extremo
          
          FreeMem (Buf);
        extremo
        
        FreeMem (Buf);
      extremo;
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegValueExists (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  hTemp: HKEY;
  _hKey: Manilla en forma de T;
comenzar
  Resultado: = falso;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_READ o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_READ o KEY_WOW64_32KEY 
    _hKey: = KEY_READ;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      Resultado: = (RegQueryValueEx (hTemp, PChar (SubKey), nada, nada, nada, nada) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegGetValueType (RootKey: HKEY; Nombre: Secuencia; valor del var: Cardinal; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  hTemp: HKEY;
  ValType: Cardinal;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  Valor: = REG_NONE;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_READ o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_READ o KEY_WOW64_32KEY 
    _hKey: = KEY_READ;

    si (RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS) entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      Resultado: = (RegQueryValueEx (hTemp, PChar (SubKey), nada, @ValType, nada, nada) = ERROR_SUCCESS);
      si resultado entonces
      Valor: = ValType;
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegKeyExists (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  hTemp: HKEY;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_READ o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_READ o KEY_WOW64_32KEY 
    _hKey: = KEY_READ;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
    comenzar
      Resultado: = verdad;
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegDelValue (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  hTemp: HKEY;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_WRITE o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_WRITE o KEY_WOW64_32KEY 
    _hKey: = KEY_WRITE;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      Resultado: = (RegDeleteValue (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegDelKey (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  hTemp: HKEY;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_WRITE o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_WRITE o KEY_WOW64_32KEY 
    _hKey: = KEY_WRITE;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      Resultado: = (RegDeleteKey (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegEnum (hRootKey: HKEY; szKey: Secuencia; Almacenador intermediario: TStringList; bKeys: Boleano; Wow64: Boleano): Boleano;
var
  i: número entero;
  iras: número entero;
  s: Secuencia;
  hTemp: HKEY;
  Buf: Indicador;
  BufSize: Cardinal;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  Buffer.Clear;

  si Wow64 e IsWow64 entonces
  _hKey: = KEY_READ o KEY_WOW64_64KEY 
  si IsWow64 y no Wow64 después
  _hKey: = KEY_READ o KEY_WOW64_32KEY 
  _hKey: = KEY_READ;

  si RegOpenKeyEx (hRootKey, PChar (szKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
  comenzar
    Resultado: = verdad;
    BufSize: = 1024;
    GetMem (buf, BufSize);
    i: = 0;
    iras: = ERROR_SUCCESS;
    mientras que hacen las iras = ERROR_SUCCESS
    comenzar
      BufSize: = 1024;
      si bKeys entonces
        iras: = RegEnumKeyEx (hTemp, i, buf, BufSize, nada, nada, nada, nada)
      
        iras: = RegEnumValue (hTemp, i, buf, BufSize, nada, nada, nada, nada);
      si iras = ERROR_SUCCESS después
      comenzar
        SetLength (s, BufSize);
        CopyMemory (@s [1], buf, BufSize);
        Buffer.Add;
        inc. (i);
      extremo;
    extremo;
    FreeMem (buf);
    RegCloseKey (hTemp);
  extremo;
extremo;

función WinRegSetString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
comenzar
  Resultado: = RegSetValue (RootKey, nombre, REG_SZ, PChar (valor + #0), longitud (valor) + 1, Wow64);
extremo;

función WinRegSetMultiString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
comenzar
  Resultado: = RegSetValue (RootKey, nombre, REG_MULTI_SZ, PChar (valor + #0#0), longitud (valor) + 2, Wow64);
extremo;

función WinRegSetExpandString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
comenzar
  Resultado: = RegSetValue (RootKey, nombre, REG_EXPAND_SZ, PChar (valor + #0), longitud (valor) + 1, Wow64);
extremo;

función WinRegSetDword (RootKey: HKEY; Nombre: Secuencia; Valor: Cardinal; Wow64: Boleano): boleano;
comenzar
  Resultado: = RegSetValue (RootKey, nombre, REG_DWORD, @Value, SizeOf (cardinal), Wow64);
extremo;

función WinRegSetBinary (RootKey: HKEY; Nombre: Secuencia; Valor: Arsenal del octeto; Wow64: Boleano): boleano;
comenzar
  Resultado: = RegSetValue (RootKey, nombre, REG_BINARY, @Value, SizeOf (valor), Wow64);
extremo;

función WinRegGetString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
var
  Buf: Indicador;
  BufSize: Cardinal;
comenzar
  Resultado: = falso;
  si RegGetValue (RootKey, nombre, REG_SZ, Buf, BufSize, Wow64) entonces
  comenzar
    Diciembre (BufSize);
    SetLength (valor, BufSize);
    si BufSize > 0 entonces
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = verdad;
  extremo;
extremo;

función WinRegGetMultiString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
var
  Buf: Indicador;
  BufSize: Cardinal;
comenzar
  Resultado: = falso;
  si RegGetValue (RootKey, nombre, REG_MULTI_SZ, Buf, BufSize, Wow64) entonces
  comenzar
    Diciembre (BufSize);
    SetLength (valor, BufSize);
    si BufSize > 0 entonces
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = verdad;
  extremo;
extremo;

función WinRegGetExpandString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
var
  Buf: Indicador;
  BufSize: Cardinal;
comenzar
  Resultado: = falso;
  si RegGetValue (RootKey, nombre, REG_EXPAND_SZ, Buf, BufSize, Wow64) entonces
  comenzar
    Diciembre (BufSize);
    SetLength (valor, BufSize);
    si BufSize > 0 entonces
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = verdad;
  extremo;
extremo;

función WinRegGetDWORD (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Cardinal; Wow64: Boleano): boleano;
var
  Buf: Indicador;
  BufSize: Cardinal;
comenzar
  Resultado: = falso;
  si RegGetValue (RootKey, nombre, REG_DWORD, Buf, BufSize, Wow64) entonces
  comenzar
    CopyMemory (@Value, Buf, BufSize);
    FreeMem (Buf);
    Resultado: = verdad;
  extremo;
extremo;

función WinRegGetBinary (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
var
  Buf: Indicador;
  BufSize: Cardinal;
comenzar
  Resultado: = falso;
  si RegGetValue (RootKey, nombre, REG_BINARY, Buf, BufSize, Wow64) entonces
  comenzar
    SetLength (valor, BufSize);
    CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = verdad;
  extremo;
extremo;

extremo.
Otras soluciones  
 
programming4us programming4us