src/apps/codycam/SettingsHandler.cpp

   1 #include "SettingsHandler.h"
   2
   3 #include <stdarg.h>
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7
   8 #include <Catalog.h>
   9 #include <Debug.h>
  10 #include <Directory.h>
  11 #include <Entry.h>
  12 #include <File.h>
  13 #include <FindDirectory.h>
  14 #include <Locale.h>
  15 #include <Path.h>
  16 #include <StopWatch.h>
  17
  18
  19 #undef B_TRANSLATION_CONTEXT
  20 #define B_TRANSLATION_CONTEXT "SettingsHandler"
  21
  22
  23 #if 0
  24 static int
  25 Compare(const SettingsArgvDispatcher* p1, const SettingsArgvDispatcher* p2)
  26 {
  27         return strcmp(p1->Name(), p2->Name());
  28 }
  29 #endif
  30
  31
  32 #if 0
  33 static int
  34 CompareByNameOne(const SettingsArgvDispatcher* item1,
  35         const SettingsArgvDispatcher* item2)
  36 {
  37         return strcmp(item1->Name(), item2->Name());
  38 }
  39 #endif
  40
  41
  42 /*! \class ArgvParser
  43         ArgvParser class opens a text file and passes the context in argv
  44         format to a specified handler
  45 */
  46
  47
  48 ArgvParser::ArgvParser(const char* name)
  49         :
  50         fFile(0),
  51         fBuffer(0),
  52         fPos(-1),
  53         fArgc(0),
  54         fCurrentArgv(0),
  55         fCurrentArgsPos(-1),
  56         fSawBackslash(false),
  57         fEatComment(false),
  58         fInDoubleQuote(false),
  59         fInSingleQuote(false),
  60         fLineNo(0),
  61         fFileName(name)
  62 {
  63         fFile = fopen(fFileName, "r");
  64         if (!fFile) {
  65                 PRINT((B_TRANSLATE("Error opening %s\n"), fFileName));
  66                 return;
  67         }
  68         fBuffer = new char [kBufferSize];
  69         fCurrentArgv = new char* [1024];
  70 }
  71
  72
  73 ArgvParser::~ArgvParser()
  74 {
  75         delete[] fBuffer;
  76
  77         MakeArgvEmpty();
  78         delete [] fCurrentArgv;
  79
  80         if (fFile)
  81                 fclose(fFile);
  82 }
  83
  84
  85 void
  86 ArgvParser::MakeArgvEmpty()
  87 {
  88         // done with current argv, free it up
  89         for (int32 index = 0; index < fArgc; index++)
  90                 delete fCurrentArgv[index];
  91
  92         fArgc = 0;
  93 }
  94
  95
  96 status_t
  97 ArgvParser::SendArgv(ArgvHandler argvHandlerFunc, void* passThru)
  98 {
  99         if (fArgc) {
 100                 NextArgv();
 101                 fCurrentArgv[fArgc] = 0;
 102                 const char *result = (argvHandlerFunc)(fArgc, fCurrentArgv, passThru);
 103                 if (result)
 104                         printf(B_TRANSLATE("File %s; Line %ld # %s"), fFileName, fLineNo, result);
 105                 MakeArgvEmpty();
 106                 if (result)
 107                         return B_ERROR;
 108         }
 109
 110         return B_NO_ERROR;
 111 }
 112
 113
 114 void
 115 ArgvParser::NextArgv()
 116 {
 117         if (fSawBackslash) {
 118                 fCurrentArgs[++fCurrentArgsPos] = '\\';
 119                 fSawBackslash = false;
 120         }
 121         fCurrentArgs[++fCurrentArgsPos] = '\0';
 122                 // terminate current arg pos
 123
 124         // copy it as a string to the current argv slot
 125         fCurrentArgv[fArgc] = new char [strlen(fCurrentArgs) + 1];
 126         strcpy(fCurrentArgv[fArgc], fCurrentArgs);
 127         fCurrentArgsPos = -1;
 128         fArgc++;
 129 }
 130
 131
 132 void
 133 ArgvParser::NextArgvIfNotEmpty()
 134 {
 135         if (!fSawBackslash && fCurrentArgsPos < 0)
 136                 return;
 137
 138         NextArgv();
 139 }
 140
 141
 142 char
 143 ArgvParser::GetCh()
 144 {
 145         if (fPos < 0 || fBuffer[fPos] == 0) {
 146                 if (fFile == 0)
 147                         return EOF;
 148                 if (fgets(fBuffer, kBufferSize, fFile) == 0)
 149                         return EOF;
 150                 fPos = 0;
 151         }
 152         return fBuffer[fPos++];
 153 }
 154
 155
 156 status_t
 157 ArgvParser::EachArgv(const char* name, ArgvHandler argvHandlerFunc,
 158         void* passThru)
 159 {
 160         ArgvParser parser(name);
 161         return parser.EachArgvPrivate(name, argvHandlerFunc, passThru);
 162 }
 163
 164
 165 status_t
 166 ArgvParser::EachArgvPrivate(const char* name, ArgvHandler argvHandlerFunc,
 167         void* passThru)
 168 {
 169         status_t result;
 170
 171         for (;;) {
 172                 char ch = GetCh();
 173                 if (ch == EOF) {
 174                         // done with file
 175                         if (fInDoubleQuote || fInSingleQuote) {
 176                                 printf(B_TRANSLATE("File %s # unterminated quote at end of "
 177                                         "file\n"), name);
 178                                 result = B_ERROR;
 179                                 break;
 180                         }
 181                         result = SendArgv(argvHandlerFunc, passThru);
 182                         break;
 183                 }
 184
 185                 if (ch == '\n' || ch == '\r') {
 186                         // handle new line
 187                         fEatComment = false;
 188                         if (!fSawBackslash && (fInDoubleQuote || fInSingleQuote)) {
 189                                 printf(B_TRANSLATE("File %s ; Line %ld # unterminated "
 190                                         "quote\n"), name, fLineNo);
 191                                 result = B_ERROR;
 192                                 break;
 193                         }
 194                         fLineNo++;
 195                         if (fSawBackslash) {
 196                                 fSawBackslash = false;
 197                                 continue;
 198                         }
 199                         // end of line, flush all argv
 200                         result = SendArgv(argvHandlerFunc, passThru);
 201                         if (result != B_NO_ERROR)
 202                                 break;
 203                         continue;
 204                 }
 205
 206                 if (fEatComment)
 207                         continue;
 208
 209                 if (!fSawBackslash) {
 210                         if (!fInDoubleQuote && !fInSingleQuote) {
 211                                 if (ch == ';') {
 212                                         // semicolon is a command separator, pass on the whole argv
 213                                         result = SendArgv(argvHandlerFunc, passThru);
 214                                         if (result != B_NO_ERROR)
 215                                                 break;
 216                                         continue;
 217                                 } else if (ch == '#') {
 218                                         // ignore everything on this line after this character
 219                                         fEatComment = true;
 220                                         continue;
 221                                 } else if (ch == ' ' || ch == '\t') {
 222                                         // space or tab separates the individual arg strings
 223                                         NextArgvIfNotEmpty();
 224                                         continue;
 225                                 } else if (!fSawBackslash && ch == '\\') {
 226                                         // the next character is escaped
 227                                         fSawBackslash = true;
 228                                         continue;
 229                                 }
 230                         }
 231                         if (!fInSingleQuote && ch == '"') {
 232                                 // enter/exit double quote handling
 233                                 fInDoubleQuote = !fInDoubleQuote;
 234                                 continue;
 235                         }
 236                         if (!fInDoubleQuote && ch == '\'') {
 237                                 // enter/exit single quote handling
 238                                 fInSingleQuote = !fInSingleQuote;
 239                                 continue;
 240                         }
 241                 } else {
 242                         // we just pass through the escape sequence as is
 243                         fCurrentArgs[++fCurrentArgsPos] = '\\';
 244                         fSawBackslash = false;
 245                 }
 246                 fCurrentArgs[++fCurrentArgsPos] = ch;
 247         }
 248
 249         return result;
 250 }
 251
 252
 253 //      #pragma mark -
 254
 255
 256 SettingsArgvDispatcher::SettingsArgvDispatcher(const char* name)
 257         :
 258         fName(name)
 259 {
 260 }
 261
 262
 263 void
 264 SettingsArgvDispatcher::SaveSettings(Settings* settings, bool onlyIfNonDefault)
 265 {
 266         if (!onlyIfNonDefault || NeedsSaving()) {
 267                 settings->Write("%s ", Name());
 268                 SaveSettingValue(settings);
 269                 settings->Write("\n");
 270         }
 271 }
 272
 273
 274 bool
 275 SettingsArgvDispatcher::HandleRectValue(BRect &result, const char* const *argv,
 276         bool printError)
 277 {
 278         if (!*argv) {
 279                 if (printError)
 280                         printf("rect left expected");
 281                 return false;
 282         }
 283         result.left = atoi(*argv);
 284         if (!*++argv) {
 285                 if (printError)
 286                         printf("rect top expected");
 287                 return false;
 288         }
 289         result.top = atoi(*argv);
 290         if (!*++argv) {
 291                 if (printError)
 292                         printf("rect right expected");
 293                 return false;
 294         }
 295         result.right = atoi(*argv);
 296         if (!*++argv) {
 297                 if (printError)
 298                         printf("rect bottom expected");
 299                 return false;
 300         }
 301         result.bottom = atoi(*argv);
 302         return true;
 303 }
 304
 305
 306 void
 307 SettingsArgvDispatcher::WriteRectValue(Settings* setting, BRect rect)
 308 {
 309         setting->Write("%d %d %d %d", (int32)rect.left, (int32)rect.top,
 310                 (int32)rect.right, (int32)rect.bottom);
 311 }
 312
 313
 314 //      #pragma mark -
 315
 316
 317 /*!     \class Settings
 318         this class represents a list of all the settings handlers, reads and
 319         saves the settings file
 320 */
 321
 322
 323 Settings::Settings(const char* filename, const char* settingsDirName)
 324         :
 325         fFileName(filename),
 326         fSettingsDir(settingsDirName),
 327         fList(0),
 328         fCount(0),
 329         fListSize(30),
 330         fCurrentSettings(0)
 331 {
 332 #ifdef SINGLE_SETTING_FILE
 333         settingsHandler = this;
 334 #endif
 335         fList = (SettingsArgvDispatcher**)calloc(fListSize, sizeof(SettingsArgvDispatcher *));
 336 }
 337
 338
 339 Settings::~Settings()
 340 {
 341         for (int32 index = 0; index < fCount; index++)
 342                 delete fList[index];
 343
 344         free(fList);
 345 }
 346
 347
 348 const char*
 349 Settings::_ParseUserSettings(int, const char* const *argv, void* castToThis)
 350 {
 351         if (!*argv)
 352                 return 0;
 353
 354 #ifdef SINGLE_SETTING_FILE
 355         Settings* settings = settingsHandler;
 356 #else
 357         Settings* settings = (Settings*)castToThis;
 358 #endif
 359
 360         SettingsArgvDispatcher* handler = settings->_Find(*argv);
 361         if (!handler)
 362                 return B_TRANSLATE("unknown command");
 363         return handler->Handle(argv);
 364 }
 365
 366
 367 /*!
 368         Returns false if argv dispatcher with the same name already
 369         registered
 370 */
 371 bool
 372 Settings::Add(SettingsArgvDispatcher* setting)
 373 {
 374         // check for uniqueness
 375         if (_Find(setting->Name()))
 376                 return false;
 377
 378         if (fCount >= fListSize) {
 379                 fListSize += 30;
 380                 fList = (SettingsArgvDispatcher **)realloc(fList,
 381                         fListSize * sizeof(SettingsArgvDispatcher *));
 382         }
 383         fList[fCount++] = setting;
 384         return true;
 385 }
 386
 387
 388 SettingsArgvDispatcher*
 389 Settings::_Find(const char* name)
 390 {
 391         for (int32 index = 0; index < fCount; index++)
 392                 if (strcmp(name, fList[index]->Name()) == 0)
 393                         return fList[index];
 394
 395         return 0;
 396 }
 397
 398
 399 void
 400 Settings::TryReadingSettings()
 401 {
 402         BPath prefsPath;
 403         if (find_directory(B_USER_SETTINGS_DIRECTORY, &prefsPath, true) == B_OK) {
 404                 prefsPath.Append(fSettingsDir);
 405
 406                 BPath path(prefsPath);
 407                 path.Append(fFileName);
 408                 ArgvParser::EachArgv(path.Path(), Settings::_ParseUserSettings, this);
 409         }
 410 }
 411
 412
 413 void
 414 Settings::SaveSettings(bool onlyIfNonDefault)
 415 {
 416         ASSERT(SettingsHandler());
 417         SettingsHandler()->_SaveCurrentSettings(onlyIfNonDefault);
 418 }
 419
 420
 421 void
 422 Settings::_MakeSettingsDirectory(BDirectory *resultingSettingsDir)
 423 {
 424         BPath path;
 425         if (find_directory(B_USER_SETTINGS_DIRECTORY, &path, true) != B_OK)
 426                 return;
 427
 428         // make sure there is a directory
 429         path.Append(fSettingsDir);
 430         mkdir(path.Path(), 0777);
 431         resultingSettingsDir->SetTo(path.Path());
 432 }
 433
 434
 435 void
 436 Settings::_SaveCurrentSettings(bool onlyIfNonDefault)
 437 {
 438         BDirectory fSettingsDir;
 439         _MakeSettingsDirectory(&fSettingsDir);
 440
 441         if (fSettingsDir.InitCheck() != B_OK)
 442                 return;
 443
 444         printf("+++++++++++ Settings::_SaveCurrentSettings %s\n", fFileName);
 445         // nuke old settings
 446         BEntry entry(&fSettingsDir, fFileName);
 447         entry.Remove();
 448
 449         BFile prefs(&entry, O_RDWR | O_CREAT);
 450         if (prefs.InitCheck() != B_OK)
 451                 return;
 452
 453         fCurrentSettings = &prefs;
 454         for (int32 index = 0; index < fCount; index++) {
 455                 fList[index]->SaveSettings(this, onlyIfNonDefault);
 456         }
 457
 458         fCurrentSettings = 0;
 459 }
 460
 461
 462 void
 463 Settings::Write(const char* format, ...)
 464 {
 465         va_list args;
 466
 467         va_start(args, format);
 468         VSWrite(format, args);
 469         va_end(args);
 470 }
 471
 472
 473 void
 474 Settings::VSWrite(const char* format, va_list arg)
 475 {
 476         char buffer[2048];
 477         vsprintf(buffer, format, arg);
 478         ASSERT(fCurrentSettings && fCurrentSettings->InitCheck() == B_OK);
 479         fCurrentSettings->Write(buffer, strlen(buffer));
 480 }
 481
 482
 483 #ifdef SINGLE_SETTING_FILE
 484 Settings* Settings::settingsHandler = 0;
 485 #endif