src/xkbcomp/keycodes.c

   1 /************************************************************
   2  * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
   3  *
   4  * Permission to use, copy, modify, and distribute this
   5  * software and its documentation for any purpose and without
   6  * fee is hereby granted, provided that the above copyright
   7  * notice appear in all copies and that both that copyright
   8  * notice and this permission notice appear in supporting
   9  * documentation, and that the name of Silicon Graphics not be
  10  * used in advertising or publicity pertaining to distribution
  11  * of the software without specific prior written permission.
  12  * Silicon Graphics makes no representation about the suitability
  13  * of this software for any purpose. It is provided "as is"
  14  * without any express or implied warranty.
  15  *
  16  * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18  * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  19  * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  20  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  22  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  23  * THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24  *
  25  ********************************************************/
  26
  27 #include "config.h"
  28
  29 #include "xkbcomp-priv.h"
  30 #include "text.h"
  31 #include "expr.h"
  32 #include "include.h"
  33
  34 typedef struct {
  35     enum merge_mode merge;
  36
  37     xkb_atom_t alias;
  38     xkb_atom_t real;
  39 } AliasInfo;
  40
  41 typedef struct {
  42     enum merge_mode merge;
  43
  44     xkb_atom_t name;
  45 } LedNameInfo;
  46
  47 typedef struct {
  48     char *name;
  49     int errorCount;
  50
  51     xkb_keycode_t min_key_code;
  52     xkb_keycode_t max_key_code;
  53     darray(xkb_atom_t) key_names;
  54     LedNameInfo led_names[XKB_MAX_LEDS];
  55     unsigned int num_led_names;
  56     darray(AliasInfo) aliases;
  57
  58     struct xkb_context *ctx;
  59 } KeyNamesInfo;
  60
  61 /***====================================================================***/
  62
  63 static void
  64 InitAliasInfo(AliasInfo *info, enum merge_mode merge,
  65               xkb_atom_t alias, xkb_atom_t real)
  66 {
  67     memset(info, 0, sizeof(*info));
  68     info->merge = merge;
  69     info->alias = alias;
  70     info->real = real;
  71 }
  72
  73 static LedNameInfo *
  74 FindLedByName(KeyNamesInfo *info, xkb_atom_t name,
  75               xkb_led_index_t *idx_out)
  76 {
  77     for (xkb_led_index_t idx = 0; idx < info->num_led_names; idx++) {
  78         LedNameInfo *ledi = &info->led_names[idx];
  79         if (ledi->name == name) {
  80             *idx_out = idx;
  81             return ledi;
  82         }
  83     }
  84
  85     return NULL;
  86 }
  87
  88 static bool
  89 AddLedName(KeyNamesInfo *info, enum merge_mode merge, bool same_file,
  90            LedNameInfo *new, xkb_led_index_t new_idx)
  91 {
  92     xkb_led_index_t old_idx;
  93     LedNameInfo *old;
  94     const int verbosity = xkb_context_get_log_verbosity(info->ctx);
  95     const bool report = (same_file && verbosity > 0) || verbosity > 9;
  96     const bool replace = (merge == MERGE_REPLACE || merge == MERGE_OVERRIDE);
  97
  98     /* LED with the same name already exists. */
  99     old = FindLedByName(info, new->name, &old_idx);
 100     if (old) {
 101         if (old_idx == new_idx) {
 102             log_warn(info->ctx,
 103                      "Multiple indicators named \"%s\"; "
 104                      "Identical definitions ignored\n",
 105                      xkb_atom_text(info->ctx, new->name));
 106             return true;
 107         }
 108
 109         if (report) {
 110             xkb_led_index_t use = (replace ? new_idx + 1 : old_idx + 1);
 111             xkb_led_index_t ignore = (replace ? old_idx + 1 : new_idx + 1);
 112             log_warn(info->ctx,
 113                      "Multiple indicators named %s; Using %d, ignoring %d\n",
 114                      xkb_atom_text(info->ctx, new->name), use, ignore);
 115         }
 116
 117         if (replace)
 118             *old = *new;
 119
 120         return true;
 121     }
 122
 123     if (new_idx >= info->num_led_names)
 124         info->num_led_names = new_idx + 1;
 125
 126     /* LED with the same index already exists. */
 127     old = &info->led_names[new_idx];
 128     if (old->name != XKB_ATOM_NONE) {
 129         if (report) {
 130             const xkb_atom_t use = (replace ? new->name : old->name);
 131             const xkb_atom_t ignore = (replace ? old->name : new->name);
 132             log_warn(info->ctx, "Multiple names for indicator %d; "
 133                      "Using %s, ignoring %s\n", new_idx + 1,
 134                      xkb_atom_text(info->ctx, use),
 135                      xkb_atom_text(info->ctx, ignore));
 136         }
 137
 138         if (replace)
 139             *old = *new;
 140
 141         return true;
 142     }
 143
 144     *old = *new;
 145     return true;
 146 }
 147
 148 static void
 149 ClearKeyNamesInfo(KeyNamesInfo *info)
 150 {
 151     free(info->name);
 152     darray_free(info->key_names);
 153     darray_free(info->aliases);
 154 }
 155
 156 static void
 157 InitKeyNamesInfo(KeyNamesInfo *info, struct xkb_context *ctx)
 158 {
 159     memset(info, 0, sizeof(*info));
 160     info->ctx = ctx;
 161     info->min_key_code = XKB_KEYCODE_INVALID;
 162 #if XKB_KEYCODE_INVALID < XKB_KEYCODE_MAX
 163 #error "Hey, you can't be changing stuff like that."
 164 #endif
 165 }
 166
 167 static xkb_keycode_t
 168 FindKeyByName(KeyNamesInfo *info, xkb_atom_t name)
 169 {
 170     xkb_keycode_t i;
 171
 172     for (i = info->min_key_code; i <= info->max_key_code; i++)
 173         if (darray_item(info->key_names, i) == name)
 174             return i;
 175
 176     return XKB_KEYCODE_INVALID;
 177 }
 178
 179 static bool
 180 AddKeyName(KeyNamesInfo *info, xkb_keycode_t kc, xkb_atom_t name,
 181            enum merge_mode merge, bool same_file, bool report)
 182 {
 183     xkb_atom_t old_name;
 184     xkb_keycode_t old_kc;
 185     const int verbosity = xkb_context_get_log_verbosity(info->ctx);
 186
 187     report = report && ((same_file && verbosity > 0) || verbosity > 7);
 188
 189     if (kc >= darray_size(info->key_names))
 190         darray_resize0(info->key_names, kc + 1);
 191
 192     info->min_key_code = MIN(info->min_key_code, kc);
 193     info->max_key_code = MAX(info->max_key_code, kc);
 194
 195     /* There's already a key with this keycode. */
 196     old_name = darray_item(info->key_names, kc);
 197     if (old_name != XKB_ATOM_NONE) {
 198         const char *lname = KeyNameText(info->ctx, old_name);
 199         const char *kname = KeyNameText(info->ctx, name);
 200
 201         if (old_name == name) {
 202             if (report)
 203                 log_warn(info->ctx,
 204                          "Multiple identical key name definitions; "
 205                          "Later occurrences of \"%s = %d\" ignored\n",
 206                          lname, kc);
 207             return true;
 208         }
 209         else if (merge == MERGE_AUGMENT) {
 210             if (report)
 211                 log_warn(info->ctx,
 212                          "Multiple names for keycode %d; "
 213                          "Using %s, ignoring %s\n", kc, lname, kname);
 214             return true;
 215         }
 216         else {
 217             if (report)
 218                 log_warn(info->ctx,
 219                          "Multiple names for keycode %d; "
 220                          "Using %s, ignoring %s\n", kc, kname, lname);
 221             darray_item(info->key_names, kc) = XKB_ATOM_NONE;
 222         }
 223     }
 224
 225     /* There's already a key with this name. */
 226     old_kc = FindKeyByName(info, name);
 227     if (old_kc != XKB_KEYCODE_INVALID && old_kc != kc) {
 228         const char *kname = KeyNameText(info->ctx, name);
 229
 230         if (merge == MERGE_OVERRIDE) {
 231             darray_item(info->key_names, old_kc) = XKB_ATOM_NONE;
 232             if (report)
 233                 log_warn_with_code(info->ctx,
 234                          XKB_WARNING_CONFLICTING_KEY_NAME,
 235                          "Key name %s assigned to multiple keys; "
 236                          "Using %d, ignoring %d\n", kname, kc, old_kc);
 237         }
 238         else {
 239             if (report)
 240                 log_vrb(info->ctx, 3,
 241                         XKB_WARNING_CONFLICTING_KEY_NAME,
 242                         "Key name %s assigned to multiple keys; "
 243                         "Using %d, ignoring %d\n", kname, old_kc, kc);
 244             return true;
 245         }
 246     }
 247
 248     darray_item(info->key_names, kc) = name;
 249     return true;
 250 }
 251
 252 /***====================================================================***/
 253
 254 static bool
 255 HandleAliasDef(KeyNamesInfo *info, KeyAliasDef *def, enum merge_mode merge);
 256
 257 static void
 258 MergeIncludedKeycodes(KeyNamesInfo *into, KeyNamesInfo *from,
 259                       enum merge_mode merge)
 260 {
 261     if (from->errorCount > 0) {
 262         into->errorCount += from->errorCount;
 263         return;
 264     }
 265
 266     if (into->name == NULL) {
 267         into->name = from->name;
 268         from->name = NULL;
 269     }
 270
 271     /* Merge key names. */
 272     if (darray_empty(into->key_names)) {
 273         into->key_names = from->key_names;
 274         darray_init(from->key_names);
 275         into->min_key_code = from->min_key_code;
 276         into->max_key_code = from->max_key_code;
 277     }
 278     else {
 279         if (darray_size(into->key_names) < darray_size(from->key_names))
 280             darray_resize0(into->key_names, darray_size(from->key_names));
 281
 282         for (unsigned i = from->min_key_code; i <= from->max_key_code; i++) {
 283             xkb_atom_t name = darray_item(from->key_names, i);
 284             if (name == XKB_ATOM_NONE)
 285                 continue;
 286
 287             if (!AddKeyName(into, i, name, merge, true, false))
 288                 into->errorCount++;
 289         }
 290     }
 291
 292     /* Merge key aliases. */
 293     if (darray_empty(into->aliases)) {
 294         into->aliases = from->aliases;
 295         darray_init(from->aliases);
 296     }
 297     else {
 298         AliasInfo *alias;
 299
 300         darray_foreach(alias, from->aliases) {
 301             KeyAliasDef def;
 302
 303             def.merge = (merge == MERGE_DEFAULT ? alias->merge : merge);
 304             def.alias = alias->alias;
 305             def.real = alias->real;
 306
 307             if (!HandleAliasDef(into, &def, def.merge))
 308                 into->errorCount++;
 309         }
 310     }
 311
 312     /* Merge LED names. */
 313     if (into->num_led_names == 0) {
 314         memcpy(into->led_names, from->led_names,
 315                sizeof(*from->led_names) * from->num_led_names);
 316         into->num_led_names = from->num_led_names;
 317         from->num_led_names = 0;
 318     }
 319     else {
 320         for (xkb_led_index_t idx = 0; idx < from->num_led_names; idx++) {
 321             LedNameInfo *ledi = &from->led_names[idx];
 322
 323             if (ledi->name == XKB_ATOM_NONE)
 324                 continue;
 325
 326             ledi->merge = (merge == MERGE_DEFAULT ? ledi->merge : merge);
 327             if (!AddLedName(into, ledi->merge, false, ledi, idx))
 328                 into->errorCount++;
 329         }
 330     }
 331 }
 332
 333 static void
 334 HandleKeycodesFile(KeyNamesInfo *info, XkbFile *file, enum merge_mode merge);
 335
 336 static bool
 337 HandleIncludeKeycodes(KeyNamesInfo *info, IncludeStmt *include)
 338 {
 339     KeyNamesInfo included;
 340
 341     InitKeyNamesInfo(&included, info->ctx);
 342     included.name = include->stmt;
 343     include->stmt = NULL;
 344
 345     for (IncludeStmt *stmt = include; stmt; stmt = stmt->next_incl) {
 346         KeyNamesInfo next_incl;
 347         XkbFile *file;
 348
 349         file = ProcessIncludeFile(info->ctx, stmt, FILE_TYPE_KEYCODES);
 350         if (!file) {
 351             info->errorCount += 10;
 352             ClearKeyNamesInfo(&included);
 353             return false;
 354         }
 355
 356         InitKeyNamesInfo(&next_incl, info->ctx);
 357
 358         HandleKeycodesFile(&next_incl, file, MERGE_OVERRIDE);
 359
 360         MergeIncludedKeycodes(&included, &next_incl, stmt->merge);
 361
 362         ClearKeyNamesInfo(&next_incl);
 363         FreeXkbFile(file);
 364     }
 365
 366     MergeIncludedKeycodes(info, &included, include->merge);
 367     ClearKeyNamesInfo(&included);
 368
 369     return (info->errorCount == 0);
 370 }
 371
 372 static bool
 373 HandleKeycodeDef(KeyNamesInfo *info, KeycodeDef *stmt, enum merge_mode merge)
 374 {
 375     if (stmt->merge != MERGE_DEFAULT) {
 376         if (stmt->merge == MERGE_REPLACE)
 377             merge = MERGE_OVERRIDE;
 378         else
 379             merge = stmt->merge;
 380     }
 381
 382     if (stmt->value < 0 || stmt->value > XKB_KEYCODE_MAX) {
 383         log_err(info->ctx,
 384                 "Illegal keycode %lld: must be between 0..%u; "
 385                 "Key ignored\n", (long long) stmt->value, XKB_KEYCODE_MAX);
 386         return false;
 387     }
 388
 389     return AddKeyName(info, (xkb_keycode_t) stmt->value,
 390                       stmt->name, merge, false, true);
 391 }
 392
 393 static bool
 394 HandleAliasDef(KeyNamesInfo *info, KeyAliasDef *def, enum merge_mode merge)
 395 {
 396     AliasInfo *old, new;
 397
 398     darray_foreach(old, info->aliases) {
 399         if (old->alias == def->alias) {
 400             if (def->real == old->real) {
 401                 log_vrb(info->ctx, 1,
 402                         XKB_WARNING_CONFLICTING_KEY_NAME,
 403                         "Alias of %s for %s declared more than once; "
 404                         "First definition ignored\n",
 405                         KeyNameText(info->ctx, def->alias),
 406                         KeyNameText(info->ctx, def->real));
 407             }
 408             else {
 409                 xkb_atom_t use, ignore;
 410
 411                 use = (merge == MERGE_AUGMENT ? old->real : def->real);
 412                 ignore = (merge == MERGE_AUGMENT ? def->real : old->real);
 413
 414                 log_warn_with_code(info->ctx,
 415                          XKB_WARNING_CONFLICTING_KEY_NAME,
 416                          "Multiple definitions for alias %s; "
 417                          "Using %s, ignoring %s\n",
 418                          KeyNameText(info->ctx, old->alias),
 419                          KeyNameText(info->ctx, use),
 420                          KeyNameText(info->ctx, ignore));
 421
 422                 old->real = use;
 423             }
 424
 425             old->merge = merge;
 426             return true;
 427         }
 428     }
 429
 430     InitAliasInfo(&new, merge, def->alias, def->real);
 431     darray_append(info->aliases, new);
 432     return true;
 433 }
 434
 435 static bool
 436 HandleKeyNameVar(KeyNamesInfo *info, VarDef *stmt)
 437 {
 438     const char *elem, *field;
 439     ExprDef *arrayNdx;
 440
 441     if (!ExprResolveLhs(info->ctx, stmt->name, &elem, &field, &arrayNdx))
 442         return false;
 443
 444     if (elem) {
 445         log_err(info->ctx, "Unknown element %s encountered; "
 446                 "Default for field %s ignored\n", elem, field);
 447         return false;
 448     }
 449
 450     if (!istreq(field, "minimum") && !istreq(field, "maximum")) {
 451         log_err(info->ctx, "Unknown field encountered; "
 452                 "Assignment to field %s ignored\n", field);
 453         return false;
 454     }
 455
 456     /* We ignore explicit min/max statements, we always use computed. */
 457     return true;
 458 }
 459
 460 static bool
 461 HandleLedNameDef(KeyNamesInfo *info, LedNameDef *def,
 462                  enum merge_mode merge)
 463 {
 464     LedNameInfo ledi;
 465     xkb_atom_t name;
 466
 467     if (def->ndx < 1 || def->ndx > XKB_MAX_LEDS) {
 468         info->errorCount++;
 469         log_err(info->ctx,
 470                 "Illegal indicator index (%d) specified; must be between 1 .. %d; "
 471                 "Ignored\n", def->ndx, XKB_MAX_LEDS);
 472         return false;
 473     }
 474
 475     if (!ExprResolveString(info->ctx, def->name, &name)) {
 476         char buf[20];
 477         snprintf(buf, sizeof(buf), "%u", def->ndx);
 478         info->errorCount++;
 479         return ReportBadType(info->ctx, XKB_ERROR_WRONG_FIELD_TYPE,
 480                              "indicator", "name", buf, "string");
 481     }
 482
 483     ledi.merge = merge;
 484     ledi.name = name;
 485     return AddLedName(info, merge, true, &ledi, def->ndx - 1);
 486 }
 487
 488 static void
 489 HandleKeycodesFile(KeyNamesInfo *info, XkbFile *file, enum merge_mode merge)
 490 {
 491     bool ok;
 492
 493     free(info->name);
 494     info->name = strdup_safe(file->name);
 495
 496     for (ParseCommon *stmt = file->defs; stmt; stmt = stmt->next) {
 497         switch (stmt->type) {
 498         case STMT_INCLUDE:
 499             ok = HandleIncludeKeycodes(info, (IncludeStmt *) stmt);
 500             break;
 501         case STMT_KEYCODE:
 502             ok = HandleKeycodeDef(info, (KeycodeDef *) stmt, merge);
 503             break;
 504         case STMT_ALIAS:
 505             ok = HandleAliasDef(info, (KeyAliasDef *) stmt, merge);
 506             break;
 507         case STMT_VAR:
 508             ok = HandleKeyNameVar(info, (VarDef *) stmt);
 509             break;
 510         case STMT_LED_NAME:
 511             ok = HandleLedNameDef(info, (LedNameDef *) stmt, merge);
 512             break;
 513         default:
 514             log_err(info->ctx,
 515                     "Keycode files may define key and indicator names only; "
 516                     "Ignoring %s\n", stmt_type_to_string(stmt->type));
 517             ok = false;
 518             break;
 519         }
 520
 521         if (!ok)
 522             info->errorCount++;
 523
 524         if (info->errorCount > 10) {
 525             log_err(info->ctx, "Abandoning keycodes file \"%s\"\n",
 526                     file->name);
 527             break;
 528         }
 529     }
 530 }
 531
 532 /***====================================================================***/
 533
 534 static bool
 535 CopyKeyNamesToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 536 {
 537     struct xkb_key *keys;
 538     xkb_keycode_t min_key_code, max_key_code, kc;
 539
 540     min_key_code = info->min_key_code;
 541     max_key_code = info->max_key_code;
 542     /* If the keymap has no keys, let's just use the safest pair we know. */
 543     if (min_key_code == XKB_KEYCODE_INVALID) {
 544         min_key_code = 8;
 545         max_key_code = 255;
 546     }
 547
 548     keys = calloc(max_key_code + 1, sizeof(*keys));
 549     if (!keys)
 550         return false;
 551
 552     for (kc = min_key_code; kc <= max_key_code; kc++)
 553         keys[kc].keycode = kc;
 554
 555     for (kc = info->min_key_code; kc <= info->max_key_code; kc++)
 556         keys[kc].name = darray_item(info->key_names, kc);
 557
 558     keymap->min_key_code = min_key_code;
 559     keymap->max_key_code = max_key_code;
 560     keymap->keys = keys;
 561     return true;
 562 }
 563
 564 static bool
 565 CopyKeyAliasesToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 566 {
 567     AliasInfo *alias;
 568     unsigned i, num_key_aliases;
 569     struct xkb_key_alias *key_aliases;
 570
 571     /*
 572      * Do some sanity checking on the aliases. We can't do it before
 573      * because keys and their aliases may be added out-of-order.
 574      */
 575     num_key_aliases = 0;
 576     darray_foreach(alias, info->aliases) {
 577         /* Check that ->real is a key. */
 578         if (!XkbKeyByName(keymap, alias->real, false)) {
 579             log_vrb(info->ctx, 5,
 580                     XKB_WARNING_UNDEFINED_KEYCODE,
 581                     "Attempt to alias %s to non-existent key %s; Ignored\n",
 582                     KeyNameText(info->ctx, alias->alias),
 583                     KeyNameText(info->ctx, alias->real));
 584             alias->real = XKB_ATOM_NONE;
 585             continue;
 586         }
 587
 588         /* Check that ->alias is not a key. */
 589         if (XkbKeyByName(keymap, alias->alias, false)) {
 590             log_vrb(info->ctx, 5,
 591                     XKB_WARNING_ILLEGAL_KEYCODE_ALIAS,
 592                     "Attempt to create alias with the name of a real key; "
 593                     "Alias \"%s = %s\" ignored\n",
 594                     KeyNameText(info->ctx, alias->alias),
 595                     KeyNameText(info->ctx, alias->real));
 596             alias->real = XKB_ATOM_NONE;
 597             continue;
 598         }
 599
 600         num_key_aliases++;
 601     }
 602
 603     /* Copy key aliases. */
 604     key_aliases = NULL;
 605     if (num_key_aliases > 0) {
 606         key_aliases = calloc(num_key_aliases, sizeof(*key_aliases));
 607         if (!key_aliases)
 608             return false;
 609
 610         i = 0;
 611         darray_foreach(alias, info->aliases) {
 612             if (alias->real != XKB_ATOM_NONE) {
 613                 key_aliases[i].alias = alias->alias;
 614                 key_aliases[i].real = alias->real;
 615                 i++;
 616             }
 617         }
 618     }
 619
 620     keymap->num_key_aliases = num_key_aliases;
 621     keymap->key_aliases = key_aliases;
 622     return true;
 623 }
 624
 625 static bool
 626 CopyLedNamesToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 627 {
 628     keymap->num_leds = info->num_led_names;
 629     for (xkb_led_index_t idx = 0; idx < info->num_led_names; idx++) {
 630         LedNameInfo *ledi = &info->led_names[idx];
 631
 632         if (ledi->name == XKB_ATOM_NONE)
 633             continue;
 634
 635         keymap->leds[idx].name = ledi->name;
 636     }
 637
 638     return true;
 639 }
 640
 641 static bool
 642 CopyKeyNamesInfoToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 643 {
 644     /* This function trashes keymap on error, but that's OK. */
 645     if (!CopyKeyNamesToKeymap(keymap, info) ||
 646         !CopyKeyAliasesToKeymap(keymap, info) ||
 647         !CopyLedNamesToKeymap(keymap, info))
 648         return false;
 649
 650     keymap->keycodes_section_name = strdup_safe(info->name);
 651     XkbEscapeMapName(keymap->keycodes_section_name);
 652     return true;
 653 }
 654
 655 /***====================================================================***/
 656
 657 bool
 658 CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap,
 659                 enum merge_mode merge)
 660 {
 661     KeyNamesInfo info;
 662
 663     InitKeyNamesInfo(&info, keymap->ctx);
 664
 665     HandleKeycodesFile(&info, file, merge);
 666     if (info.errorCount != 0)
 667         goto err_info;
 668
 669     if (!CopyKeyNamesInfoToKeymap(keymap, &info))
 670         goto err_info;
 671
 672     ClearKeyNamesInfo(&info);
 673     return true;
 674
 675 err_info:
 676     ClearKeyNamesInfo(&info);
 677     return false;
 678 }