rt/gc/cdgc/opts.d

   1 /**
   2  * This module contains the options managemente code of the garbage collector.
   3  *
   4  * Copyright: Copyright (C) 2010 Leandro Lucarella <http://www.llucax.com.ar/>
   5  *            All rights reserved.
   6  *
   7  * License: Boost Software License - Version 1.0 - August 17th, 2003
   8  *
   9  * Permission is hereby granted, free of charge, to any person or organization
  10  * obtaining a copy of the software and accompanying documentation covered by
  11  * this license (the "Software") to use, reproduce, display, distribute,
  12  * execute, and transmit the Software, and to prepare derivative works of the
  13  * Software, and to permit third-parties to whom the Software is furnished to
  14  * do so, all subject to the following:
  15  *
  16  * The copyright notices in the Software and this entire statement, including
  17  * the above license grant, this restriction and the following disclaimer,
  18  * must be included in all copies of the Software, in whole or in part, and
  19  * all derivative works of the Software, unless such copies or derivative
  20  * works are solely in the form of machine-executable object code generated by
  21  * a source language processor.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  24  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  25  * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
  26  * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
  27  * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
  28  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  29  * DEALINGS IN THE SOFTWARE.
  30  *
  31  * Authors: Leandro Lucarella
  32  */
  33
  34 module rt.gc.cdgc.opts;
  35
  36 import cstdlib = tango.stdc.stdlib;
  37 import cstring = tango.stdc.string;
  38
  39
  40 private:
  41
  42
  43 const MAX_OPT_LEN = 256;
  44
  45
  46 struct Options
  47 {
  48     uint verbose = 0;
  49     char[MAX_OPT_LEN] log_file = "";
  50     char[MAX_OPT_LEN] malloc_stats_file = "";
  51     char[MAX_OPT_LEN] collect_stats_file = "";
  52     bool sentinel = false;
  53     bool mem_stomp = false;
  54     bool conservative = false;
  55     bool fork = true;
  56 }
  57
  58 package Options options;
  59
  60
  61 bool cstr_eq(char* s1, char* s2)
  62 {
  63     return cstring.strcmp(s1, s2) == 0;
  64 }
  65
  66
  67 bool parse_bool(char* value)
  68 {
  69     if (value[0] == '\0')
  70         return true;
  71     return (cstdlib.atoi(value) != 0);
  72 }
  73
  74
  75 void process_option(char* opt_name, char* opt_value)
  76 {
  77     if (cstr_eq(opt_name, "verbose"))
  78         options.verbose = cstdlib.atoi(opt_value);
  79     else if (cstr_eq(opt_name, "log_file"))
  80         cstring.strcpy(options.log_file.ptr, opt_value);
  81     else if (cstr_eq(opt_name, "malloc_stats_file"))
  82         cstring.strcpy(options.malloc_stats_file.ptr, opt_value);
  83     else if (cstr_eq(opt_name, "collect_stats_file"))
  84         cstring.strcpy(options.collect_stats_file.ptr, opt_value);
  85     else if (cstr_eq(opt_name, "sentinel"))
  86         options.sentinel = parse_bool(opt_value);
  87     else if (cstr_eq(opt_name, "mem_stomp"))
  88         options.mem_stomp = parse_bool(opt_value);
  89     else if (cstr_eq(opt_name, "conservative"))
  90         options.conservative = parse_bool(opt_value);
  91     else if (cstr_eq(opt_name, "no_fork"))
  92         options.fork = !parse_bool(opt_value);
  93 }
  94
  95
  96 package void parse(char* opts_string)
  97 {
  98     char[MAX_OPT_LEN] opt_name;
  99     opt_name[0] = '\0';
 100     char[MAX_OPT_LEN] opt_value;
 101     opt_value[0] = '\0';
 102     char* curr = opt_name.ptr;
 103     size_t i = 0;
 104     if (opts_string is null)
 105         return;
 106     for (; *opts_string != '\0'; opts_string++)
 107     {
 108         char c = *opts_string;
 109         if (i == MAX_OPT_LEN)
 110         {
 111             if (c != ':')
 112                 continue;
 113             else
 114                 i--;
 115         }
 116         switch (*opts_string)
 117         {
 118         case ':':
 119             curr[i] = '\0';
 120             process_option(opt_name.ptr, opt_value.ptr);
 121             i = 0;
 122             opt_name[0] = '\0';
 123             opt_value[0] = '\0';
 124             curr = opt_name.ptr;
 125             break;
 126         case '=':
 127             opt_name[i] = '\0';
 128             curr = opt_value.ptr;
 129             i = 0;
 130             break;
 131         default:
 132             curr[i] = c;
 133             ++i;
 134         }
 135     }
 136     if (i == MAX_OPT_LEN)
 137         i--;
 138     curr[i] = '\0';
 139     process_option(opt_name.ptr, opt_value.ptr);
 140 }
 141
 142
 143 unittest
 144 {
 145     with (options) {
 146         assert (verbose == 0);
 147         assert (log_file[0] == '\0');
 148         assert (sentinel == false);
 149         assert (mem_stomp == false);
 150         assert (conservative == false);
 151         assert (fork == true);
 152     }
 153     parse("mem_stomp");
 154     with (options) {
 155         assert (verbose == 0);
 156         assert (log_file[0] == '\0');
 157         assert (sentinel == false);
 158         assert (mem_stomp == true);
 159         assert (conservative == false);
 160         assert (fork == true);
 161     }
 162     parse("mem_stomp=0:verbose=2:conservative:no_fork=10");
 163     with (options) {
 164         assert (verbose == 2);
 165         assert (log_file[0] == '\0');
 166         assert (sentinel == false);
 167         assert (mem_stomp == false);
 168         assert (conservative == true);
 169         assert (fork == false);
 170     }
 171     parse("log_file=12345 67890:verbose=1:sentinel=4:mem_stomp=1");
 172     with (options) {
 173         assert (verbose == 1);
 174         assert (cstring.strcmp(log_file.ptr, "12345 67890".ptr) == 0);
 175         assert (sentinel == true);
 176         assert (mem_stomp == true);
 177         assert (conservative == true);
 178         assert (fork == false);
 179     }
 180     parse(null);
 181     with (options) {
 182         assert (verbose == 1);
 183         assert (cstring.strcmp(log_file.ptr, "12345 67890".ptr) == 0);
 184         assert (sentinel == true);
 185         assert (mem_stomp == true);
 186         assert (conservative == true);
 187         assert (fork == false);
 188     }
 189     parse("");
 190     with (options) {
 191         assert (verbose == 1);
 192         assert (cstring.strcmp(log_file.ptr, "12345 67890".ptr) == 0);
 193         assert (sentinel == true);
 194         assert (mem_stomp == true);
 195         assert (conservative == true);
 196         assert (fork == false);
 197     }
 198     parse(":");
 199     with (options) {
 200         assert (verbose == 1);
 201         assert (cstring.strcmp(log_file.ptr, "12345 67890".ptr) == 0);
 202         assert (sentinel == true);
 203         assert (mem_stomp == true);
 204         assert (conservative == true);
 205         assert (fork == false);
 206     }
 207     parse("::::");
 208     with (options) {
 209         assert (verbose == 1);
 210         assert (cstring.strcmp(log_file.ptr, "12345 67890".ptr) == 0);
 211         assert (sentinel == true);
 212         assert (mem_stomp == true);
 213         assert (conservative == true);
 214         assert (fork == false);
 215     }
 216 }
 217
 218
 219 // vim: set et sw=4 sts=4 :