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