From 59f3970dc5ba85e5b7c5b4ffe95c408434b3a827 Mon Sep 17 00:00:00 2001
From: Philippe Canal <pcanal@fnal.gov>
Date: Thu, 20 Mar 2008 22:06:28 +0000
Subject: [PATCH] white space
git-svn-id: http://root.cern.ch/svn/root/trunk@22806 27541ba8-7e3a-0410-8455-c3a389f83636
---
io/src/TMakeProject.cxx | 272 ++++++++++++++++++++++------------------
1 file changed, 149 insertions(+), 123 deletions(-)
diff --git a/io/src/TMakeProject.cxx b/io/src/TMakeProject.cxx
index 12850e5e7c5..3493e355dea 100644
--- a/io/src/TMakeProject.cxx
+++ b/io/src/TMakeProject.cxx
@@ -30,7 +30,7 @@ void TMakeProject::AddUniqueStatement(FILE *fp, const char *statement, char *inc
if (!strstr(inclist, statement)) {
strcat(inclist, statement);
- fprintf(fp,statement);
+ fprintf(fp, statement);
}
}
@@ -55,7 +55,7 @@ TString TMakeProject::GetHeaderName(const char *name, Bool_t includeNested)
TString result;
Int_t len = strlen(name);
Int_t nest = 0;
- for(Int_t i=0; i<len; ++i) {
+ for (Int_t i = 0; i < len; ++i) {
switch (name[i]) {
case '<':
++nest;
@@ -66,15 +66,15 @@ TString TMakeProject::GetHeaderName(const char *name, Bool_t includeNested)
result.Append('_');
break;
case ':':
- if (nest==0 && name[i+1]==':') {
+ if (nest == 0 && name[i+1] == ':') {
TString nsname(name, i);
TClass *cl = gROOT->GetClass(nsname);
- if (!includeNested && cl && cl->Size()!=0) {
+ if (!includeNested && cl && cl->Size() != 0) {
// The requested class is actually nested inside
- // the class whose name we already 'copied' to
+ // the class whose name we already 'copied' to
// result. The declaration will be in the same
// header file as the outer class.
- if (strcmp(name+strlen(name)-2,".h")==0) {
+ if (strcmp(name + strlen(name) - 2, ".h") == 0) {
result.Append(".h");
}
return result;
@@ -102,48 +102,53 @@ TString TMakeProject::GetHeaderName(const char *name, Bool_t includeNested)
//______________________________________________________________________________
UInt_t TMakeProject::GenerateClassPrefix(FILE *fp, const char *clname, Bool_t top, TString &protoname,
- UInt_t *numberOfClasses, Bool_t implementEmptyClass){
+ UInt_t *numberOfClasses, Bool_t implementEmptyClass)
+{
// First open the namespace (if any)
Int_t numberOfNamespaces = 0;
const char *fullname = clname;
Bool_t istemplate = kFALSE;
- if (strchr(clname,':')) {
+ if (strchr(clname, ':')) {
// We might have a namespace in front of the classname.
Int_t len = strlen(clname);
const char *name = clname;
UInt_t nest = 0;
- for(Int_t cur=0; cur<len; ++cur) {
- switch(clname[cur]) {
- case '<': ++nest; istemplate = kTRUE; break;
- case '>': --nest; break;
- case ':':
- {
- if (nest==0 && clname[cur+1]==':') {
+ for (Int_t cur = 0; cur < len; ++cur) {
+ switch (clname[cur]) {
+ case '<':
+ ++nest;
+ istemplate = kTRUE;
+ break;
+ case '>':
+ --nest;
+ break;
+ case ':': {
+ if (nest == 0 && clname[cur+1] == ':') {
// We have a scope
TString nsname(clname, cur);
TClass *cl = gROOT->GetClass(nsname);
if (top) {
- if (cl==0 || (cl && cl->Size()==0)) {
- TString last( name, cur - (name-clname) );
- if ((numberOfClasses==0 || *numberOfClasses == 0) && strchr(last.Data(),'<')==0) {
- fprintf(fp,"namespace %s {\n",last.Data());
+ if (cl == 0 || (cl && cl->Size() == 0)) {
+ TString last(name, cur - (name - clname));
+ if ((numberOfClasses == 0 || *numberOfClasses == 0) && strchr(last.Data(), '<') == 0) {
+ fprintf(fp, "namespace %s {\n", last.Data());
++numberOfNamespaces;
} else {
- TString headername( GetHeaderName(last) );
- fprintf(fp,"#ifndef %s_h\n",headername.Data());
- fprintf(fp,"#define %s_h\n",headername.Data());
+ TString headername(GetHeaderName(last));
+ fprintf(fp, "#ifndef %s_h\n", headername.Data());
+ fprintf(fp, "#define %s_h\n", headername.Data());
GenerateClassPrefix(fp, last.Data(), top, protoname, 0);
fprintf(fp, "{\n");
fprintf(fp, "public:\n");
if (numberOfClasses) ++(*numberOfClasses);
istemplate = kFALSE;
}
- name = clname+cur+2;
+ name = clname + cur + 2;
}
} else {
- name = clname+cur+2;
+ name = clname + cur + 2;
}
}
break;
@@ -152,15 +157,15 @@ UInt_t TMakeProject::GenerateClassPrefix(FILE *fp, const char *clname, Bool_t to
}
clname = name;
} else {
- istemplate = strstr(clname,"<")!=0;
+ istemplate = strstr(clname, "<") != 0;
}
protoname = clname;
if (implementEmptyClass) {
- TString headername( GetHeaderName(fullname) );
- fprintf(fp,"#ifndef %s_h\n",headername.Data());
- fprintf(fp,"#define %s_h\n",headername.Data());
+ TString headername(GetHeaderName(fullname));
+ fprintf(fp, "#ifndef %s_h\n", headername.Data());
+ fprintf(fp, "#define %s_h\n", headername.Data());
}
if (istemplate) {
std::vector<const char*> argtype;
@@ -174,18 +179,22 @@ UInt_t TMakeProject::GenerateClassPrefix(FILE *fp, const char *clname, Bool_t to
argtype.push_back("typename");
}
UInt_t nest = 0;
- for(Ssiz_t i = pos; i<protoname.Length(); ++i) {
- switch(protoname[i]) {
- case '<': ++nest; break;
- case '>': --nest; break;
- case ',':
- if (nest==1) {
+ for (Ssiz_t i = pos; i < protoname.Length(); ++i) {
+ switch (protoname[i]) {
+ case '<':
+ ++nest;
+ break;
+ case '>':
+ --nest;
+ break;
+ case ',':
+ if (nest == 1) {
if (isdigit(protoname[i+1])) {
argtype.push_back("int");
} else {
argtype.push_back("typename");
}
- ++nparam;
+ ++nparam;
}
break;
}
@@ -193,46 +202,46 @@ UInt_t TMakeProject::GenerateClassPrefix(FILE *fp, const char *clname, Bool_t to
protoname.Remove(pos);
}
// Forward declaration of template.
- fprintf(fp,"template <");
- for(UInt_t p = 0; p < nparam; ++p) {
- fprintf(fp,"%s T%d",argtype[p],p);
- if (p!=(nparam-1)) fprintf(fp,", ");
+ fprintf(fp, "template <");
+ for (UInt_t p = 0; p < nparam; ++p) {
+ fprintf(fp, "%s T%d", argtype[p], p);
+ if (p != (nparam - 1)) fprintf(fp, ", ");
}
- fprintf(fp,"> class %s;\n",protoname.Data());
- fprintf(fp,"template <> ");
+ fprintf(fp, "> class %s;\n", protoname.Data());
+ fprintf(fp, "template <> ");
}
if (implementEmptyClass) {
if (istemplate) {
- fprintf(fp,"class %s",clname);
- fprintf(fp, " {\n" );
+ fprintf(fp, "class %s", clname);
+ fprintf(fp, " {\n");
if (numberOfClasses) ++(*numberOfClasses);
fprintf(fp, "public:\n");
fprintf(fp, "operator int() { return 0; };\n");
} else {
- fprintf(fp, "enum %s { kDefault_%s };\n",clname,clname);
+ fprintf(fp, "enum %s { kDefault_%s };\n", clname, clname);
// The nesting space of this class may not be #pragma declared (and without
// the dictionary is broken), so for now skip those
- if (strchr(fullname,':')==0) {
+ if (strchr(fullname, ':') == 0) {
// yes this is too aggressive, this needs to be fixed properly by moving the #pragma out of band.
fprintf(fp, Form("#ifdef __MAKECINT__\n#pragma link C++ class %s+;\n#endif\n", fullname));
}
fprintf(fp, "#endif\n");
}
} else {
- fprintf(fp,"class %s",clname);
+ fprintf(fp, "class %s", clname);
}
return numberOfNamespaces;
}
//______________________________________________________________________________
-UInt_t TMakeProject::GenerateForwardDeclaration(FILE *fp, const char *clname, char *inclist, Bool_t implementEmptyClass)
+UInt_t TMakeProject::GenerateForwardDeclaration(FILE *fp, const char *clname, char *inclist, Bool_t implementEmptyClass)
{
// Insert a (complete) forward declaration for the class 'clname'
UInt_t ninc = 0;
- if (strchr(clname,'<')) {
+ if (strchr(clname, '<')) {
ninc += GenerateIncludeForTemplate(fp, clname, inclist, kTRUE);
}
TString protoname;
@@ -240,19 +249,19 @@ UInt_t TMakeProject::GenerateForwardDeclaration(FILE *fp, const char *clname, ch
UInt_t numberOfNamespaces = GenerateClassPrefix(fp, clname, kTRUE, protoname, &numberOfClasses, implementEmptyClass);
fprintf(fp, ";\n");
- for(UInt_t i=0;i<numberOfClasses;++i) {
- fprintf(fp,"}; // end of class.\n");
- fprintf(fp,"#endif\n");
+ for (UInt_t i = 0;i < numberOfClasses;++i) {
+ fprintf(fp, "}; // end of class.\n");
+ fprintf(fp, "#endif\n");
}
- for(UInt_t i=0;i<numberOfNamespaces;++i) {
- fprintf(fp,"} // end of namespace.\n");
+ for (UInt_t i = 0;i < numberOfNamespaces;++i) {
+ fprintf(fp, "} // end of namespace.\n");
}
return ninc;
}
//______________________________________________________________________________
-UInt_t TMakeProject::GenerateIncludeForTemplate(FILE *fp, const char *clname, char *inclist, Bool_t forward)
+UInt_t TMakeProject::GenerateIncludeForTemplate(FILE *fp, const char *clname, char *inclist, Bool_t forward)
{
// Add to the header file, the #include needed for the argument of
// this template.
@@ -262,67 +271,85 @@ UInt_t TMakeProject::GenerateIncludeForTemplate(FILE *fp, const char *clname, ch
UInt_t nest = 0;
UInt_t last = 0;
-
- for(UInt_t i = 0; i < len; ++i) {
- switch(clname[i]) {
- case '<': ++nest; if (nest==1) last = i+1; break;
- case '>': --nest; /* intentional fall throught to the next case */
- case ',':
- if ((clname[i]==','&&nest==1) || (clname[i]=='>'&&nest==0)) {
- TString incName( clname+last, i-last );
- incName = TClassEdit::ShortType(incName.Data(), 1);
- if (clname[i]=='>' && nest==1) incName.Append(">");
- Int_t stlType;
- if (isdigit(incName[0])) {
- // Not a class name, nothing to do.
- } else if ((stlType = TClassEdit::IsSTLCont(incName))) {
- const char *what = "";
- switch(stlType) {
- case TClassEdit::kVector: what = "vector"; break;
- case TClassEdit::kList: what = "list"; break;
- case TClassEdit::kDeque: what = "deque"; break;
- case TClassEdit::kMap: what = "map"; break;
- case TClassEdit::kMultiMap: what = "map"; break;
- case TClassEdit::kSet: what = "set"; break;
- case TClassEdit::kMultiSet: what = "set"; break;
- }
- AddInclude(fp, what, kTRUE, inclist);
- fprintf(fp, "namespace std {} using namespace std;\n");
- ninc += GenerateIncludeForTemplate(fp, incName, inclist, forward);
- } else if (strncmp(incName.Data(),"pair<",strlen("pair<"))==0) {
- AddInclude(fp, "utility", kTRUE, inclist);
- ninc += GenerateIncludeForTemplate(fp, incName, inclist, forward);
- } else if (TClassEdit::IsStdClass(incName)) {
- // Do nothing.
- } else {
- TClass *cl = gROOT->GetClass( incName );
- if (!forward && cl) {
- if (cl->GetClassInfo()) {
- // We have the real dictionary for this class.
- const char *include = cl->GetDeclFileName();
- if (include && strlen(include) != 0) {
-
- if (strncmp(include,"include/",8)==0) {
- include += 8;
- }
- if (strncmp(include,"include\\",9)==0) {
- include += 9;
+ for (UInt_t i = 0; i < len; ++i) {
+ switch (clname[i]) {
+ case '<':
+ ++nest;
+ if (nest == 1) last = i + 1;
+ break;
+ case '>':
+ --nest; /* intentional fall throught to the next case */
+ case ',':
+ if ((clname[i] == ',' && nest == 1) || (clname[i] == '>' && nest == 0)) {
+ TString incName(clname + last, i - last);
+ incName = TClassEdit::ShortType(incName.Data(), 1);
+ if (clname[i] == '>' && nest == 1) incName.Append(">");
+ Int_t stlType;
+ if (isdigit(incName[0])) {
+ // Not a class name, nothing to do.
+ } else if ((stlType = TClassEdit::IsSTLCont(incName))) {
+ const char *what = "";
+ switch (stlType) {
+ case TClassEdit::kVector:
+ what = "vector";
+ break;
+ case TClassEdit::kList:
+ what = "list";
+ break;
+ case TClassEdit::kDeque:
+ what = "deque";
+ break;
+ case TClassEdit::kMap:
+ what = "map";
+ break;
+ case TClassEdit::kMultiMap:
+ what = "map";
+ break;
+ case TClassEdit::kSet:
+ what = "set";
+ break;
+ case TClassEdit::kMultiSet:
+ what = "set";
+ break;
+ }
+ AddInclude(fp, what, kTRUE, inclist);
+ fprintf(fp, "namespace std {} using namespace std;\n");
+ ninc += GenerateIncludeForTemplate(fp, incName, inclist, forward);
+ } else if (strncmp(incName.Data(), "pair<", strlen("pair<")) == 0) {
+ AddInclude(fp, "utility", kTRUE, inclist);
+ ninc += GenerateIncludeForTemplate(fp, incName, inclist, forward);
+ } else if (TClassEdit::IsStdClass(incName)) {
+ // Do nothing.
+ } else {
+ TClass *cl = gROOT->GetClass(incName);
+ if (!forward && cl) {
+ if (cl->GetClassInfo()) {
+ // We have the real dictionary for this class.
+
+ const char *include = cl->GetDeclFileName();
+ if (include && strlen(include) != 0) {
+
+ if (strncmp(include, "include/", 8) == 0) {
+ include += 8;
+ }
+ if (strncmp(include, "include\\", 9) == 0) {
+ include += 9;
+ }
+ TMakeProject::AddInclude(fp, include, kFALSE, inclist);
}
- TMakeProject::AddInclude( fp, include, kFALSE, inclist);
+ GenerateIncludeForTemplate(fp, incName, inclist, forward);
+ } else {
+ incName = GetHeaderName(incName);
+ incName.Append(".h");
+ AddInclude(fp, incName, kFALSE, inclist);
}
- GenerateIncludeForTemplate( fp, incName, inclist, forward );
- } else {
- incName = GetHeaderName(incName);
- incName.Append(".h");
- AddInclude( fp, incName, kFALSE, inclist);
+ } else if (incName.Length() && incName[0] != ' ' && gROOT->GetType(incName) == 0) {
+ GenerateForwardDeclaration(fp, incName, inclist, !cl);
}
- } else if (incName.Length() && incName[0]!=' ' && gROOT->GetType(incName)==0) {
- GenerateForwardDeclaration(fp, incName, inclist, !cl);
}
+ last = i + 1;
}
- last = i+1;
- }
}
}
@@ -330,25 +357,24 @@ UInt_t TMakeProject::GenerateIncludeForTemplate(FILE *fp, const char *clname, ch
if (stlType) {
std::vector<std::string> inside;
int nestedLoc;
- TClassEdit::GetSplit( clname, inside, nestedLoc );
+ TClassEdit::GetSplit(clname, inside, nestedLoc);
Int_t stlkind = TClassEdit::STLKind(inside[0].c_str());
TClass *key = TClass::GetClass(inside[1].c_str());
if (key) {
std::string what;
- switch ( stlkind ) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
- {
- what = "pair<";
- what += inside[1];
- what += ",";
- what += inside[2];
- what += " >";
- AddUniqueStatement(fp, Form("#ifdef __MAKECINT__\n#pragma link C++ class %s+;\n#endif\n",what.c_str()), inclist);
- break;
- }
+ switch (stlkind) {
+ case TClassEdit::kMap:
+ case TClassEdit::kMultiMap: {
+ what = "pair<";
+ what += inside[1];
+ what += ",";
+ what += inside[2];
+ what += " >";
+ AddUniqueStatement(fp, Form("#ifdef __MAKECINT__\n#pragma link C++ class %s+;\n#endif\n", what.c_str()), inclist);
+ break;
+ }
}
- }
+ }
}
return ninc;
--
GitLab