Logo ROOT  
Reference Guide
TEnv.cxx
Go to the documentation of this file.
1// @(#)root/base:$Id: 0daf41ec24086ee7af29fdc2f9f2f848b150dcc8 $
2// Author: Fons Rademakers 22/09/95
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12/** \class TEnv
13\ingroup Base
14
15The TEnv class reads config files, by default named `.rootrc`.
16Three types of config files are read: global, user and local files. The
17global file is `$ROOTSYS/etc/system<name>` (or `ROOTETCDIR/system<name>`)
18the user file is `$HOME/<name>` and the local file is `./<name>`.
19By setting the shell variable `ROOTENV_NO_HOME=1` the reading of
20the `$HOME/<name>` resource file will be skipped. This might be useful
21in case the home directory resides on an auto-mounted remote file
22system and one wants to avoid this file system from being mounted.
23
24The format of the `.rootrc` file is similar to the `.Xdefaults` format:
25~~~ {.cpp}
26 [+]<SystemName>.<RootName|ProgName>.<name>[(type)]: <value>
27~~~
28Where `<SystemName>` is either Unix, WinNT, MacOS or Vms,
29`<RootName>` the name as given in the TApplication ctor (or "RootApp"
30in case no explicit TApplication derived object was created),
31`<ProgName>` the current program name and `<name>` the resource name,
32with optionally a type specification. `<value>` can be either a
33string, an integer, a float/double or a boolean with the values
34TRUE, FALSE, ON, OFF, YES, NO, OK, NOT. Booleans will be returned as
35an integer 0 or 1. The options [+] allows the concatenation of
36values to the same resource name.
37
38E.g.:
39~~~ {.cpp}
40 Unix.Rint.Root.DynamicPath: .:$(ROOTSYS)/lib:~/lib
41 myapp.Root.Debug: FALSE
42 TH.Root.Debug: YES
43 *.Root.ObjStat: 1
44~~~
45`<SystemName>` and `<ProgName>` or `<RootName>` may be the wildcard "*".
46A # in the first column starts comment line.
47
48Note that the environment variables (like $ROOTSYS) need to be
49surrounded in parentheses in order to be expanded.
50
51For the currently defined resources (and their default values) see
52`$ROOTSYS/etc/system.rootrc`.
53
54Note that the .rootrc config files contain the config for all ROOT
55based applications.
56
57To add new entries to a TEnv:
58~~~ {.cpp}
59TEnv env(".myfile");
60env.SetValue("myname","value");
61env.SaveLevel(kEnvLocal);
62~~~
63All new entries will be saved in the file corresponding to the
64first SaveLevel() command. If Save() is used, new entries go
65into the local file by default.
66*/
67
68#include "RConfigure.h"
69
70#include <cstring>
71#include <cstdio>
72#include <cstdlib>
73#include <cctype>
74
75#include "strlcpy.h"
76#include "TEnv.h"
77#include "TROOT.h"
78#include "TSystem.h"
79#include "THashList.h"
80#include "TError.h"
81
82
83TEnv *gEnv; // main environment created in TROOT
84
85
86static struct BoolNameTable_t {
87 const char *fName;
89} gBoolNames[]= {
90 { "TRUE", 1 },
91 { "FALSE", 0 },
92 { "ON", 1 },
93 { "OFF", 0 },
94 { "YES", 1 },
95 { "NO", 0 },
96 { "OK", 1 },
97 { "NOT", 0 },
98 { nullptr, 0 }
99};
100
101
102/** \class TEnvParser
103TEnv Parser.
104*/
105
107
108private:
109 FILE *fIfp;
110
111protected:
113
114public:
115 TEnvParser(TEnv *e, FILE *f) : fIfp(f), fEnv(e) { }
116 virtual ~TEnvParser() { }
117 virtual void KeyValue(const TString&, const TString&, const TString&) { }
118 virtual void Char(Int_t) { }
119 void Parse();
120};
121
122////////////////////////////////////////////////////////////////////////////////
123/// Parse a line of the env file and create an entry in the resource
124/// dictionary (i.e. add a KeyValue pair).
125
127{
128 TString name(1024);
129 TString type(1024);
130 TString value(1024);
131 int c, state = 0;
132
133 while ((c = fgetc(fIfp)) != EOF) {
134 if (c == 13) // ignore CR
135 continue;
136 if (c == '\n') {
137 state = 0;
138 if (name.Length() > 0) {
139 KeyValue(name, value, type);
140 name.Clear();
141 value.Clear();
142 type.Clear();
143 }
144 Char(c);
145 continue;
146 }
147 switch (state) {
148 case 0: // start of line
149 switch (c) {
150 case ' ':
151 case '\t':
152 break;
153 case '#':
154 state = 1;
155 break;
156 default:
157 state = 2;
158 break;
159 }
160 break;
161
162 case 1: // comment
163 break;
164
165 case 2: // name
166 switch (c) {
167 case ' ':
168 case '\t':
169 case ':':
170 state = 3;
171 break;
172 case '(':
173 state = 7;
174 break;
175 default:
176 break;
177 }
178 break;
179
180 case 3: // ws before value
181 if (c != ' ' && c != '\t')
182 state = 4;
183 break;
184
185 case 4: // value
186 break;
187
188 case 5: // type
189 if (c == ')')
190 state = 6;
191 break;
192
193 case 6: // optional ':'
194 state = (c == ':') ? 3 : 4;
195 break;
196
197 case 7:
198 state = (c == ')') ? 6 : 5;
199 break;
200
201 }
202 switch (state) {
203 case 2:
204 name.Append(c);
205 break;
206 case 4:
207 value.Append(c);
208 break;
209 case 5:
210 type.Append(c);
211 break;
212 }
213 if (state != 4)
214 Char(c);
215 }
216 // In case EOF is reach before '\n'
217 if (name.Length() > 0) {
218 KeyValue(name, value, type);
219 name.Clear();
220 value.Clear();
221 type.Clear();
222 }
223}
224
225/** \class TReadEnvParser
226*/
227
229
230private:
232
233public:
235 void KeyValue(const TString &name, const TString &value, const TString &type)
236 { fEnv->SetValue(name, value, fLevel, type); }
237};
238
239/** \class TWriteEnvParser
240*/
241
243
244private:
245 FILE *fOfp;
246
247public:
248 TWriteEnvParser(TEnv *e, FILE *f, FILE *of) : TEnvParser(e, f), fOfp(of) { }
249 void KeyValue(const TString &name, const TString &value, const TString &type);
250 void Char(Int_t c) { fputc(c, fOfp); }
251};
252
253////////////////////////////////////////////////////////////////////////////////
254/// Write resources out to a new file.
255
257 const TString &)
258{
259 TEnvRec *er = fEnv->Lookup(name);
260 if (er && er->fModified) {
261 er->fModified = kFALSE;
262 fprintf(fOfp, "%s", er->fValue.Data());
263 } else
264 fprintf(fOfp, "%s", value.Data());
265}
266
267
268/** \class TEnvRec
269*/
270
271////////////////////////////////////////////////////////////////////////////////
272/// Ctor of a single resource.
273
274TEnvRec::TEnvRec(const char *n, const char *v, const char *t, EEnvLevel l)
275 : fName(n), fType(t), fLevel(l)
276{
278 fModified = (l == kEnvChange);
279}
280
281////////////////////////////////////////////////////////////////////////////////
282/// TNamed destructor.
283
285{
286 // Required since we overload TObject::Hash.
288}
289
290////////////////////////////////////////////////////////////////////////////////
291/// Change the value of a resource.
292
293void TEnvRec::ChangeValue(const char *v, const char *, EEnvLevel l,
294 Bool_t append, Bool_t ignoredup)
295{
296 if (l != kEnvChange && fLevel == l && !append) {
297 // use global Warning() since interpreter might not yet be initialized
298 // at this stage (called from TROOT ctor)
299 if (fValue != v && !ignoredup)
300 ::Warning("TEnvRec::ChangeValue",
301 "duplicate entry <%s=%s> for level %d; ignored", fName.Data(), v, l);
302 return;
303 }
304 if (!append) {
305 if (fValue != v) {
306 if (l == kEnvChange)
308 else
310 fLevel = l;
312 }
313 } else {
314 if (l == kEnvChange)
316 fLevel = l;
317 fValue += " ";
318 fValue += ExpandValue(v);
319 }
320}
321
322////////////////////////////////////////////////////////////////////////////////
323/// Comparison function for resources.
324
326{
327 return fName.CompareTo(((TEnvRec*)op)->fName);
328}
329
330////////////////////////////////////////////////////////////////////////////////
331/// Replace all $(XXX) strings by the value defined in the shell
332/// (obtained via TSystem::Getenv()).
333
335{
336 const char *vv;
337 char *v, *vorg = StrDup(value);
338 v = vorg;
339
340 char *s1, *s2;
341 int len = 0;
342 while ((s1 = (char*)strstr(v, "$("))) {
343 s1 += 2;
344 s2 = (char*)strchr(s1, ')');
345 if (!s2) {
346 len = 0;
347 break;
348 }
349 *s2 = 0;
350 vv = gSystem->Getenv(s1);
351 if (vv) len += strlen(vv);
352 *s2 = ')';
353 v = s2 + 1;
354 }
355
356 if (!len) {
357 delete [] vorg;
358 return TString(value);
359 }
360
361 v = vorg;
362 int nch = strlen(v) + len;
363 char *nv = new char[nch];
364 *nv = 0;
365
366 while ((s1 = (char*)strstr(v, "$("))) {
367 *s1 = 0;
368 strlcat(nv, v,nch);
369 *s1 = '$';
370 s1 += 2;
371 s2 = (char*)strchr(s1, ')');
372 *s2 = 0;
373 vv = gSystem->Getenv(s1);
374 if (vv) strlcat(nv, vv,nch);
375 *s2 = ')';
376 v = s2 + 1;
377 }
378
379 if (*v) strlcat(nv, v,nch);
380
381 TString val = nv;
382 delete [] nv;
383 delete [] vorg;
384
385 return val;
386}
387
389
390////////////////////////////////////////////////////////////////////////////////
391/// Create a resource table and read the (possibly) three resource files,
392/// i.e.\ `$ROOTSYS/etc/system<name>` (or `ROOTETCDIR/system<name>`),
393/// `$HOME/<name>` and `$PWD/<name>`.
394/// ROOT always reads ".rootrc" (in TROOT::InitSystem()). You can
395/// read additional user defined resource files by creating additional TEnv
396/// objects. By setting the shell variable ROOTENV_NO_HOME=1 the reading of
397/// the `$HOME/<name>` resource file will be skipped. This might be useful in
398/// case the home directory resides on an auto-mounted remote file system
399/// and one wants to avoid the file system from being mounted.
400
401TEnv::TEnv(const char *name)
402{
404
405 if (!name || !name[0] || !gSystem)
406 fTable = nullptr;
407 else {
408 fTable = new THashList(1000);
409 fRcName = name;
410
411 TString sname = "system";
412 sname += name;
413 char *s = gSystem->ConcatFileName(TROOT::GetEtcDir(), sname);
415 delete [] s;
416 if (!gSystem->Getenv("ROOTENV_NO_HOME")) {
419 delete [] s;
422 } else
424 }
425}
426
427////////////////////////////////////////////////////////////////////////////////
428/// Delete the resource table.
429
431{
432 if (fTable) {
433 fTable->Delete();
435 }
436}
437
438////////////////////////////////////////////////////////////////////////////////
439/// Returns the character value for a named resource.
440
441const char *TEnv::Getvalue(const char *name) const
442{
443 Bool_t haveProgName = kFALSE;
444 if (gProgName && strlen(gProgName) > 0)
445 haveProgName = kTRUE;
446
447 TString aname;
448 TEnvRec *er = nullptr;
449 if (haveProgName && gSystem && gProgName) {
450 aname = gSystem->GetName(); aname += "."; aname += gProgName;
451 aname += "."; aname += name;
452 er = Lookup(aname);
453 }
454 if (er == nullptr && gSystem && gROOT) {
455 aname = gSystem->GetName(); aname += "."; aname += gROOT->GetName();
456 aname += "."; aname += name;
457 er = Lookup(aname);
458 }
459 if (er == nullptr && gSystem) {
460 aname = gSystem->GetName(); aname += ".*."; aname += name;
461 er = Lookup(aname);
462 }
463 if (er == nullptr && haveProgName && gProgName) {
464 aname = gProgName; aname += "."; aname += name;
465 er = Lookup(aname);
466 }
467 if (er == nullptr && gROOT) {
468 aname = gROOT->GetName(); aname += "."; aname += name;
469 er = Lookup(aname);
470 }
471 if (er == nullptr) {
472 aname = "*.*."; aname += name;
473 er = Lookup(aname);
474 }
475 if (er == nullptr) {
476 aname = "*."; aname += name;
477 er = Lookup(aname);
478 }
479 if (er == nullptr) {
480 er = Lookup(name);
481 }
482 if (er == nullptr)
483 return nullptr;
484 return er->fValue;
485}
486
487////////////////////////////////////////////////////////////////////////////////
488/// Returns the integer value for a resource. If the resource is not found
489/// return the default value.
490
491Int_t TEnv::GetValue(const char *name, Int_t dflt) const
492{
493 const char *cp = TEnv::Getvalue(name);
494 if (cp) {
495 char buf2[512], *cp2 = buf2;
496
497 while (isspace((int)*cp))
498 cp++;
499 if (*cp) {
500 BoolNameTable_t *bt;
501 if (isdigit((int)*cp) || *cp == '-' || *cp == '+')
502 return atoi(cp);
503 while (isalpha((int)*cp))
504 *cp2++ = toupper((int)*cp++);
505 *cp2 = 0;
506 for (bt = gBoolNames; bt->fName; bt++)
507 if (strcmp(buf2, bt->fName) == 0)
508 return bt->fValue;
509 }
510 }
511 return dflt;
512}
513
514////////////////////////////////////////////////////////////////////////////////
515/// Returns the double value for a resource. If the resource is not found
516/// return the default value.
517
518Double_t TEnv::GetValue(const char *name, Double_t dflt) const
519{
520 const char *cp = TEnv::Getvalue(name);
521 if (cp) {
522 char *endptr;
523 Double_t val = strtod(cp, &endptr);
524 if (val == 0.0 && cp == endptr)
525 return dflt;
526 return val;
527 }
528 return dflt;
529}
530
531////////////////////////////////////////////////////////////////////////////////
532/// Returns the character value for a named resource. If the resource is
533/// not found the default value is returned.
534
535const char *TEnv::GetValue(const char *name, const char *dflt) const
536{
537 const char *cp = TEnv::Getvalue(name);
538 if (cp)
539 return cp;
540 return dflt;
541}
542
543////////////////////////////////////////////////////////////////////////////////
544/// Loop over all resource records and return the one with name.
545/// Return 0 in case name is not in the resource table.
546
547TEnvRec *TEnv::Lookup(const char *name) const
548{
549 if (!fTable) return nullptr;
550 return (TEnvRec*) fTable->FindObject(name);
551}
552
553////////////////////////////////////////////////////////////////////////////////
554/// Print all resources or the global, user or local resources separately.
555
556void TEnv::Print(Option_t *opt) const
557{
558 if (!opt || !opt[0]) {
559 PrintEnv();
560 return;
561 }
562
563 if (!strcmp(opt, "global"))
565 if (!strcmp(opt, "user"))
567 if (!strcmp(opt, "local"))
569}
570
571////////////////////////////////////////////////////////////////////////////////
572/// Print all resources for a certain level (global, user, local, changed).
573
574void TEnv::PrintEnv(EEnvLevel level) const
575{
576 if (!fTable) return;
577
578 TIter next(fTable);
579 TEnvRec *er;
580 static const char *lc[] = { "Global", "User", "Local", "Changed", "All" };
581
582 while ((er = (TEnvRec*) next()))
583 if (er->fLevel == level || level == kEnvAll)
584 Printf("%-25s %-30s [%s]", Form("%s:", er->fName.Data()),
585 er->fValue.Data(), lc[er->fLevel]);
586}
587
588////////////////////////////////////////////////////////////////////////////////
589/// Read and parse the resource file for a certain level.
590/// Returns -1 on case of error, 0 in case of success.
591
592Int_t TEnv::ReadFile(const char *fname, EEnvLevel level)
593{
594 if (!fname || !fname[0]) {
595 Error("ReadFile", "no file name specified");
596 return -1;
597 }
598
599 FILE *ifp;
600 if ((ifp = fopen(fname, "r"))) {
601 TReadEnvParser rp(this, ifp, level);
602 rp.Parse();
603 fclose(ifp);
604 return 0;
605 }
606
607 // no Error() here since we are allowed to try to read from a non-existing
608 // file (like ./.rootrc, $HOME/.rootrc, etc.)
609 return -1;
610}
611
612////////////////////////////////////////////////////////////////////////////////
613/// Write resource records to file fname for a certain level. Use
614/// level kEnvAll to write all resources. Returns -1 on case of error,
615/// 0 in case of success.
616
617Int_t TEnv::WriteFile(const char *fname, EEnvLevel level)
618{
619 if (!fname || !fname[0]) {
620 Error("WriteFile", "no file name specified");
621 return -1;
622 }
623
624 if (!fTable) {
625 Error("WriteFile", "TEnv table is empty");
626 return -1;
627 }
628
629 FILE *ofp;
630 if ((ofp = fopen(fname, "w"))) {
631 TIter next(fTable);
632 TEnvRec *er;
633 while ((er = (TEnvRec*) next()))
634 if (er->fLevel == level || level == kEnvAll)
635 fprintf(ofp, "%-40s %s\n", Form("%s:", er->fName.Data()),
636 er->fValue.Data());
637 fclose(ofp);
638 return 0;
639 }
640
641 Error("WriteFile", "cannot open %s for writing", fname);
642 return -1;
643}
644
645////////////////////////////////////////////////////////////////////////////////
646/// Write the resource files for each level. The new files have the same
647/// name as the original files. The old files are renamed to *.bak.
648
650{
651 if (fRcName == "") {
652 Error("Save", "no resource file name specified");
653 return;
654 }
655
656 SaveLevel(kEnvLocal); // Be default, new items will be put into Local.
659}
660
661////////////////////////////////////////////////////////////////////////////////
662/// Write the resource file for a certain level.
663
665{
666 if (fRcName == "") {
667 Error("SaveLevel", "no resource file name specified");
668 return;
669 }
670
671 if (!fTable) {
672 Error("SaveLevel", "TEnv table is empty");
673 return;
674 }
675
676 TString rootrcdir;
677 FILE *ifp, *ofp;
678
679 if (level == kEnvGlobal) {
680
681 TString sname = "system";
682 sname += fRcName;
683 char *s = gSystem->ConcatFileName(TROOT::GetEtcDir(), sname);
684 rootrcdir = s;
685 delete [] s;
686 } else if (level == kEnvUser) {
688 rootrcdir = s;
689 delete [] s;
690 } else if (level == kEnvLocal)
691 rootrcdir = fRcName;
692 else
693 return;
694
695 if ((ofp = fopen(Form("%s.new", rootrcdir.Data()), "w"))) {
696 ifp = fopen(rootrcdir.Data(), "r");
697 if (ifp == nullptr) { // try to create file
698 ifp = fopen(rootrcdir.Data(), "w");
699 if (ifp) {
700 fclose(ifp);
701 ifp = nullptr;
702 }
703 }
704 if (ifp || (ifp = fopen(rootrcdir.Data(), "r"))) {
705 TWriteEnvParser wp(this, ifp, ofp);
706 wp.Parse();
707
708 TIter next(fTable);
709 TEnvRec *er;
710 while ((er = (TEnvRec*) next())) {
711 if (er->fModified) {
712
713 // If it doesn't have a level yet, make it this one.
714 if (er->fLevel == kEnvChange) er->fLevel = level;
715 if (er->fLevel == level) {
716 er->fModified = kFALSE;
717 fprintf(ofp, "%-40s %s\n", Form("%s:", er->fName.Data()),
718 er->fValue.Data());
719 }
720 }
721 }
722 fclose(ifp);
723 fclose(ofp);
724 gSystem->Rename(rootrcdir.Data(), Form("%s.bak", rootrcdir.Data()));
725 gSystem->Rename(Form("%s.new", rootrcdir.Data()), rootrcdir.Data());
726 return;
727 }
728 fclose(ofp);
729 } else
730 Error("SaveLevel", "cannot write to file %s", rootrcdir.Data());
731}
732
733////////////////////////////////////////////////////////////////////////////////
734/// Set the value of a resource or create a new resource.
735
736void TEnv::SetValue(const char *name, const char *value, EEnvLevel level,
737 const char *type)
738{
739 if (!fTable)
740 fTable = new THashList(1000);
741
742 const char *nam = name;
743 Bool_t append = kFALSE;
744 if (name[0] == '+') {
745 nam = &name[1];
746 append = kTRUE;
747 }
748
749 TEnvRec *er = Lookup(nam);
750 if (er)
751 er->ChangeValue(value, type, level, append, fIgnoreDup);
752 else
753 fTable->Add(new TEnvRec(nam, value, type, level));
754}
755
756////////////////////////////////////////////////////////////////////////////////
757/// Set the value of a resource or create a new resource.
758/// Use this method to set a resource like, "name=val".
759/// If just "name" is given it will be interpreted as "name=1".
760
761void TEnv::SetValue(const char *name, EEnvLevel level)
762{
763 TString buf = name;
764 int l = buf.Index("=");
765 if (l > 0) {
766 TString nm = buf(0, l);
767 TString val = buf(l+1, buf.Length());
768 SetValue(nm, val, level);
769 } else
770 SetValue(name, "1", level);
771}
772
773////////////////////////////////////////////////////////////////////////////////
774/// Set or create an integer resource value.
775
776void TEnv::SetValue(const char *name, Int_t value)
777{
778 SetValue(name, Form("%d", value));
779}
780
781////////////////////////////////////////////////////////////////////////////////
782/// Set or create a double resource value.
783
784void TEnv::SetValue(const char *name, Double_t value)
785{
786 SetValue(name, Form("%g", value));
787}
788
789////////////////////////////////////////////////////////////////////////////////
790/// If set to true, no warnings in case of duplicates are issued.
791/// Returns previous value.
792
794{
795 Bool_t ret = fIgnoreDup;
796 fIgnoreDup = ignore;
797 return ret;
798}
#define SafeDelete(p)
Definition: RConfig.hxx:534
#define f(i)
Definition: RSha256.hxx:104
#define c(i)
Definition: RSha256.hxx:101
#define s1(x)
Definition: RSha256.hxx:91
#define e(i)
Definition: RSha256.hxx:103
int Int_t
Definition: RtypesCore.h:45
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:364
TEnv * gEnv
Definition: TEnv.cxx:83
static struct BoolNameTable_t gBoolNames[]
EEnvLevel
Definition: TEnv.h:69
@ kEnvUser
Definition: TEnv.h:71
@ kEnvChange
Definition: TEnv.h:73
@ kEnvAll
Definition: TEnv.h:74
@ kEnvGlobal
Definition: TEnv.h:70
@ kEnvLocal
Definition: TEnv.h:72
char name[80]
Definition: TGX11.cxx:110
int type
Definition: TGX11.cxx:121
#define gROOT
Definition: TROOT.h:404
char * Form(const char *fmt,...)
void Printf(const char *fmt,...)
char * StrDup(const char *str)
Duplicate the string str.
Definition: TString.cxx:2515
R__EXTERN const char * gProgName
Definition: TSystem.h:242
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
TEnv Parser.
Definition: TEnv.cxx:106
virtual ~TEnvParser()
Definition: TEnv.cxx:116
virtual void Char(Int_t)
Definition: TEnv.cxx:118
void Parse()
Parse a line of the env file and create an entry in the resource dictionary (i.e.
Definition: TEnv.cxx:126
TEnvParser(TEnv *e, FILE *f)
Definition: TEnv.cxx:115
TEnv * fEnv
Definition: TEnv.cxx:112
virtual void KeyValue(const TString &, const TString &, const TString &)
Definition: TEnv.cxx:117
FILE * fIfp
Definition: TEnv.cxx:109
Definition: TEnv.h:86
TString fValue
Definition: TEnv.h:96
void ChangeValue(const char *v, const char *t, EEnvLevel l, Bool_t append=kFALSE, Bool_t ignoredup=kFALSE)
Change the value of a resource.
Definition: TEnv.cxx:293
EEnvLevel fLevel
Definition: TEnv.h:97
TEnvRec()
Definition: TEnv.h:107
TString ExpandValue(const char *v)
Replace all strings by the value defined in the shell (obtained via TSystem::Getenv()).
Definition: TEnv.cxx:334
TString fName
Definition: TEnv.h:94
Int_t Compare(const TObject *obj) const
Comparison function for resources.
Definition: TEnv.cxx:325
Bool_t fModified
Definition: TEnv.h:98
~TEnvRec()
TNamed destructor.
Definition: TEnv.cxx:284
The TEnv class reads config files, by default named .rootrc.
Definition: TEnv.h:124
THashList * fTable
Definition: TEnv.h:127
virtual void PrintEnv(EEnvLevel level=kEnvAll) const
Print all resources for a certain level (global, user, local, changed).
Definition: TEnv.cxx:574
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition: TEnv.cxx:491
TString fRcName
Definition: TEnv.h:128
virtual Int_t WriteFile(const char *fname, EEnvLevel level=kEnvAll)
Write resource records to file fname for a certain level.
Definition: TEnv.cxx:617
Bool_t IgnoreDuplicates(Bool_t ignore)
If set to true, no warnings in case of duplicates are issued.
Definition: TEnv.cxx:793
virtual Int_t ReadFile(const char *fname, EEnvLevel level)
Read and parse the resource file for a certain level.
Definition: TEnv.cxx:592
virtual void SetValue(const char *name, const char *value, EEnvLevel level=kEnvChange, const char *type=nullptr)
Set the value of a resource or create a new resource.
Definition: TEnv.cxx:736
virtual TEnvRec * Lookup(const char *n) const
Loop over all resource records and return the one with name.
Definition: TEnv.cxx:547
virtual void Save()
Write the resource files for each level.
Definition: TEnv.cxx:649
Bool_t fIgnoreDup
Definition: TEnv.h:129
const char * Getvalue(const char *name) const
Returns the character value for a named resource.
Definition: TEnv.cxx:441
virtual void Print(Option_t *option="") const
Print all resources or the global, user or local resources separately.
Definition: TEnv.cxx:556
virtual void SaveLevel(EEnvLevel level)
Write the resource file for a certain level.
Definition: TEnv.cxx:664
virtual ~TEnv()
Delete the resource table.
Definition: TEnv.cxx:430
TEnv(const TEnv &)=delete
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition: THashList.h:34
TObject * FindObject(const char *name) const
Find object using its name.
Definition: THashList.cxx:262
void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: THashList.cxx:207
virtual void Add(TObject *obj)
Definition: TList.h:87
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
Mother of all ROOT objects.
Definition: TObject.h:37
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:879
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:893
static const TString & GetEtcDir()
Get the sysconfig directory in the installation. Static utility function.
Definition: TROOT.cxx:2953
TReadEnvParser(TEnv *e, FILE *f, EEnvLevel l)
Definition: TEnv.cxx:234
void KeyValue(const TString &name, const TString &value, const TString &type)
Definition: TEnv.cxx:235
EEnvLevel fLevel
Definition: TEnv.cxx:231
Basic string class.
Definition: TString.h:136
Ssiz_t Length() const
Definition: TString.h:410
int CompareTo(const char *cs, ECaseCompare cmp=kExact) const
Compare a string to char *cs2.
Definition: TString.cxx:442
void Clear()
Clear string without changing its capacity.
Definition: TString.cxx:1201
const char * Data() const
Definition: TString.h:369
TString & Append(const char *cs)
Definition: TString.h:564
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:639
virtual const char * Getenv(const char *env)
Get environment variable.
Definition: TSystem.cxx:1663
virtual char * ConcatFileName(const char *dir, const char *name)
Concatenate a directory and a file name. User must delete returned string.
Definition: TSystem.cxx:1071
virtual int Rename(const char *from, const char *to)
Rename a file.
Definition: TSystem.cxx:1350
virtual const char * WorkingDirectory()
Return working directory.
Definition: TSystem.cxx:872
virtual const char * HomeDirectory(const char *userName=nullptr)
Return the user's home directory.
Definition: TSystem.cxx:888
void Char(Int_t c)
Definition: TEnv.cxx:250
TWriteEnvParser(TEnv *e, FILE *f, FILE *of)
Definition: TEnv.cxx:248
void KeyValue(const TString &name, const TString &value, const TString &type)
Write resources out to a new file.
Definition: TEnv.cxx:256
FILE * fOfp
Definition: TEnv.cxx:245
const Int_t n
Definition: legend1.C:16
void CallRecursiveRemoveIfNeeded(TObject &obj)
call RecursiveRemove for obj if gROOT is valid and obj.TestBit(kMustCleanup) is true.
Definition: TROOT.h:393
static constexpr double nm
static constexpr double s
Int_t fValue
Definition: TEnv.cxx:88
const char * fName
Definition: TEnv.cxx:87
auto * l
Definition: textangle.C:4