Ignore:
Timestamp:
2000-09-11T17:29:32+12:00 (24 years ago)
Author:
sjboddie
Message:

Changes to get compiling on VC++ and gcc

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/gsinstaller/registry.cpp

    r1475 r1536  
    33
    44bool registry_createkey(HKEY key, const char *name, PHKEY keyout)
    5 { LONG reply;
    6     DWORD disposition;
    7 
    8     reply = RegCreateKeyEx( key, name, NULL, NULL,
    9                                                 REG_OPTION_NON_VOLATILE,
    10                           KEY_ALL_ACCESS, NULL,
    11                           keyout, &disposition);
    12   if (reply != ERROR_SUCCESS)
    13   { return FALSE;
    14   }
     5{
     6  LONG reply;
     7  DWORD disposition;
     8
     9  reply = RegCreateKeyEx(key, name, 0, NULL,
     10             REG_OPTION_NON_VOLATILE,
     11             KEY_ALL_ACCESS, NULL,
     12             keyout, &disposition);
     13  if (reply != ERROR_SUCCESS)
     14    {
     15      return FALSE;
     16    }
    1517  return TRUE;
    1618}
    1719
    1820bool registry_openkey(HKEY key, const char *name, PHKEY keyout)
    19 { LONG reply;
    20 
    21     reply = RegOpenKeyEx(key, name, NULL, KEY_QUERY_VALUE, keyout);
    22   if (reply != ERROR_SUCCESS)
    23   { return false;
    24   }
     21{
     22  LONG reply;
     23
     24  reply = RegOpenKeyEx(key, name, 0, KEY_QUERY_VALUE, keyout);
     25  if (reply != ERROR_SUCCESS)
     26    {
     27      return false;
     28    }
    2529  return true;
    2630}
    2731
    2832bool registry_deletekey(HKEY key, const char *name)
    29 {   if (RegDeleteKey(key, name) != ERROR_SUCCESS)
    30     {   return false;
    31   }
     33{   
     34  if (RegDeleteKey(key, name) != ERROR_SUCCESS)
     35    {
     36      return false;
     37    }
    3238  return true;
    3339}
    3440
    3541bool registry_closekey(HKEY key)
    36 { LONG reply;
    37     reply = RegCloseKey(key);
    38   if (reply != ERROR_SUCCESS)
    39   { return FALSE;
     42{
     43  LONG reply;
     44  reply = RegCloseKey(key);
     45  if (reply != ERROR_SUCCESS)
     46  {
     47    return FALSE;
    4048  }
    4149  return TRUE;
    … …  
    4351
    4452bool registry_keyExists(HKEY key, const char *name)
    45 { HKEY local;
    46 
    47     if (!registry_openkey(key, name, &local))
    48   { return false;
     53{
     54  HKEY local;
     55 
     56  if (!registry_openkey(key, name, &local))
     57  {
     58    return false;
    4959  }
    5060  registry_closekey(local);
    … …  
    5363
    5464bool registry_ensureKeyExists(HKEY key, const char *name)
    55 { HKEY local;
    56 
    57     if (!registry_openkey(key, name, &local))
    58     {   if (!registry_createkey(key, name, &local))
    59     {   return false;
    60     }
    61   }
    62     registry_closekey(local);
     65{
     66  HKEY local;
     67
     68  if (!registry_openkey(key, name, &local))
     69    {
     70      if (!registry_createkey(key, name, &local))
     71    {
     72      return false;
     73    }
     74    }
     75  registry_closekey(local);
    6376  return true;
    6477}
    6578
    6679bool registry_deleteitem(HKEY key, const char *name)
    67 {   if (RegDeleteValue(key, name) != ERROR_SUCCESS)
    68     {   return false;
    69   }
     80{
     81  if (RegDeleteValue(key, name) != ERROR_SUCCESS)
     82    {
     83      return false;
     84    }
    7085  return true;
    7186}
    7287
    7388bool registry_setstring(HKEY key, const char *name, const char *value)
    74 { LONG reply;
    75 
    76     reply = RegSetValueEx(key, (LPCTSTR) name, NULL, REG_SZ, (CONST BYTE *) value, strlen(value) + 1);
    77   if (reply != ERROR_SUCCESS)
    78   { return false;
     89{
     90  LONG reply;
     91 
     92  reply = RegSetValueEx(key, (LPCTSTR) name, 0, REG_SZ, (CONST BYTE *) value, strlen(value) + 1);
     93  if (reply != ERROR_SUCCESS)
     94  {
     95    return false;
    7996  }
    8097  return true;
    … …  
    8299
    83100bool registry_setlong(HKEY key, char *name, LONG value)
    84 { LONG  reply;
    85     DWORD word;
    86 
     101{
     102  LONG  reply;
     103  DWORD word;
     104 
    87105  word = (DWORD) value;
    88     reply = RegSetValueEx(key, (LPCTSTR) name, NULL, REG_DWORD, (CONST BYTE *) &word, sizeof(DWORD));
    89   if (reply != ERROR_SUCCESS)
    90   { return FALSE;
     106  reply = RegSetValueEx(key, (LPCTSTR) name, 0, REG_DWORD, (CONST BYTE *) &word, sizeof(DWORD));
     107  if (reply != ERROR_SUCCESS)
     108  {
     109    return FALSE;
    91110  }
    92111  return TRUE;
    … …  
    94113
    95114bool registry_setblock(HKEY key, char *name, char *data, int size)
    96 { LONG  reply;
    97 
    98     reply = RegSetValueEx(key, name, NULL, REG_BINARY, (CONST BYTE *) data, size);
    99   if (reply != ERROR_SUCCESS)
    100   { // display_error();
    101     return FALSE;
     115{
     116  LONG  reply;
     117 
     118  reply = RegSetValueEx(key, name, 0, REG_BINARY, (CONST BYTE *) data, size);
     119  if (reply != ERROR_SUCCESS)
     120  {
     121    // display_error();
     122    return FALSE;
    102123  }
    103124  return TRUE;
    … …  
    105126
    106127bool registry_setint(HKEY key, char *name, int value)
    107 { return registry_setlong(key, name, (LONG) value);
     128{
     129  return registry_setlong(key, name, (LONG) value);
    108130}
    109131
    110132bool registry_getstring(HKEY key, char *name, char **string)
    111 { LONG reply;
    112     DWORD type;
     133{
     134  LONG reply;
     135  DWORD type;
    113136  DWORD size;
    114137  BYTE  buffer[128];
    … …  
    116139
    117140  do
    118   {
    119         reply = RegQueryValueEx(key, name, NULL, &type, buffer, &size);
    120     if (reply != ERROR_SUCCESS)
    121       { //display_error();
    122         //sprintf(buffer, "%x {%s}", key, name);
    123         //MessageBox(0, buffer, name, MB_OK);
    124       }
    125     tries ++;
    126   } while (reply != ERROR_SUCCESS && tries < 3);
    127 
    128   if (reply != ERROR_SUCCESS)
    129   { return FALSE;
     141    {
     142      reply = RegQueryValueEx(key, name, NULL, &type, buffer, &size);
     143      if (reply != ERROR_SUCCESS)
     144    {
     145      //display_error();
     146      //sprintf(buffer, "%x {%s}", key, name);
     147      //MessageBox(0, buffer, name, MB_OK);
     148    }
     149      tries ++;
     150    } while (reply != ERROR_SUCCESS && tries < 3);
     151 
     152  if (reply != ERROR_SUCCESS)
     153  {
     154    return FALSE;
    130155  }
    131156
    132157  *string = (char *) malloc(size);
    133158  if (*string == NULL)
    134   { return FALSE;
     159  {
     160    return FALSE;
    135161  }
    136162  strcpy(*string, (char *) buffer);
    … …  
    139165
    140166bool registry_getint(HKEY key, char *name, int *out)
    141 { DWORD type;
    142     DWORD size;
     167{
     168  DWORD type;
     169  DWORD size;
    143170  LONG  reply;
    144171
    145     reply = RegQueryValueEx(key, (LPTSTR) name, NULL, &type, (LPBYTE) out, &size);
    146   if (reply != ERROR_SUCCESS)
    147   { return FALSE;
     172  reply = RegQueryValueEx(key, (LPTSTR) name, NULL, &type, (LPBYTE) out, &size);
     173  if (reply != ERROR_SUCCESS)
     174  {
     175    return FALSE;
    148176  }
    149177  return TRUE;
    … …  
    151179
    152180bool registry_getlong(HKEY key, char *name, LONG *out)
    153 { DWORD type;
    154     DWORD size;
     181{
     182  DWORD type;
     183  DWORD size;
    155184  LONG  reply;
    156185  DWORD got;
    … …  
    158187  size = sizeof(DWORD);
    159188
    160     reply = RegQueryValueEx(key, name, NULL, &type, (LPBYTE) &got, &size);
    161   if (reply != ERROR_SUCCESS)
    162   { return FALSE;
     189  reply = RegQueryValueEx(key, name, NULL, &type, (LPBYTE) &got, &size);
     190  if (reply != ERROR_SUCCESS)
     191  {
     192    return FALSE;
    163193  }
    164194  *out = (LONG) got;
    … …  
    167197
    168198int registry_getblock(HKEY key, char *name, char *data, int size)
    169 { DWORD type;
    170     DWORD lsize;
     199{
     200  DWORD type;
     201  DWORD lsize;
    171202  LONG  reply;
    172 
     203 
    173204  lsize = size;
    174205
    175     reply = RegQueryValueEx(key, name, NULL, &type, (LPBYTE) data, &lsize);
    176   if (reply != ERROR_SUCCESS)
    177   { return -1;
     206  reply = RegQueryValueEx(key, name, NULL, &type, (LPBYTE) data, &lsize);
     207  if (reply != ERROR_SUCCESS)
     208  {
     209    return -1;
    178210  }
    179211  return lsize;
    … …  
    181213
    182214bool registry_fetchlong(char *keystr, LONG *lptr)
    183 { HKEY key;
    184 
    185     if (!registry_openkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
    186     { return FALSE;
    187   }
     215{
     216  HKEY key;
     217 
     218  if (!registry_openkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
     219    {
     220      return FALSE;
     221    }
    188222  if (!registry_getlong(key, keystr, lptr))
    189   { return FALSE;
    190   }
     223    {   
     224      return FALSE;
     225    }
    191226  if (registry_closekey(key) == FALSE)
    192   { return FALSE;
    193     }
     227  {
     228    return FALSE;
     229  }
    194230  return TRUE;
    195231}
    196232
    197233bool registry_fetchblock(char *keystr, char *data, int size)
    198 { HKEY  key;
    199     int     read;
    200 
    201     if (!registry_openkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
    202     { return FALSE;
    203   }
     234{
     235  HKEY key;
     236  int read;
     237
     238  if (!registry_openkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
     239    {
     240      return FALSE;
     241    }
    204242  read = registry_getblock(key, keystr, data, size);
    205243  if (read < 0)
    206   { return FALSE;
    207   }
     244    {   
     245      return FALSE;
     246    }
    208247  if (registry_closekey(key) == FALSE)
    209   { return FALSE;
    210     }
     248  {
     249    return FALSE;
     250  }
    211251  return TRUE;
    212252}
    213253
    214254bool registry_storelong(char *keystr, LONG value)
    215 { HKEY key;
    216 
    217     if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
    218   { return FALSE;
     255{
     256  HKEY key;
     257
     258  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
     259  {
     260    return FALSE;
    219261  }
    220262  if (!registry_setlong(key, keystr, value))
    221   { return FALSE;
     263  {
     264    return FALSE;
    222265  }
    223266  if (!registry_closekey(key))
    224   { return FALSE;
     267  {
     268    return FALSE;
    225269  }
    226270  return TRUE;
    … …  
    228272
    229273bool registry_storeint(char *keystr, int value)
    230 { HKEY key;
    231 
    232     if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
    233   { return FALSE;
     274{
     275  HKEY key;
     276 
     277  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
     278  {
     279    return FALSE;
    234280  }
    235281  if (!registry_setint(key, keystr, value))
    236   { return FALSE;
     282  {
     283    return FALSE;
    237284  }
    238285  if (!registry_closekey(key))
    239   { return FALSE;
     286  {
     287    return FALSE;
    240288  }
    241289  return TRUE;
    … …  
    243291
    244292bool registry_storeblock(char *keystr, char *data, int size)
    245 { HKEY key;
    246 
    247     if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
    248   { return FALSE;
     293{
     294  HKEY key;
     295
     296  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
     297  {
     298    return FALSE;
    249299  }
    250300  if (!registry_setblock(key, keystr, data, size))
    251   { return FALSE;
     301  {
     302    return FALSE;
    252303  }
    253304  if (!registry_closekey(key))
    254   { return FALSE;
     305  {
     306    return FALSE;
    255307  }
    256308  return TRUE;
    … …  
    258310
    259311bool registry_storestring(char *keystr, char *value)
    260 { HKEY key;
    261 
    262     if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
    263   { return FALSE;
     312{
     313  HKEY key;
     314 
     315  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
     316  {
     317    return FALSE;
    264318  }
    265319  if (!registry_setstring(key, keystr, value))
    266   { return FALSE;
     320  {
     321    return FALSE;
    267322  }
    268323  if (!registry_closekey(key))
    269   { return FALSE;
    270   }
    271   return TRUE;
    272 }
     324  {
     325    return FALSE;
     326  }
     327  return TRUE;
     328}
Note: See TracChangeset for help on using the changeset viewer.