setting.cpp

   1 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
   2 // setting.cpp\r
   3 \r
   4 \r
   5 #include "misc.h"\r
   6 \r
   7 #include "dlgsetting.h"\r
   8 #include "errormessage.h"\r
   9 #include "mayu.h"\r
  10 #include "mayurc.h"\r
  11 #include "registry.h"\r
  12 #include "setting.h"\r
  13 #include "windowstool.h"\r
  14 #include "vkeytable.h"\r
  15 #include "array.h"\r
  16 \r
  17 #include <algorithm>\r
  18 #include <fstream>\r
  19 #include <iomanip>\r
  20 #include <sys/stat.h>\r
  21 \r
  22 \r
  23 namespace Event\r
  24 {\r
  25 Key prefixed(_T("prefixed"));\r
  26 Key before_key_down(_T("before-key-down"));\r
  27 Key after_key_up(_T("after-key-up"));\r
  28 Key *events[] = {\r
  29         &prefixed,\r
  30         &before_key_down,\r
  31         &after_key_up,\r
  32         NULL,\r
  33 };\r
  34 }\r
  35 \r
  36 \r
  37 // get mayu filename\r
  38 static bool getFilenameFromRegistry(\r
  39         tstringi *o_name, tstringi *o_filename, Setting::Symbols *o_symbols)\r
  40 {\r
  41         Registry reg(MAYU_REGISTRY_ROOT);\r
  42         int index;\r
  43         reg.read(_T(".mayuIndex"), &index, 0);\r
  44         _TCHAR buf[100];\r
  45         _sntprintf(buf, NUMBER_OF(buf), _T(".mayu%d"), index);\r
  46 \r
  47         tstringi entry;\r
  48         if (!reg.read(buf, &entry))\r
  49                 return false;\r
  50 \r
  51         tregex getFilename(_T("^([^;]*);([^;]*);(.*)$"));\r
  52         tsmatch getFilenameResult;\r
  53         if (!boost::regex_match(entry, getFilenameResult, getFilename))\r
  54                 return false;\r
  55 \r
  56         if (o_name)\r
  57                 *o_name = getFilenameResult.str(1);\r
  58         if (o_filename)\r
  59                 *o_filename = getFilenameResult.str(2);\r
  60         if (o_symbols) {\r
  61                 tstringi symbols = getFilenameResult.str(3);\r
  62                 tregex symbol(_T("-D([^;]*)(.*)$"));\r
  63                 tsmatch symbolResult;\r
  64                 while (boost::regex_search(symbols, symbolResult, symbol)) {\r
  65                         o_symbols->insert(symbolResult.str(1));\r
  66                         symbols = symbolResult.str(2);\r
  67                 }\r
  68         }\r
  69         return true;\r
  70 }\r
  71 \r
  72 \r
  73 // get home directory path\r
  74 void getHomeDirectories(HomeDirectories *o_pathes)\r
  75 {\r
  76         tstringi filename;\r
  77 #ifndef USE_INI\r
  78         if (getFilenameFromRegistry(NULL, &filename, NULL) &&\r
  79                         !filename.empty()) {\r
  80                 tregex getPath(_T("^(.*[/\\\\])[^/\\\\]*$"));\r
  81                 tsmatch getPathResult;\r
  82                 if (boost::regex_match(filename, getPathResult, getPath))\r
  83                         o_pathes->push_back(getPathResult.str(1));\r
  84         }\r
  85 \r
  86         const _TCHAR *home = _tgetenv(_T("HOME"));\r
  87         if (home)\r
  88                 o_pathes->push_back(home);\r
  89 \r
  90         const _TCHAR *homedrive = _tgetenv(_T("HOMEDRIVE"));\r
  91         const _TCHAR *homepath = _tgetenv(_T("HOMEPATH"));\r
  92         if (homedrive && homepath)\r
  93                 o_pathes->push_back(tstringi(homedrive) + homepath);\r
  94 \r
  95         const _TCHAR *userprofile = _tgetenv(_T("USERPROFILE"));\r
  96         if (userprofile)\r
  97                 o_pathes->push_back(userprofile);\r
  98 \r
  99         _TCHAR buf[GANA_MAX_PATH];\r
 100         DWORD len = GetCurrentDirectory(NUMBER_OF(buf), buf);\r
 101         if (0 < len && len < NUMBER_OF(buf))\r
 102                 o_pathes->push_back(buf);\r
 103 #else //USE_INI\r
 104         _TCHAR buf[GANA_MAX_PATH];\r
 105 #endif //USE_INI\r
 106 \r
 107         if (GetModuleFileName(GetModuleHandle(NULL), buf, NUMBER_OF(buf)))\r
 108                 o_pathes->push_back(pathRemoveFileSpec(buf));\r
 109 }\r
 110 \r
 111 \r
 112 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
 113 // SettingLoader\r
 114 \r
 115 \r
 116 // is there no more tokens ?\r
 117 bool SettingLoader::isEOL()\r
 118 {\r
 119         return m_ti == m_tokens.end();\r
 120 }\r
 121 \r
 122 \r
 123 // get next token\r
 124 Token *SettingLoader::getToken()\r
 125 {\r
 126         if (isEOL())\r
 127                 throw ErrorMessage() << _T("too few words.");\r
 128         return &*(m_ti ++);\r
 129 }\r
 130 \r
 131 \r
 132 // look next token\r
 133 Token *SettingLoader::lookToken()\r
 134 {\r
 135         if (isEOL())\r
 136                 throw ErrorMessage() << _T("too few words.");\r
 137         return &*m_ti;\r
 138 }\r
 139 \r
 140 \r
 141 // argument "("\r
 142 bool SettingLoader::getOpenParen(bool i_doesThrow, const _TCHAR *i_name)\r
 143 {\r
 144         if (!isEOL() && lookToken()->isOpenParen()) {\r
 145                 getToken();\r
 146                 return true;\r
 147         }\r
 148         if (i_doesThrow)\r
 149                 throw ErrorMessage() << _T("there must be `(' after `&")\r
 150                 << i_name << _T("'.");\r
 151         return false;\r
 152 }\r
 153 \r
 154 \r
 155 // argument ")"\r
 156 bool SettingLoader::getCloseParen(bool i_doesThrow, const _TCHAR *i_name)\r
 157 {\r
 158         if (!isEOL() && lookToken()->isCloseParen()) {\r
 159                 getToken();\r
 160                 return true;\r
 161         }\r
 162         if (i_doesThrow)\r
 163                 throw ErrorMessage() << _T("`&")  << i_name\r
 164                 << _T("': too many arguments.");\r
 165         return false;\r
 166 }\r
 167 \r
 168 \r
 169 // argument ","\r
 170 bool SettingLoader::getComma(bool i_doesThrow, const _TCHAR *i_name)\r
 171 {\r
 172         if (!isEOL() && lookToken()->isComma()) {\r
 173                 getToken();\r
 174                 return true;\r
 175         }\r
 176         if (i_doesThrow)\r
 177                 throw ErrorMessage() << _T("`&")  << i_name\r
 178                 << _T("': comma expected.");\r
 179         return false;\r
 180 }\r
 181 \r
 182 \r
 183 // <INCLUDE>\r
 184 void SettingLoader::load_INCLUDE()\r
 185 {\r
 186         SettingLoader loader(m_soLog, m_log);\r
 187         loader.m_defaultAssignModifier = m_defaultAssignModifier;\r
 188         loader.m_defaultKeySeqModifier = m_defaultKeySeqModifier;\r
 189         if (!loader.load(m_setting, (*getToken()).getString()))\r
 190                 m_isThereAnyError = true;\r
 191 }\r
 192 \r
 193 \r
 194 // <SCAN_CODES>\r
 195 void SettingLoader::load_SCAN_CODES(Key *o_key)\r
 196 {\r
 197         for (int j = 0; j < Key::MAX_SCAN_CODES_SIZE && !isEOL(); ++ j) {\r
 198                 ScanCode sc;\r
 199                 sc.m_flags = 0;\r
 200                 while (true) {\r
 201                         Token *t = getToken();\r
 202                         if (t->isNumber()) {\r
 203                                 sc.m_scan = (u_char)t->getNumber();\r
 204                                 o_key->addScanCode(sc);\r
 205                                 break;\r
 206                         }\r
 207                         if      (*t == _T("E0-")) sc.m_flags |= ScanCode::E0;\r
 208                         else if (*t == _T("E1-")) sc.m_flags |= ScanCode::E1;\r
 209                         else  throw ErrorMessage() << _T("`") << *t\r
 210                                 << _T("': invalid modifier.");\r
 211                 }\r
 212         }\r
 213 }\r
 214 \r
 215 \r
 216 // <DEFINE_KEY>\r
 217 void SettingLoader::load_DEFINE_KEY()\r
 218 {\r
 219         Token *t = getToken();\r
 220         Key key;\r
 221 \r
 222         // <KEY_NAMES>\r
 223         if (*t == _T('(')) {\r
 224                 key.addName(getToken()->getString());\r
 225                 while (t = getToken(), *t != _T(')'))\r
 226                         key.addName(t->getString());\r
 227                 if (*getToken() != _T("="))\r
 228                         throw ErrorMessage() << _T("there must be `=' after `)'.");\r
 229         } else {\r
 230                 key.addName(t->getString());\r
 231                 while (t = getToken(), *t != _T("="))\r
 232                         key.addName(t->getString());\r
 233         }\r
 234 \r
 235         load_SCAN_CODES(&key);\r
 236         m_setting->m_keyboard.addKey(key);\r
 237 }\r
 238 \r
 239 \r
 240 // <DEFINE_MODIFIER>\r
 241 void SettingLoader::load_DEFINE_MODIFIER()\r
 242 {\r
 243         Token *t = getToken();\r
 244         Modifier::Type mt;\r
 245         if      (*t == _T("shift")  ) mt = Modifier::Type_Shift;\r
 246         else if (*t == _T("alt")     ||\r
 247                          *t == _T("meta")    ||\r
 248                          *t == _T("menu")   ) mt = Modifier::Type_Alt;\r
 249         else if (*t == _T("control") ||\r
 250                          *t == _T("ctrl")   ) mt = Modifier::Type_Control;\r
 251         else if (*t == _T("windows") ||\r
 252                          *t == _T("win")    ) mt = Modifier::Type_Windows;\r
 253         else throw ErrorMessage() << _T("`") << *t\r
 254                 << _T("': invalid modifier name.");\r
 255 \r
 256         if (*getToken() != _T("="))\r
 257                 throw ErrorMessage() << _T("there must be `=' after modifier name.");\r
 258 \r
 259         while (!isEOL()) {\r
 260                 t = getToken();\r
 261                 Key *key =\r
 262                         m_setting->m_keyboard.searchKeyByNonAliasName(t->getString());\r
 263                 if (!key)\r
 264                         throw ErrorMessage() << _T("`") << *t << _T("': invalid key name.");\r
 265                 m_setting->m_keyboard.addModifier(mt, key);\r
 266         }\r
 267 }\r
 268 \r
 269 \r
 270 // <DEFINE_SYNC_KEY>\r
 271 void SettingLoader::load_DEFINE_SYNC_KEY()\r
 272 {\r
 273         Key *key = m_setting->m_keyboard.getSyncKey();\r
 274         key->initialize();\r
 275         key->addName(_T("sync"));\r
 276 \r
 277         if (*getToken() != _T("="))\r
 278                 throw ErrorMessage() << _T("there must be `=' after `sync'.");\r
 279 \r
 280         load_SCAN_CODES(key);\r
 281 }\r
 282 \r
 283 \r
 284 // <DEFINE_ALIAS>\r
 285 void SettingLoader::load_DEFINE_ALIAS()\r
 286 {\r
 287         Token *name = getToken();\r
 288 \r
 289         if (*getToken() != _T("="))\r
 290                 throw ErrorMessage() << _T("there must be `=' after `alias'.");\r
 291 \r
 292         Token *t = getToken();\r
 293         Key *key = m_setting->m_keyboard.searchKeyByNonAliasName(t->getString());\r
 294         if (!key)\r
 295                 throw ErrorMessage() << _T("`") << *t << _T("': invalid key name.");\r
 296         m_setting->m_keyboard.addAlias(name->getString(), key);\r
 297 }\r
 298 \r
 299 \r
 300 // <DEFINE_SUBSTITUTE>\r
 301 void SettingLoader::load_DEFINE_SUBSTITUTE()\r
 302 {\r
 303         typedef std::list<ModifiedKey> AssignedKeys;\r
 304         AssignedKeys assignedKeys;\r
 305         do {\r
 306                 ModifiedKey mkey;\r
 307                 mkey.m_modifier =\r
 308                         load_MODIFIER(Modifier::Type_ASSIGN, m_defaultAssignModifier);\r
 309                 mkey.m_key = load_KEY_NAME();\r
 310                 assignedKeys.push_back(mkey);\r
 311         } while (!(*lookToken() == _T("=>") || *lookToken() == _T("=")));\r
 312         getToken();\r
 313 \r
 314         KeySeq *keySeq = load_KEY_SEQUENCE(_T(""), false, Modifier::Type_ASSIGN);\r
 315         ModifiedKey mkey = keySeq->getFirstModifiedKey();\r
 316         if (!mkey.m_key)\r
 317                 throw ErrorMessage() << _T("no key is specified for substitute.");\r
 318 \r
 319         for (AssignedKeys::iterator i = assignedKeys.begin();\r
 320                         i != assignedKeys.end(); ++ i)\r
 321                 m_setting->m_keyboard.addSubstitute(*i, mkey);\r
 322 }\r
 323 \r
 324 \r
 325 // <DEFINE_OPTION>\r
 326 void SettingLoader::load_DEFINE_OPTION()\r
 327 {\r
 328         Token *t = getToken();\r
 329         if (*t == _T("KL-")) {\r
 330                 if (*getToken() != _T("=")) {\r
 331                         throw ErrorMessage() << _T("there must be `=' after `def option KL-'.");\r
 332                 }\r
 333 \r
 334                 load_ARGUMENT(&m_setting->m_correctKanaLockHandling);\r
 335 \r
 336         } else if (*t == _T("delay-of")) {\r
 337                 if (*getToken() != _T("!!!")) {\r
 338                         throw ErrorMessage()\r
 339                         << _T("there must be `!!!' after `def option delay-of'.");\r
 340                 }\r
 341 \r
 342                 if (*getToken() != _T("=")) {\r
 343                         throw ErrorMessage()\r
 344                         << _T("there must be `=' after `def option delay-of !!!'.");\r
 345                 }\r
 346 \r
 347                 load_ARGUMENT(&m_setting->m_oneShotRepeatableDelay);\r
 348 \r
 349         } else if (*t == _T("sts4mayu")) {\r
 350                 if (*getToken() != _T("=")) {\r
 351                         throw ErrorMessage()\r
 352                         << _T("there must be `=' after `def option sts4mayu'.");\r
 353                 }\r
 354 \r
 355                 load_ARGUMENT(&m_setting->m_sts4mayu);\r
 356 \r
 357         } else if (*t == _T("cts4mayu")) {\r
 358                 if (*getToken() != _T("=")) {\r
 359                         throw ErrorMessage()\r
 360                         << _T("there must be `=' after `def option cts4mayu'.");\r
 361                 }\r
 362 \r
 363                 load_ARGUMENT(&m_setting->m_cts4mayu);\r
 364 \r
 365         } else {\r
 366                 throw ErrorMessage() << _T("syntax error `def option ") << *t << _T("'.");\r
 367         }\r
 368 }\r
 369 \r
 370 \r
 371 \r
 372 // <KEYBOARD_DEFINITION>\r
 373 void SettingLoader::load_KEYBOARD_DEFINITION()\r
 374 {\r
 375         Token *t = getToken();\r
 376 \r
 377         // <DEFINE_KEY>\r
 378         if (*t == _T("key")) load_DEFINE_KEY();\r
 379 \r
 380         // <DEFINE_MODIFIER>\r
 381         else if (*t == _T("mod")) load_DEFINE_MODIFIER();\r
 382 \r
 383         // <DEFINE_SYNC_KEY>\r
 384         else if (*t == _T("sync")) load_DEFINE_SYNC_KEY();\r
 385 \r
 386         // <DEFINE_ALIAS>\r
 387         else if (*t == _T("alias")) load_DEFINE_ALIAS();\r
 388 \r
 389         // <DEFINE_SUBSTITUTE>\r
 390         else if (*t == _T("subst")) load_DEFINE_SUBSTITUTE();\r
 391 \r
 392         // <DEFINE_OPTION>\r
 393         else if (*t == _T("option")) load_DEFINE_OPTION();\r
 394 \r
 395         //\r
 396         else throw ErrorMessage() << _T("syntax error `") << *t << _T("'.");\r
 397 }\r
 398 \r
 399 \r
 400 // <..._MODIFIER>\r
 401 Modifier SettingLoader::load_MODIFIER(\r
 402         Modifier::Type i_mode, Modifier i_modifier, Modifier::Type *o_mode)\r
 403 {\r
 404         if (o_mode)\r
 405                 *o_mode = Modifier::Type_begin;\r
 406 \r
 407         Modifier isModifierSpecified;\r
 408         enum { PRESS, RELEASE, DONTCARE } flag = PRESS;\r
 409 \r
 410         int i;\r
 411         for (i = i_mode; i < Modifier::Type_ASSIGN; ++ i) {\r
 412                 i_modifier.dontcare(Modifier::Type(i));\r
 413                 isModifierSpecified.on(Modifier::Type(i));\r
 414         }\r
 415 \r
 416         Token *t = NULL;\r
 417 \r
 418 continue_loop:\r
 419         while (!isEOL()) {\r
 420                 t = lookToken();\r
 421 \r
 422                 const static struct {\r
 423                         const _TCHAR *m_s;\r
 424                         Modifier::Type m_mt;\r
 425                 } map[] = {\r
 426                         // <BASIC_MODIFIER>\r
 427                         { _T("S-"),  Modifier::Type_Shift },\r
 428                         { _T("A-"),  Modifier::Type_Alt },\r
 429                         { _T("M-"),  Modifier::Type_Alt },\r
 430                         { _T("C-"),  Modifier::Type_Control },\r
 431                         { _T("W-"),  Modifier::Type_Windows },\r
 432                         // <KEYSEQ_MODIFIER>\r
 433                         { _T("U-"),  Modifier::Type_Up },\r
 434                         { _T("D-"),  Modifier::Type_Down },\r
 435                         // <ASSIGN_MODIFIER>\r
 436                         { _T("R-"),  Modifier::Type_Repeat },\r
 437                         { _T("IL-"), Modifier::Type_ImeLock },\r
 438                         { _T("IC-"), Modifier::Type_ImeComp },\r
 439                         { _T("I-"),  Modifier::Type_ImeComp },\r
 440                         { _T("NL-"), Modifier::Type_NumLock },\r
 441                         { _T("CL-"), Modifier::Type_CapsLock },\r
 442                         { _T("SL-"), Modifier::Type_ScrollLock },\r
 443                         { _T("KL-"), Modifier::Type_KanaLock },\r
 444                         { _T("MAX-"), Modifier::Type_Maximized },\r
 445                         { _T("MIN-"), Modifier::Type_Minimized },\r
 446                         { _T("MMAX-"), Modifier::Type_MdiMaximized },\r
 447                         { _T("MMIN-"), Modifier::Type_MdiMinimized },\r
 448                         { _T("T-"), Modifier::Type_Touchpad },\r
 449                         { _T("TS-"), Modifier::Type_TouchpadSticky },\r
 450                         { _T("M0-"), Modifier::Type_Mod0 },\r
 451                         { _T("M1-"), Modifier::Type_Mod1 },\r
 452                         { _T("M2-"), Modifier::Type_Mod2 },\r
 453                         { _T("M3-"), Modifier::Type_Mod3 },\r
 454                         { _T("M4-"), Modifier::Type_Mod4 },\r
 455                         { _T("M5-"), Modifier::Type_Mod5 },\r
 456                         { _T("M6-"), Modifier::Type_Mod6 },\r
 457                         { _T("M7-"), Modifier::Type_Mod7 },\r
 458                         { _T("M8-"), Modifier::Type_Mod8 },\r
 459                         { _T("M9-"), Modifier::Type_Mod9 },\r
 460                         { _T("L0-"), Modifier::Type_Lock0 },\r
 461                         { _T("L1-"), Modifier::Type_Lock1 },\r
 462                         { _T("L2-"), Modifier::Type_Lock2 },\r
 463                         { _T("L3-"), Modifier::Type_Lock3 },\r
 464                         { _T("L4-"), Modifier::Type_Lock4 },\r
 465                         { _T("L5-"), Modifier::Type_Lock5 },\r
 466                         { _T("L6-"), Modifier::Type_Lock6 },\r
 467                         { _T("L7-"), Modifier::Type_Lock7 },\r
 468                         { _T("L8-"), Modifier::Type_Lock8 },\r
 469                         { _T("L9-"), Modifier::Type_Lock9 },\r
 470                 };\r
 471 \r
 472                 for (int i = 0; i < NUMBER_OF(map); ++ i)\r
 473                         if (*t == map[i].m_s) {\r
 474                                 getToken();\r
 475                                 Modifier::Type mt = map[i].m_mt;\r
 476                                 if (static_cast<int>(i_mode) <= static_cast<int>(mt))\r
 477                                         throw ErrorMessage() << _T("`") << *t\r
 478                                         << _T("': invalid modifier at this context.");\r
 479                                 switch (flag) {\r
 480                                 case PRESS:\r
 481                                         i_modifier.press(mt);\r
 482                                         break;\r
 483                                 case RELEASE:\r
 484                                         i_modifier.release(mt);\r
 485                                         break;\r
 486                                 case DONTCARE:\r
 487                                         i_modifier.dontcare(mt);\r
 488                                         break;\r
 489                                 }\r
 490                                 isModifierSpecified.on(mt);\r
 491                                 flag = PRESS;\r
 492 \r
 493                                 if (o_mode && *o_mode < mt) {\r
 494                                         if (mt < Modifier::Type_BASIC)\r
 495                                                 *o_mode = Modifier::Type_BASIC;\r
 496                                         else if (mt < Modifier::Type_KEYSEQ)\r
 497                                                 *o_mode = Modifier::Type_KEYSEQ;\r
 498                                         else if (mt < Modifier::Type_ASSIGN)\r
 499                                                 *o_mode = Modifier::Type_ASSIGN;\r
 500                                 }\r
 501                                 goto continue_loop;\r
 502                         }\r
 503 \r
 504                 if (*t == _T("*")) {\r
 505                         getToken();\r
 506                         flag = DONTCARE;\r
 507                         continue;\r
 508                 }\r
 509 \r
 510                 if (*t == _T("~")) {\r
 511                         getToken();\r
 512                         flag = RELEASE;\r
 513                         continue;\r
 514                 }\r
 515 \r
 516                 break;\r
 517         }\r
 518 \r
 519         for (i = Modifier::Type_begin; i != Modifier::Type_end; ++ i)\r
 520                 if (!isModifierSpecified.isOn(Modifier::Type(i)))\r
 521                         switch (flag) {\r
 522                         case PRESS:\r
 523                                 break;\r
 524                         case RELEASE:\r
 525                                 i_modifier.release(Modifier::Type(i));\r
 526                                 break;\r
 527                         case DONTCARE:\r
 528                                 i_modifier.dontcare(Modifier::Type(i));\r
 529                                 break;\r
 530                         }\r
 531 \r
 532         // fix up and down\r
 533         bool isDontcareUp   = i_modifier.isDontcare(Modifier::Type_Up);\r
 534         bool isDontcareDown = i_modifier.isDontcare(Modifier::Type_Down);\r
 535         bool isOnUp         = i_modifier.isOn(Modifier::Type_Up);\r
 536         bool isOnDown       = i_modifier.isOn(Modifier::Type_Down);\r
 537         if (isDontcareUp && isDontcareDown)\r
 538                 ;\r
 539         else if (isDontcareUp)\r
 540                 i_modifier.on(Modifier::Type_Up, !isOnDown);\r
 541         else if (isDontcareDown)\r
 542                 i_modifier.on(Modifier::Type_Down, !isOnUp);\r
 543         else if (isOnUp == isOnDown) {\r
 544                 i_modifier.dontcare(Modifier::Type_Up);\r
 545                 i_modifier.dontcare(Modifier::Type_Down);\r
 546         }\r
 547 \r
 548         // fix repeat\r
 549         if (!isModifierSpecified.isOn(Modifier::Type_Repeat))\r
 550                 i_modifier.dontcare(Modifier::Type_Repeat);\r
 551         return i_modifier;\r
 552 }\r
 553 \r
 554 \r
 555 // <KEY_NAME>\r
 556 Key *SettingLoader::load_KEY_NAME()\r
 557 {\r
 558         Token *t = getToken();\r
 559         Key *key = m_setting->m_keyboard.searchKey(t->getString());\r
 560         if (!key)\r
 561                 throw ErrorMessage() << _T("`") << *t << _T("': invalid key name.");\r
 562         return key;\r
 563 }\r
 564 \r
 565 \r
 566 // <KEYMAP_DEFINITION>\r
 567 void SettingLoader::load_KEYMAP_DEFINITION(const Token *i_which)\r
 568 {\r
 569         Keymap::Type type = Keymap::Type_keymap;\r
 570         Token *name = getToken();       // <KEYMAP_NAME>\r
 571         tstringi windowClassName;\r
 572         tstringi windowTitleName;\r
 573         KeySeq *keySeq = NULL;\r
 574         Keymap *parentKeymap = NULL;\r
 575         bool isKeymap2 = false;\r
 576         bool doesLoadDefaultKeySeq = false;\r
 577 \r
 578         if (!isEOL()) {\r
 579                 Token *t = lookToken();\r
 580                 if (*i_which == _T("window")) { // <WINDOW>\r
 581                         if (t->isOpenParen())\r
 582                                 // "(" <WINDOW_CLASS_NAME> "&&" <WINDOW_TITLE_NAME> ")"\r
 583                                 // "(" <WINDOW_CLASS_NAME> "||" <WINDOW_TITLE_NAME> ")"\r
 584                         {\r
 585                                 getToken();\r
 586                                 windowClassName = getToken()->getRegexp();\r
 587                                 t = getToken();\r
 588                                 if (*t == _T("&&"))\r
 589                                         type = Keymap::Type_windowAnd;\r
 590                                 else if (*t == _T("||"))\r
 591                                         type = Keymap::Type_windowOr;\r
 592                                 else\r
 593                                         throw ErrorMessage() << _T("`") << *t << _T("': unknown operator.");\r
 594                                 windowTitleName = getToken()->getRegexp();\r
 595                                 if (!getToken()->isCloseParen())\r
 596                                         throw ErrorMessage() << _T("there must be `)'.");\r
 597                         } else if (t->isRegexp()) {     // <WINDOW_CLASS_NAME>\r
 598                                 getToken();\r
 599                                 type = Keymap::Type_windowAnd;\r
 600                                 windowClassName = t->getRegexp();\r
 601                         }\r
 602                 } else if (*i_which == _T("keymap"))\r
 603                         ;\r
 604                 else if (*i_which == _T("keymap2"))\r
 605                         isKeymap2 = true;\r
 606                 else\r
 607                         ASSERT(false);\r
 608 \r
 609                 if (!isEOL())\r
 610                         doesLoadDefaultKeySeq = true;\r
 611         }\r
 612 \r
 613         m_currentKeymap = m_setting->m_keymaps.add(\r
 614                                                   Keymap(type, name->getString(), windowClassName, windowTitleName,\r
 615                                                                  NULL, NULL));\r
 616 \r
 617         if (doesLoadDefaultKeySeq) {\r
 618                 Token *t = lookToken();\r
 619                 // <KEYMAP_PARENT>\r
 620                 if (*t == _T(":")) {\r
 621                         getToken();\r
 622                         t = getToken();\r
 623                         parentKeymap = m_setting->m_keymaps.searchByName(t->getString());\r
 624                         if (!parentKeymap)\r
 625                                 throw ErrorMessage() << _T("`") << *t\r
 626                                 << _T("': unknown keymap name.");\r
 627                 }\r
 628                 if (!isEOL()) {\r
 629                         t = getToken();\r
 630                         if (!(*t == _T("=>") || *t == _T("=")))\r
 631                                 throw ErrorMessage() << _T("`") << *t << _T("': syntax error.");\r
 632                         keySeq = SettingLoader::load_KEY_SEQUENCE();\r
 633                 }\r
 634         }\r
 635         if (keySeq == NULL) {\r
 636                 FunctionData *fd;\r
 637                 if (type == Keymap::Type_keymap && !isKeymap2)\r
 638                         fd = createFunctionData(_T("KeymapParent"));\r
 639                 else if (type == Keymap::Type_keymap && !isKeymap2)\r
 640                         fd = createFunctionData(_T("Undefined"));\r
 641                 else // (type == Keymap::Type_windowAnd || type == Keymap::Type_windowOr)\r
 642                         fd = createFunctionData(_T("KeymapParent"));\r
 643                 ASSERT( fd );\r
 644                 keySeq = m_setting->m_keySeqs.add(\r
 645                                          KeySeq(name->getString()).add(ActionFunction(fd)));\r
 646         }\r
 647 \r
 648         m_currentKeymap->setIfNotYet(keySeq, parentKeymap);\r
 649 }\r
 650 \r
 651 \r
 652 // &lt;ARGUMENT&gt;\r
 653 void SettingLoader::load_ARGUMENT(bool *o_arg)\r
 654 {\r
 655         *o_arg = !(*getToken() == _T("false"));\r
 656 }\r
 657 \r
 658 \r
 659 // &lt;ARGUMENT&gt;\r
 660 void SettingLoader::load_ARGUMENT(int *o_arg)\r
 661 {\r
 662         *o_arg = getToken()->getNumber();\r
 663 }\r
 664 \r
 665 \r
 666 // &lt;ARGUMENT&gt;\r
 667 void SettingLoader::load_ARGUMENT(unsigned int *o_arg)\r
 668 {\r
 669         *o_arg = getToken()->getNumber();\r
 670 }\r
 671 \r
 672 \r
 673 // &lt;ARGUMENT&gt;\r
 674 void SettingLoader::load_ARGUMENT(long *o_arg)\r
 675 {\r
 676         *o_arg = getToken()->getNumber();\r
 677 }\r
 678 \r
 679 \r
 680 // &lt;ARGUMENT&gt;\r
 681 void SettingLoader::load_ARGUMENT(unsigned __int64 *o_arg)\r
 682 {\r
 683         *o_arg = getToken()->getNumber();\r
 684 }\r
 685 \r
 686 \r
 687 // &lt;ARGUMENT&gt;\r
 688 void SettingLoader::load_ARGUMENT(__int64 *o_arg)\r
 689 {\r
 690         *o_arg = getToken()->getNumber();\r
 691 }\r
 692 \r
 693 \r
 694 // &lt;ARGUMENT&gt;\r
 695 void SettingLoader::load_ARGUMENT(tstringq *o_arg)\r
 696 {\r
 697         *o_arg = getToken()->getString();\r
 698 }\r
 699 \r
 700 \r
 701 // &lt;ARGUMENT&gt;\r
 702 void SettingLoader::load_ARGUMENT(std::list<tstringq> *o_arg)\r
 703 {\r
 704         while (true) {\r
 705                 if (!lookToken()->isString())\r
 706                         return;\r
 707                 o_arg->push_back(getToken()->getString());\r
 708 \r
 709                 if (!lookToken()->isComma())\r
 710                         return;\r
 711                 getToken();\r
 712         }\r
 713 }\r
 714 \r
 715 \r
 716 // &lt;ARGUMENT&gt;\r
 717 void SettingLoader::load_ARGUMENT(tregex *o_arg)\r
 718 {\r
 719         *o_arg = getToken()->getRegexp();\r
 720 }\r
 721 \r
 722 \r
 723 // &lt;ARGUMENT_VK&gt;\r
 724 void SettingLoader::load_ARGUMENT(VKey *o_arg)\r
 725 {\r
 726         Token *t = getToken();\r
 727         int vkey = 0;\r
 728         while (true) {\r
 729                 if (t->isNumber()) {\r
 730                         vkey |= static_cast<BYTE>(t->getNumber());\r
 731                         break;\r
 732                 } else if (*t == _T("E-")) vkey |= VKey_extended;\r
 733                 else if (*t == _T("U-")) vkey |= VKey_released;\r
 734                 else if (*t == _T("D-")) vkey |= VKey_pressed;\r
 735                 else {\r
 736                         const VKeyTable *vkt;\r
 737                         for (vkt = g_vkeyTable; vkt->m_name; ++ vkt)\r
 738                                 if (*t == vkt->m_name)\r
 739                                         break;\r
 740                         if (!vkt->m_name)\r
 741                                 throw ErrorMessage() << _T("`") << *t\r
 742                                 << _T("': unknown virtual key name.");\r
 743                         vkey |= vkt->m_code;\r
 744                         break;\r
 745                 }\r
 746                 t = getToken();\r
 747         }\r
 748         if (!(vkey & VKey_released) && !(vkey & VKey_pressed))\r
 749                 vkey |= VKey_released | VKey_pressed;\r
 750         *o_arg = static_cast<VKey>(vkey);\r
 751 }\r
 752 \r
 753 \r
 754 // &lt;ARGUMENT_WINDOW&gt;\r
 755 void SettingLoader::load_ARGUMENT(ToWindowType *o_arg)\r
 756 {\r
 757         Token *t = getToken();\r
 758         if (t->isNumber()) {\r
 759                 if (ToWindowType_toBegin <= t->getNumber()) {\r
 760                         *o_arg = static_cast<ToWindowType>(t->getNumber());\r
 761                         return;\r
 762                 }\r
 763         } else if (getTypeValue(o_arg, t->getString()))\r
 764                 return;\r
 765         throw ErrorMessage() << _T("`") << *t << _T("': invalid target window.");\r
 766 }\r
 767 \r
 768 \r
 769 // &lt;ARGUMENT&gt;\r
 770 void SettingLoader::load_ARGUMENT(GravityType *o_arg)\r
 771 {\r
 772         Token *t = getToken();\r
 773         if (getTypeValue(o_arg, t->getString()))\r
 774                 return;\r
 775         throw ErrorMessage() << _T("`") << *t << _T("': unknown gravity symbol.");\r
 776 }\r
 777 \r
 778 \r
 779 // &lt;ARGUMENT&gt;\r
 780 void SettingLoader::load_ARGUMENT(MouseHookType *o_arg)\r
 781 {\r
 782         Token *t = getToken();\r
 783         if (getTypeValue(o_arg, t->getString()))\r
 784                 return;\r
 785         throw ErrorMessage() << _T("`") << *t << _T("': unknown MouseHookType symbol.");\r
 786 }\r
 787 \r
 788 \r
 789 // &lt;ARGUMENT&gt;\r
 790 void SettingLoader::load_ARGUMENT(MayuDialogType *o_arg)\r
 791 {\r
 792         Token *t = getToken();\r
 793         if (getTypeValue(o_arg, t->getString()))\r
 794                 return;\r
 795         throw ErrorMessage() << _T("`") << *t << _T("': unknown dialog box.");\r
 796 }\r
 797 \r
 798 \r
 799 // &lt;ARGUMENT_LOCK&gt;\r
 800 void SettingLoader::load_ARGUMENT(ModifierLockType *o_arg)\r
 801 {\r
 802         Token *t = getToken();\r
 803         if (getTypeValue(o_arg, t->getString()))\r
 804                 return;\r
 805         throw ErrorMessage() << _T("`") << *t << _T("': unknown lock name.");\r
 806 }\r
 807 \r
 808 \r
 809 // &lt;ARGUMENT_LOCK&gt;\r
 810 void SettingLoader::load_ARGUMENT(ToggleType *o_arg)\r
 811 {\r
 812         Token *t = getToken();\r
 813         if (getTypeValue(o_arg, t->getString()))\r
 814                 return;\r
 815         throw ErrorMessage() << _T("`") << *t << _T("': unknown toggle name.");\r
 816 }\r
 817 \r
 818 \r
 819 // &lt;ARGUMENT_SHOW_WINDOW&gt;\r
 820 void SettingLoader::load_ARGUMENT(ShowCommandType *o_arg)\r
 821 {\r
 822         Token *t = getToken();\r
 823         if (getTypeValue(o_arg, t->getString()))\r
 824                 return;\r
 825         throw ErrorMessage() << _T("`") << *t << _T("': unknown show command.");\r
 826 }\r
 827 \r
 828 \r
 829 // &lt;ARGUMENT_TARGET_WINDOW&gt;\r
 830 void SettingLoader::load_ARGUMENT(TargetWindowType *o_arg)\r
 831 {\r
 832         Token *t = getToken();\r
 833         if (getTypeValue(o_arg, t->getString()))\r
 834                 return;\r
 835         throw ErrorMessage() << _T("`") << *t\r
 836         << _T("': unknown target window type.");\r
 837 }\r
 838 \r
 839 \r
 840 // &lt;bool&gt;\r
 841 void SettingLoader::load_ARGUMENT(BooleanType *o_arg)\r
 842 {\r
 843         Token *t = getToken();\r
 844         if (getTypeValue(o_arg, t->getString()))\r
 845                 return;\r
 846         throw ErrorMessage() << _T("`") << *t << _T("': must be true or false.");\r
 847 }\r
 848 \r
 849 \r
 850 // &lt;ARGUMENT&gt;\r
 851 void SettingLoader::load_ARGUMENT(LogicalOperatorType *o_arg)\r
 852 {\r
 853         Token *t = getToken();\r
 854         if (getTypeValue(o_arg, t->getString()))\r
 855                 return;\r
 856         throw ErrorMessage() << _T("`") << *t << _T("': must be 'or' or 'and'.");\r
 857 }\r
 858 \r
 859 \r
 860 // &lt;ARGUMENT&gt;\r
 861 void SettingLoader::load_ARGUMENT(Modifier *o_arg)\r
 862 {\r
 863         Modifier modifier;\r
 864         for (int i = Modifier::Type_begin; i != Modifier::Type_end; ++ i)\r
 865                 modifier.dontcare(static_cast<Modifier::Type>(i));\r
 866         *o_arg = load_MODIFIER(Modifier::Type_ASSIGN, modifier);\r
 867 }\r
 868 \r
 869 \r
 870 // &lt;ARGUMENT&gt;\r
 871 void SettingLoader::load_ARGUMENT(const Keymap **o_arg)\r
 872 {\r
 873         Token *t = getToken();\r
 874         const Keymap *&keymap = *o_arg;\r
 875         keymap = m_setting->m_keymaps.searchByName(t->getString());\r
 876         if (!keymap)\r
 877                 throw ErrorMessage() << _T("`") << *t << _T("': unknown keymap name.");\r
 878 }\r
 879 \r
 880 \r
 881 // &lt;ARGUMENT&gt;\r
 882 void SettingLoader::load_ARGUMENT(const KeySeq **o_arg)\r
 883 {\r
 884         Token *t = getToken();\r
 885         const KeySeq *&keySeq = *o_arg;\r
 886         if (t->isOpenParen()) {\r
 887                 keySeq = load_KEY_SEQUENCE(_T(""), true);\r
 888                 getToken(); // close paren\r
 889         } else if (*t == _T("$")) {\r
 890                 t = getToken();\r
 891                 keySeq = m_setting->m_keySeqs.searchByName(t->getString());\r
 892                 if (!keySeq)\r
 893                         throw ErrorMessage() << _T("`$") << *t << _T("': unknown keyseq name.");\r
 894         } else\r
 895                 throw ErrorMessage() << _T("`") << *t << _T("': it is not keyseq.");\r
 896 }\r
 897 \r
 898 \r
 899 // &lt;ARGUMENT&gt;\r
 900 void SettingLoader::load_ARGUMENT(StrExprArg *o_arg)\r
 901 {\r
 902         Token *t = getToken();\r
 903         StrExprArg::Type type = StrExprArg::Literal;\r
 904         if (*t == _T("$") && t->isQuoted() == false\r
 905                         && lookToken()->getType() == Token::Type_string) {\r
 906                 type = StrExprArg::Builtin;\r
 907                 t = getToken();\r
 908         }\r
 909         *o_arg = StrExprArg(t->getString(), type);\r
 910 }\r
 911 \r
 912 \r
 913 // &lt;ARGUMENT&gt;\r
 914 void SettingLoader::load_ARGUMENT(WindowMonitorFromType *o_arg)\r
 915 {\r
 916         Token *t = getToken();\r
 917         if (getTypeValue(o_arg, t->getString()))\r
 918                 return;\r
 919         throw ErrorMessage() << _T("`") << *t\r
 920         << _T("': unknown monitor from type.");\r
 921 }\r
 922 \r
 923 \r
 924 // <KEY_SEQUENCE>\r
 925 KeySeq *SettingLoader::load_KEY_SEQUENCE(\r
 926         const tstringi &i_name, bool i_isInParen, Modifier::Type i_mode)\r
 927 {\r
 928         KeySeq keySeq(i_name);\r
 929         while (!isEOL()) {\r
 930                 Modifier::Type mode;\r
 931                 Modifier modifier = load_MODIFIER(i_mode, m_defaultKeySeqModifier, &mode);\r
 932                 keySeq.setMode(mode);\r
 933                 Token *t = lookToken();\r
 934                 if (t->isCloseParen() && i_isInParen)\r
 935                         break;\r
 936                 else if (t->isOpenParen()) {\r
 937                         getToken(); // open paren\r
 938                         KeySeq *ks = load_KEY_SEQUENCE(_T(""), true, i_mode);\r
 939                         getToken(); // close paren\r
 940                         keySeq.add(ActionKeySeq(ks));\r
 941                 } else if (*t == _T("$")) { // <KEYSEQ_NAME>\r
 942                         getToken();\r
 943                         t = getToken();\r
 944                         KeySeq *ks = m_setting->m_keySeqs.searchByName(t->getString());\r
 945                         if (ks == NULL)\r
 946                                 throw ErrorMessage() << _T("`$") << *t\r
 947                                 << _T("': unknown keyseq name.");\r
 948                         if (!ks->isCorrectMode(i_mode))\r
 949                                 throw ErrorMessage()\r
 950                                 << _T("`$") << *t\r
 951                                 << _T("': Some of R-, IL-, IC-, NL-, CL-, SL-, KL-, MAX-, MIN-, MMAX-, MMIN-, T-, TS-, M0...M9- and L0...L9- are used in the keyseq.  They are prohibited in this context.");\r
 952                         keySeq.setMode(ks->getMode());\r
 953                         keySeq.add(ActionKeySeq(ks));\r
 954                 } else if (*t == _T("&")) { // <FUNCTION_NAME>\r
 955                         getToken();\r
 956                         t = getToken();\r
 957 \r
 958                         // search function\r
 959                         ActionFunction af(createFunctionData(t->getString()), modifier);\r
 960                         if (af.m_functionData == NULL)\r
 961                                 throw ErrorMessage() << _T("`&") << *t\r
 962                                 << _T("': unknown function name.");\r
 963                         af.m_functionData->load(this);\r
 964                         keySeq.add(af);\r
 965                 } else { // <KEYSEQ_MODIFIED_KEY_NAME>\r
 966                         ModifiedKey mkey;\r
 967                         mkey.m_modifier = modifier;\r
 968                         mkey.m_key = load_KEY_NAME();\r
 969                         keySeq.add(ActionKey(mkey));\r
 970                 }\r
 971         }\r
 972         return m_setting->m_keySeqs.add(keySeq);\r
 973 }\r
 974 \r
 975 \r
 976 // <KEY_ASSIGN>\r
 977 void SettingLoader::load_KEY_ASSIGN()\r
 978 {\r
 979         typedef std::list<ModifiedKey> AssignedKeys;\r
 980         AssignedKeys assignedKeys;\r
 981 \r
 982         ModifiedKey mkey;\r
 983         mkey.m_modifier =\r
 984                 load_MODIFIER(Modifier::Type_ASSIGN, m_defaultAssignModifier);\r
 985         if (*lookToken() == _T("=")) {\r
 986                 getToken();\r
 987                 m_defaultKeySeqModifier = load_MODIFIER(Modifier::Type_KEYSEQ,\r
 988                                                                                                 m_defaultKeySeqModifier);\r
 989                 m_defaultAssignModifier = mkey.m_modifier;\r
 990                 return;\r
 991         }\r
 992 \r
 993         while (true) {\r
 994                 mkey.m_key = load_KEY_NAME();\r
 995                 assignedKeys.push_back(mkey);\r
 996                 if (*lookToken() == _T("=>") || *lookToken() == _T("="))\r
 997                         break;\r
 998                 mkey.m_modifier =\r
 999                         load_MODIFIER(Modifier::Type_ASSIGN, m_defaultAssignModifier);\r
1000         }\r
1001         getToken();\r
1002 \r
1003         ASSERT(m_currentKeymap);\r
1004         KeySeq *keySeq = load_KEY_SEQUENCE();\r
1005         for (AssignedKeys::iterator i = assignedKeys.begin();\r
1006                         i != assignedKeys.end(); ++ i)\r
1007                 m_currentKeymap->addAssignment(*i, keySeq);\r
1008 }\r
1009 \r
1010 \r
1011 // <EVENT_ASSIGN>\r
1012 void SettingLoader::load_EVENT_ASSIGN()\r
1013 {\r
1014         std::list<ModifiedKey> assignedKeys;\r
1015 \r
1016         ModifiedKey mkey;\r
1017         mkey.m_modifier.dontcare();                     //set all modifiers to dontcare\r
1018 \r
1019         Token *t = getToken();\r
1020         Key **e;\r
1021         for (e = Event::events; *e; ++ e)\r
1022                 if (*t == (*e)->getName()) {\r
1023                         mkey.m_key = *e;\r
1024                         break;\r
1025                 }\r
1026         if (!*e)\r
1027                 throw ErrorMessage() << _T("`") << *t << _T("': invalid event name.");\r
1028 \r
1029         t = getToken();\r
1030         if (!(*t == _T("=>") || *t == _T("=")))\r
1031                 throw ErrorMessage() << _T("`=' is expected.");\r
1032 \r
1033         ASSERT(m_currentKeymap);\r
1034         KeySeq *keySeq = load_KEY_SEQUENCE();\r
1035         m_currentKeymap->addAssignment(mkey, keySeq);\r
1036 }\r
1037 \r
1038 \r
1039 // <MODIFIER_ASSIGNMENT>\r
1040 void SettingLoader::load_MODIFIER_ASSIGNMENT()\r
1041 {\r
1042         // <MODIFIER_NAME>\r
1043         Token *t = getToken();\r
1044         Modifier::Type mt;\r
1045 \r
1046         while (true) {\r
1047                 Keymap::AssignMode am = Keymap::AM_notModifier;\r
1048                 if      (*t == _T("!")  ) am = Keymap::AM_true, t = getToken();\r
1049                 else if (*t == _T("!!") ) am = Keymap::AM_oneShot, t = getToken();\r
1050                 else if (*t == _T("!!!")) am = Keymap::AM_oneShotRepeatable, t = getToken();\r
1051 \r
1052                 if      (*t == _T("shift")) mt = Modifier::Type_Shift;\r
1053                 else if (*t == _T("alt")  ||\r
1054                                  *t == _T("meta") ||\r
1055                                  *t == _T("menu") ) mt = Modifier::Type_Alt;\r
1056                 else if (*t == _T("control") ||\r
1057                                  *t == _T("ctrl") ) mt = Modifier::Type_Control;\r
1058                 else if (*t == _T("windows") ||\r
1059                                  *t == _T("win")  ) mt = Modifier::Type_Windows;\r
1060                 else if (*t == _T("mod0") ) mt = Modifier::Type_Mod0;\r
1061                 else if (*t == _T("mod1") ) mt = Modifier::Type_Mod1;\r
1062                 else if (*t == _T("mod2") ) mt = Modifier::Type_Mod2;\r
1063                 else if (*t == _T("mod3") ) mt = Modifier::Type_Mod3;\r
1064                 else if (*t == _T("mod4") ) mt = Modifier::Type_Mod4;\r
1065                 else if (*t == _T("mod5") ) mt = Modifier::Type_Mod5;\r
1066                 else if (*t == _T("mod6") ) mt = Modifier::Type_Mod6;\r
1067                 else if (*t == _T("mod7") ) mt = Modifier::Type_Mod7;\r
1068                 else if (*t == _T("mod8") ) mt = Modifier::Type_Mod8;\r
1069                 else if (*t == _T("mod9") ) mt = Modifier::Type_Mod9;\r
1070                 else throw ErrorMessage() << _T("`") << *t\r
1071                         << _T("': invalid modifier name.");\r
1072 \r
1073                 if (am == Keymap::AM_notModifier)\r
1074                         break;\r
1075 \r
1076                 m_currentKeymap->addModifier(mt, Keymap::AO_overwrite, am, NULL);\r
1077                 if (isEOL())\r
1078                         return;\r
1079                 t = getToken();\r
1080         }\r
1081 \r
1082         // <ASSIGN_OP>\r
1083         t = getToken();\r
1084         Keymap::AssignOperator ao;\r
1085         if      (*t == _T("=") ) ao = Keymap::AO_new;\r
1086         else if (*t == _T("+=")) ao = Keymap::AO_add;\r
1087         else if (*t == _T("-=")) ao = Keymap::AO_sub;\r
1088         else  throw ErrorMessage() << _T("`") << *t << _T("': is unknown operator.");\r
1089 \r
1090         // <ASSIGN_MODE>? <KEY_NAME>\r
1091         while (!isEOL()) {\r
1092                 // <ASSIGN_MODE>?\r
1093                 t = getToken();\r
1094                 Keymap::AssignMode am = Keymap::AM_normal;\r
1095                 if      (*t == _T("!")  ) am = Keymap::AM_true, t = getToken();\r
1096                 else if (*t == _T("!!") ) am = Keymap::AM_oneShot, t = getToken();\r
1097                 else if (*t == _T("!!!")) am = Keymap::AM_oneShotRepeatable, t = getToken();\r
1098 \r
1099                 // <KEY_NAME>\r
1100                 Key *key = m_setting->m_keyboard.searchKey(t->getString());\r
1101                 if (!key)\r
1102                         throw ErrorMessage() << _T("`") << *t << _T("': invalid key name.");\r
1103 \r
1104                 // we can ignore warning C4701\r
1105                 m_currentKeymap->addModifier(mt, ao, am, key);\r
1106                 if (ao == Keymap::AO_new)\r
1107                         ao = Keymap::AO_add;\r
1108         }\r
1109 }\r
1110 \r
1111 \r
1112 // <KEYSEQ_DEFINITION>\r
1113 void SettingLoader::load_KEYSEQ_DEFINITION()\r
1114 {\r
1115         if (*getToken() != _T("$"))\r
1116                 throw ErrorMessage() << _T("there must be `$' after `keyseq'");\r
1117         Token *name = getToken();\r
1118         if (*getToken() != _T("="))\r
1119                 throw ErrorMessage() << _T("there must be `=' after keyseq naem");\r
1120         load_KEY_SEQUENCE(name->getString(), false, Modifier::Type_ASSIGN);\r
1121 }\r
1122 \r
1123 \r
1124 // <DEFINE>\r
1125 void SettingLoader::load_DEFINE()\r
1126 {\r
1127         m_setting->m_symbols.insert(getToken()->getString());\r
1128 }\r
1129 \r
1130 \r
1131 // <IF>\r
1132 void SettingLoader::load_IF()\r
1133 {\r
1134         if (!getToken()->isOpenParen())\r
1135                 throw ErrorMessage() << _T("there must be `(' after `if'.");\r
1136         Token *t = getToken(); // <SYMBOL> or !\r
1137         bool not = false;\r
1138         if (*t == _T("!")) {\r
1139                 not = true;\r
1140                 t = getToken(); // <SYMBOL>\r
1141         }\r
1142 \r
1143         bool doesSymbolExist = (m_setting->m_symbols.find(t->getString())\r
1144                                                         != m_setting->m_symbols.end());\r
1145         bool doesRead = ((doesSymbolExist && !not) ||\r
1146                                          (!doesSymbolExist && not));\r
1147         if (0 < m_canReadStack.size())\r
1148                 doesRead = doesRead && m_canReadStack.back();\r
1149 \r
1150         if (!getToken()->isCloseParen())\r
1151                 throw ErrorMessage() << _T("there must be `)'.");\r
1152 \r
1153         m_canReadStack.push_back(doesRead);\r
1154         if (!isEOL()) {\r
1155                 size_t len = m_canReadStack.size();\r
1156                 load_LINE();\r
1157                 if (len < m_canReadStack.size()) {\r
1158                         bool r = m_canReadStack.back();\r
1159                         m_canReadStack.pop_back();\r
1160                         m_canReadStack[len - 1] = r && doesRead;\r
1161                 } else if (len == m_canReadStack.size())\r
1162                         m_canReadStack.pop_back();\r
1163                 else\r
1164                         ; // `end' found\r
1165         }\r
1166 }\r
1167 \r
1168 \r
1169 // <ELSE> <ELSEIF>\r
1170 void SettingLoader::load_ELSE(bool i_isElseIf, const tstringi &i_token)\r
1171 {\r
1172         bool doesRead = !load_ENDIF(i_token);\r
1173         if (0 < m_canReadStack.size())\r
1174                 doesRead = doesRead && m_canReadStack.back();\r
1175         m_canReadStack.push_back(doesRead);\r
1176         if (!isEOL()) {\r
1177                 size_t len = m_canReadStack.size();\r
1178                 if (i_isElseIf)\r
1179                         load_IF();\r
1180                 else\r
1181                         load_LINE();\r
1182                 if (len < m_canReadStack.size()) {\r
1183                         bool r = m_canReadStack.back();\r
1184                         m_canReadStack.pop_back();\r
1185                         m_canReadStack[len - 1] = doesRead && r;\r
1186                 } else if (len == m_canReadStack.size())\r
1187                         m_canReadStack.pop_back();\r
1188                 else\r
1189                         ; // `end' found\r
1190         }\r
1191 }\r
1192 \r
1193 \r
1194 // <ENDIF>\r
1195 bool SettingLoader::load_ENDIF(const tstringi &i_token)\r
1196 {\r
1197         if (m_canReadStack.size() == 0)\r
1198                 throw ErrorMessage() << _T("unbalanced `") << i_token << _T("'");\r
1199         bool r = m_canReadStack.back();\r
1200         m_canReadStack.pop_back();\r
1201         return r;\r
1202 }\r
1203 \r
1204 \r
1205 // <LINE>\r
1206 void SettingLoader::load_LINE()\r
1207 {\r
1208         Token *i_token = getToken();\r
1209 \r
1210         // <COND_SYMBOL>\r
1211         if      (*i_token == _T("if") ||\r
1212                          *i_token == _T("and")) load_IF();\r
1213         else if (*i_token == _T("else")) load_ELSE(false, i_token->getString());\r
1214         else if (*i_token == _T("elseif") ||\r
1215                          *i_token == _T("elsif")  ||\r
1216                          *i_token == _T("elif")   ||\r
1217                          *i_token == _T("or")) load_ELSE(true, i_token->getString());\r
1218         else if (*i_token == _T("endif")) load_ENDIF(_T("endif"));\r
1219         else if (0 < m_canReadStack.size() && !m_canReadStack.back()) {\r
1220                 while (!isEOL())\r
1221                         getToken();\r
1222         } else if (*i_token == _T("define")) load_DEFINE();\r
1223         // <INCLUDE>\r
1224         else if (*i_token == _T("include")) load_INCLUDE();\r
1225         // <KEYBOARD_DEFINITION>\r
1226         else if (*i_token == _T("def")) load_KEYBOARD_DEFINITION();\r
1227         // <KEYMAP_DEFINITION>\r
1228         else if (*i_token == _T("keymap")  ||\r
1229                          *i_token == _T("keymap2") ||\r
1230                          *i_token == _T("window")) load_KEYMAP_DEFINITION(i_token);\r
1231         // <KEY_ASSIGN>\r
1232         else if (*i_token == _T("key")) load_KEY_ASSIGN();\r
1233         // <EVENT_ASSIGN>\r
1234         else if (*i_token == _T("event")) load_EVENT_ASSIGN();\r
1235         // <MODIFIER_ASSIGNMENT>\r
1236         else if (*i_token == _T("mod")) load_MODIFIER_ASSIGNMENT();\r
1237         // <KEYSEQ_DEFINITION>\r
1238         else if (*i_token == _T("keyseq")) load_KEYSEQ_DEFINITION();\r
1239         else\r
1240                 throw ErrorMessage() << _T("syntax error `") << *i_token << _T("'.");\r
1241 }\r
1242 \r
1243 \r
1244 // prefix sort predicate used in load(const string &)\r
1245 static bool prefixSortPred(const tstringi &i_a, const tstringi &i_b)\r
1246 {\r
1247         return i_b.size() < i_a.size();\r
1248 }\r
1249 \r
1250 \r
1251 /*\r
1252   _UNICODE: read file (UTF-16 LE/BE, UTF-8, locale specific multibyte encoding)\r
1253   _MBCS: read file\r
1254 */\r
1255 bool readFile(tstring *o_data, const tstringi &i_filename)\r
1256 {\r
1257         // get size of file\r
1258 #if 0\r
1259         // bcc's _wstat cannot obtain file size\r
1260         struct _stat sbuf;\r
1261         if (_tstat(i_filename.c_str(), &sbuf) < 0 || sbuf.st_size == 0)\r
1262                 return false;\r
1263 #else\r
1264         // so, we use _wstati64 for bcc\r
1265         struct stati64_t sbuf;\r
1266         if (_tstati64(i_filename.c_str(), &sbuf) < 0 || sbuf.st_size == 0)\r
1267                 return false;\r
1268         // following check is needed to cast sbuf.st_size to size_t safely\r
1269         // this cast occurs because of above workaround for bcc\r
1270         if (sbuf.st_size > UINT_MAX)\r
1271                 return false;\r
1272 #endif\r
1273 \r
1274         // open\r
1275         FILE *fp = _tfopen(i_filename.c_str(), _T("rb"));\r
1276         if (!fp)\r
1277                 return false;\r
1278 \r
1279         // read file\r
1280         Array<BYTE> buf(static_cast<size_t>(sbuf.st_size) + 1);\r
1281         if (fread(buf.get(), static_cast<size_t>(sbuf.st_size), 1, fp) != 1) {\r
1282                 fclose(fp);\r
1283                 return false;\r
1284         }\r
1285         buf.get()[sbuf.st_size] = 0;                    // mbstowcs() requires null\r
1286         // terminated string\r
1287 \r
1288 #ifdef _UNICODE\r
1289         //\r
1290         if (buf.get()[0] == 0xffU && buf.get()[1] == 0xfeU &&\r
1291                         sbuf.st_size % 2 == 0)\r
1292                 // UTF-16 Little Endien\r
1293         {\r
1294                 size_t size = static_cast<size_t>(sbuf.st_size) / 2;\r
1295                 o_data->resize(size);\r
1296                 BYTE *p = buf.get();\r
1297                 for (size_t i = 0; i < size; ++ i) {\r
1298                         wchar_t c = static_cast<wchar_t>(*p ++);\r
1299                         c |= static_cast<wchar_t>(*p ++) << 8;\r
1300                         (*o_data)[i] = c;\r
1301                 }\r
1302                 fclose(fp);\r
1303                 return true;\r
1304         }\r
1305 \r
1306         //\r
1307         if (buf.get()[0] == 0xfeU && buf.get()[1] == 0xffU &&\r
1308                         sbuf.st_size % 2 == 0)\r
1309                 // UTF-16 Big Endien\r
1310         {\r
1311                 size_t size = static_cast<size_t>(sbuf.st_size) / 2;\r
1312                 o_data->resize(size);\r
1313                 BYTE *p = buf.get();\r
1314                 for (size_t i = 0; i < size; ++ i) {\r
1315                         wchar_t c = static_cast<wchar_t>(*p ++) << 8;\r
1316                         c |= static_cast<wchar_t>(*p ++);\r
1317                         (*o_data)[i] = c;\r
1318                 }\r
1319                 fclose(fp);\r
1320                 return true;\r
1321         }\r
1322 \r
1323         // try multibyte charset\r
1324         size_t wsize = mbstowcs(NULL, reinterpret_cast<char *>(buf.get()), 0);\r
1325         if (wsize != size_t(-1)) {\r
1326                 Array<wchar_t> wbuf(wsize);\r
1327                 mbstowcs(wbuf.get(), reinterpret_cast<char *>(buf.get()), wsize);\r
1328                 o_data->assign(wbuf.get(), wbuf.get() + wsize);\r
1329                 fclose(fp);\r
1330                 return true;\r
1331         }\r
1332 \r
1333         // try UTF-8\r
1334         {\r
1335                 Array<wchar_t> wbuf(static_cast<size_t>(sbuf.st_size));\r
1336                 BYTE *f = buf.get();\r
1337                 BYTE *end = buf.get() + sbuf.st_size;\r
1338                 wchar_t *d = wbuf.get();\r
1339                 enum { STATE_1, STATE_2of2, STATE_2of3, STATE_3of3 } state = STATE_1;\r
1340 \r
1341                 while (f != end) {\r
1342                         switch (state) {\r
1343                         case STATE_1:\r
1344                                 if (!(*f & 0x80))                       // 0xxxxxxx: 00-7F\r
1345                                         *d++ = static_cast<wchar_t>(*f++);\r
1346                                 else if ((*f & 0xe0) == 0xc0) { // 110xxxxx 10xxxxxx: 0080-07FF\r
1347                                         *d = ((static_cast<wchar_t>(*f++) & 0x1f) << 6);\r
1348                                         state = STATE_2of2;\r
1349                                 } else if ((*f & 0xf0) == 0xe0)         // 1110xxxx 10xxxxxx 10xxxxxx:\r
1350                                         // 0800 - FFFF\r
1351                                 {\r
1352                                         *d = ((static_cast<wchar_t>(*f++) & 0x0f) << 12);\r
1353                                         state = STATE_2of3;\r
1354                                 } else\r
1355                                         goto not_UTF_8;\r
1356                                 break;\r
1357 \r
1358                         case STATE_2of2:\r
1359                         case STATE_3of3:\r
1360                                 if ((*f & 0xc0) != 0x80)\r
1361                                         goto not_UTF_8;\r
1362                                 *d++ |= (static_cast<wchar_t>(*f++) & 0x3f);\r
1363                                 state = STATE_1;\r
1364                                 break;\r
1365 \r
1366                         case STATE_2of3:\r
1367                                 if ((*f & 0xc0) != 0x80)\r
1368                                         goto not_UTF_8;\r
1369                                 *d |= ((static_cast<wchar_t>(*f++) & 0x3f) << 6);\r
1370                                 state = STATE_3of3;\r
1371                                 break;\r
1372                         }\r
1373                 }\r
1374                 o_data->assign(wbuf.get(), d);\r
1375                 fclose(fp);\r
1376                 return true;\r
1377 \r
1378 not_UTF_8:\r
1379                 ;\r
1380         }\r
1381 #endif // _UNICODE\r
1382 \r
1383         // assume ascii\r
1384         o_data->resize(static_cast<size_t>(sbuf.st_size));\r
1385         for (off_t i = 0; i < sbuf.st_size; ++ i)\r
1386                 (*o_data)[i] = buf.get()[i];\r
1387         fclose(fp);\r
1388         return true;\r
1389 }\r
1390 \r
1391 \r
1392 // load (called from load(Setting *, const tstringi &) only)\r
1393 void SettingLoader::load(const tstringi &i_filename)\r
1394 {\r
1395         m_currentFilename = i_filename;\r
1396 \r
1397         tstring data;\r
1398         if (!readFile(&data, m_currentFilename)) {\r
1399                 Acquire a(m_soLog);\r
1400                 *m_log << m_currentFilename << _T(" : error: file not found") << std::endl;\r
1401 #if 1\r
1402                 *m_log << data << std::endl;\r
1403 #endif\r
1404                 m_isThereAnyError = true;\r
1405                 return;\r
1406         }\r
1407 \r
1408         // prefix\r
1409         if (m_prefixesRefCcount == 0) {\r
1410                 static const _TCHAR *prefixes[] = {\r
1411                         _T("="), _T("=>"), _T("&&"), _T("||"), _T(":"), _T("$"), _T("&"),\r
1412                         _T("-="), _T("+="), _T("!!!"), _T("!!"), _T("!"),\r
1413                         _T("E0-"), _T("E1-"),                   // <SCAN_CODE_EXTENTION>\r
1414                         _T("S-"), _T("A-"), _T("M-"), _T("C-"), // <BASIC_MODIFIER>\r
1415                         _T("W-"), _T("*"), _T("~"),\r
1416                         _T("U-"), _T("D-"),                     // <KEYSEQ_MODIFIER>\r
1417                         _T("R-"), _T("IL-"), _T("IC-"), _T("I-"),       // <ASSIGN_MODIFIER>\r
1418                         _T("NL-"), _T("CL-"), _T("SL-"), _T("KL-"),\r
1419                         _T("MAX-"), _T("MIN-"), _T("MMAX-"), _T("MMIN-"),\r
1420                         _T("T-"), _T("TS-"),\r
1421                         _T("M0-"), _T("M1-"), _T("M2-"), _T("M3-"), _T("M4-"),\r
1422                         _T("M5-"), _T("M6-"), _T("M7-"), _T("M8-"), _T("M9-"),\r
1423                         _T("L0-"), _T("L1-"), _T("L2-"), _T("L3-"), _T("L4-"),\r
1424                         _T("L5-"), _T("L6-"), _T("L7-"), _T("L8-"), _T("L9-"),\r
1425                 };\r
1426                 m_prefixes = new std::vector<tstringi>;\r
1427                 for (size_t i = 0; i < NUMBER_OF(prefixes); ++ i)\r
1428                         m_prefixes->push_back(prefixes[i]);\r
1429                 std::sort(m_prefixes->begin(), m_prefixes->end(), prefixSortPred);\r
1430         }\r
1431         m_prefixesRefCcount ++;\r
1432 \r
1433         // create parser\r
1434         Parser parser(data.c_str(), data.size());\r
1435         parser.setPrefixes(m_prefixes);\r
1436 \r
1437         while (true) {\r
1438                 try {\r
1439                         if (!parser.getLine(&m_tokens))\r
1440                                 break;\r
1441                         m_ti = m_tokens.begin();\r
1442                 } catch (ErrorMessage &e) {\r
1443                         if (m_log && m_soLog) {\r
1444                                 Acquire a(m_soLog);\r
1445                                 *m_log << m_currentFilename << _T("(") << parser.getLineNumber()\r
1446                                 << _T(") : error: ") << e << std::endl;\r
1447                         }\r
1448                         m_isThereAnyError = true;\r
1449                         continue;\r
1450                 }\r
1451 \r
1452                 try {\r
1453                         load_LINE();\r
1454                         if (!isEOL())\r
1455                                 throw WarningMessage() << _T("back garbage is ignored.");\r
1456                 } catch (WarningMessage &w) {\r
1457                         if (m_log && m_soLog) {\r
1458                                 Acquire a(m_soLog);\r
1459                                 *m_log << i_filename << _T("(") << parser.getLineNumber()\r
1460                                 << _T(") : warning: ") << w << std::endl;\r
1461                         }\r
1462                 } catch (ErrorMessage &e) {\r
1463                         if (m_log && m_soLog) {\r
1464                                 Acquire a(m_soLog);\r
1465                                 *m_log << i_filename << _T("(") << parser.getLineNumber()\r
1466                                 << _T(") : error: ") << e << std::endl;\r
1467                         }\r
1468                         m_isThereAnyError = true;\r
1469                 }\r
1470         }\r
1471 \r
1472         // m_prefixes\r
1473         -- m_prefixesRefCcount;\r
1474         if (m_prefixesRefCcount == 0)\r
1475                 delete m_prefixes;\r
1476 \r
1477         if (0 < m_canReadStack.size()) {\r
1478                 Acquire a(m_soLog);\r
1479                 *m_log << m_currentFilename << _T("(") << parser.getLineNumber()\r
1480                 << _T(") : error: unbalanced `if'.  ")\r
1481                 << _T("you forget `endif', didn'i_token you?")\r
1482                 << std::endl;\r
1483                 m_isThereAnyError = true;\r
1484         }\r
1485 }\r
1486 \r
1487 \r
1488 // is the filename readable ?\r
1489 bool SettingLoader::isReadable(const tstringi &i_filename,\r
1490                                                            int i_debugLevel) const\r
1491 {\r
1492         if (i_filename.empty())\r
1493                 return false;\r
1494 #ifdef UNICODE\r
1495         tifstream ist(to_string(i_filename).c_str());\r
1496 #else\r
1497         tifstream ist(i_filename.c_str());\r
1498 #endif\r
1499         if (ist.good()) {\r
1500                 if (m_log && m_soLog) {\r
1501                         Acquire a(m_soLog, 0);\r
1502                         *m_log << _T("  loading: ") << i_filename << std::endl;\r
1503                 }\r
1504                 return true;\r
1505         } else {\r
1506                 if (m_log && m_soLog) {\r
1507                         Acquire a(m_soLog, i_debugLevel);\r
1508                         *m_log << _T("not found: ") << i_filename << std::endl;\r
1509                 }\r
1510                 return false;\r
1511         }\r
1512 }\r
1513 \r
1514 #if 0\r
1515 // get filename from registry\r
1516 bool SettingLoader::getFilenameFromRegistry(tstringi *o_path) const\r
1517 {\r
1518         // get from registry\r
1519         Registry reg(MAYU_REGISTRY_ROOT);\r
1520         int index;\r
1521         reg.read(_T(".mayuIndex"), &index, 0);\r
1522         char buf[100];\r
1523         snprintf(buf, NUMBER_OF(buf), _T(".mayu%d"), index);\r
1524         if (!reg.read(buf, o_path))\r
1525                 return false;\r
1526 \r
1527         // parse registry entry\r
1528         Regexp getFilename(_T("^[^;]*;([^;]*);(.*)$"));\r
1529         if (!getFilename.doesMatch(*o_path))\r
1530                 return false;\r
1531 \r
1532         tstringi path = getFilename[1];\r
1533         tstringi options = getFilename[2];\r
1534 \r
1535         if (!(0 < path.size() && isReadable(path)))\r
1536                 return false;\r
1537         *o_path = path;\r
1538 \r
1539         // set symbols\r
1540         Regexp symbol(_T("-D([^;]*)"));\r
1541         while (symbol.doesMatch(options)) {\r
1542                 m_setting->symbols.insert(symbol[1]);\r
1543                 options = options.substr(symbol.subBegin(1));\r
1544         }\r
1545 \r
1546         return true;\r
1547 }\r
1548 #endif\r
1549 \r
1550 \r
1551 // get filename\r
1552 bool SettingLoader::getFilename(const tstringi &i_name, tstringi *o_path,\r
1553                                                                 int i_debugLevel) const\r
1554 {\r
1555         // the default filename is ".mayu"\r
1556         const tstringi &name = i_name.empty() ? tstringi(_T(".mayu")) : i_name;\r
1557 \r
1558         bool isFirstTime = true;\r
1559 \r
1560         while (true) {\r
1561                 // find file from registry\r
1562                 if (i_name.empty()) {                   // called not from 'include'\r
1563                         Setting::Symbols symbols;\r
1564                         if (getFilenameFromRegistry(NULL, o_path, &symbols)) {\r
1565                                 if (o_path->empty())\r
1566                                         // find file from home directory\r
1567                                 {\r
1568                                         HomeDirectories pathes;\r
1569                                         getHomeDirectories(&pathes);\r
1570                                         for (HomeDirectories::iterator\r
1571                                                         i = pathes.begin(); i != pathes.end(); ++ i) {\r
1572                                                 *o_path = *i + _T("\\") + name;\r
1573                                                 if (isReadable(*o_path, i_debugLevel))\r
1574                                                         goto add_symbols;\r
1575                                         }\r
1576                                         return false;\r
1577                                 } else {\r
1578                                         if (!isReadable(*o_path, i_debugLevel))\r
1579                                                 return false;\r
1580                                 }\r
1581 add_symbols:\r
1582                                 for (Setting::Symbols::iterator\r
1583                                                 i = symbols.begin(); i != symbols.end(); ++ i)\r
1584                                         m_setting->m_symbols.insert(*i);\r
1585                                 return true;\r
1586                         }\r
1587                 }\r
1588 \r
1589                 if (!isFirstTime)\r
1590                         return false;\r
1591 \r
1592                 // find file from home directory\r
1593                 HomeDirectories pathes;\r
1594                 getHomeDirectories(&pathes);\r
1595                 for (HomeDirectories::iterator i = pathes.begin(); i != pathes.end(); ++ i) {\r
1596                         *o_path = *i + _T("\\") + name;\r
1597                         if (isReadable(*o_path, i_debugLevel))\r
1598                                 return true;\r
1599                 }\r
1600 \r
1601                 if (!i_name.empty())\r
1602                         return false;                           // called by 'include'\r
1603 \r
1604                 if (!DialogBox(g_hInst, MAKEINTRESOURCE(IDD_DIALOG_setting),\r
1605                                            NULL, dlgSetting_dlgProc))\r
1606                         return false;\r
1607         }\r
1608 }\r
1609 \r
1610 \r
1611 // constructor\r
1612 SettingLoader::SettingLoader(SyncObject *i_soLog, tostream *i_log)\r
1613                 : m_setting(NULL),\r
1614                 m_isThereAnyError(false),\r
1615                 m_soLog(i_soLog),\r
1616                 m_log(i_log),\r
1617                 m_currentKeymap(NULL)\r
1618 {\r
1619         m_defaultKeySeqModifier =\r
1620                 m_defaultAssignModifier.release(Modifier::Type_ImeComp);\r
1621 }\r
1622 \r
1623 \r
1624 /* load m_setting\r
1625    If called by "include", 'filename' describes filename.\r
1626    Otherwise the 'filename' is empty.\r
1627  */\r
1628 bool SettingLoader::load(Setting *i_setting, const tstringi &i_filename)\r
1629 {\r
1630         m_setting = i_setting;\r
1631         m_isThereAnyError = false;\r
1632 \r
1633         tstringi path;\r
1634         if (!getFilename(i_filename, &path)) {\r
1635                 if (i_filename.empty()) {\r
1636                         Acquire a(m_soLog);\r
1637                         getFilename(i_filename, &path, 0);      // show filenames\r
1638                         return false;\r
1639                 } else\r
1640                         throw ErrorMessage() << _T("`") << i_filename\r
1641                         << _T("': no such file or other error.");\r
1642         }\r
1643 \r
1644         // create global keymap's default keySeq\r
1645         ActionFunction af(createFunctionData(_T("OtherWindowClass")));\r
1646         KeySeq *globalDefault = m_setting->m_keySeqs.add(KeySeq(_T("")).add(af));\r
1647 \r
1648         // add default keymap\r
1649         m_currentKeymap = m_setting->m_keymaps.add(\r
1650                                                   Keymap(Keymap::Type_windowOr, _T("Global"), _T(""), _T(""),\r
1651                                                                  globalDefault, NULL));\r
1652 \r
1653         /*\r
1654         // add keyboard layout name\r
1655         if (filename.empty())\r
1656         {\r
1657           char keyboardLayoutName[KL_NAMELENGTH];\r
1658           if (GetKeyboardLayoutName(keyboardLayoutName))\r
1659           {\r
1660             tstringi kl = tstringi(_T("KeyboardLayout/")) + keyboardLayoutName;\r
1661             m_setting->symbols.insert(kl);\r
1662             Acquire a(m_soLog);\r
1663             *m_log << _T("KeyboardLayout: ") << kl << std::endl;\r
1664           }\r
1665         }\r
1666         */\r
1667 \r
1668         // load\r
1669         load(path);\r
1670 \r
1671         // finalize\r
1672         if (i_filename.empty())\r
1673                 m_setting->m_keymaps.adjustModifier(m_setting->m_keyboard);\r
1674 \r
1675         return !m_isThereAnyError;\r
1676 }\r
1677 \r
1678 \r
1679 std::vector<tstringi> *SettingLoader::m_prefixes; // m_prefixes terminal symbol\r
1680 size_t SettingLoader::m_prefixesRefCcount;      /* reference count of\r
1681                                                    m_prefixes */\r