void SPRAY::set_union(const VariableIdSet& set1, const VariableIdSet& set2, VariableIdSet& rset)
{
VariableIdSet::const_iterator it1 = set1.begin();
VariableIdSet::const_iterator it2 = set2.begin();
VariableIdSet::iterator rit = rset.begin();
// // re-implementation of set-union
while(true)
{
if(it1 == set1.end())
{
rset.insert(it2, set2.end());
break;
}
if(it2 == set2.end())
{
rset.insert(it1, set1.end());
break;
}
if(*it1 < *it2)
{
rset.insert(rit, *it1); ++it1; ++rit;
}
else if(*it2 < *it1)
{
rset.insert(rit, *it2); ++it2; ++rit;
}
else
{
rset.insert(rit, *it1); ++it1; ++it2; ++rit;
}
}
}
VariableIdSet SPRAY::IntervalPropertyState::allVariableIds() {
VariableIdSet set;
for(IntervalMapType::iterator i=intervals.begin();i!=intervals.end();++i) {
set.insert((*i).first);
}
return set;
}
VariableIdSet PState::getVariableIds() const {
VariableIdSet varIdSet;
for(PState::const_iterator i=begin();i!=end();++i) {
VariableId varId=(*i).first;
varIdSet.insert(varId);
}
return varIdSet;
}
VariableIdSet
AnalysisAbstractionLayer::usedVariablesInsideFunctions(SgProject* project, VariableIdMapping* variableIdMapping) {
list<SgVarRefExp*> varRefExpList=SgNodeHelper::listOfUsedVarsInFunctions(project);
VariableIdSet setOfUsedVars;
for(list<SgVarRefExp*>::iterator i=varRefExpList.begin();i!=varRefExpList.end();++i) {
setOfUsedVars.insert(variableIdMapping->variableId(*i));
}
return setOfUsedVars;
}
/*!
* \author Markus Schordan
* \date 2012.
*/
VariableIdMapping::VariableIdSet VariableIdMapping::getVariableIdSet() {
VariableIdSet set;
for(map<SgSymbol*,size_t>::iterator i=mappingSymToVarId.begin();i!=mappingSymToVarId.end();++i) {
size_t t=(*i).second;
VariableId id;
id.setIdCode(t);
set.insert(id);
}
return set;
}
void FIConstAnalysis::filterVariables(VariableIdSet& variableIdSet) {
VariableIdSet toBeRemoved;
for(VarConstSetMap::iterator i=_varConstSetMap.begin(); i!=_varConstSetMap.end(); ++i) {
VariableId varId=(*i).first;
if(variableIdSet.find(varId)==variableIdSet.end()) {
toBeRemoved.insert(varId);
}
}
for(VariableIdSet::iterator i=toBeRemoved.begin(); i!=toBeRemoved.end(); ++i) {
_varConstSetMap.erase(*i);
}
}
VariableIdSet Threadification::determineVariablesOfInterest(SgNode* root) {
VariableIdSet varIdSet;
RoseAst ast(root);
for(RoseAst::iterator i=ast.begin();i!=ast.end();++i) {
if(SgVariableDeclaration* varDecl=isSgVariableDeclaration(*i)) {
VariableId varId=_variableIdMapping->variableId(varDecl);
// specifically exclude array variable declarations
if( (_variableIdMapping->hasPointerType(varId)||_variableIdMapping->hasIntegerType(varId))
&& _variableIdMapping->variableName(varId) != "stdout"
&& _variableIdMapping->variableName(varId) != "__PRETTY_FUNCTION__" ) {
varIdSet.insert(varId);
}
}
}
return varIdSet;
}
VariableIdMapping::VariableIdSet VariableIdMapping::variableIdsOfAstSubTree(SgNode* node) {
VariableIdSet vset;
RoseAst ast(node);
for(RoseAst::iterator i=ast.begin();i!=ast.end();++i) {
VariableId vid; // default creates intentionally an invalid id.
if(SgVariableDeclaration* varDecl=isSgVariableDeclaration(*i)) {
vid=variableId(varDecl);
} else if(SgVarRefExp* varRefExp=isSgVarRefExp(*i)) {
vid=variableId(varRefExp);
} else if(SgInitializedName* initName=isSgInitializedName(*i)) {
vid=variableId(initName);
}
if(vid.isValid())
vset.insert(vid);
}
return vset;
}
// returns the number of race conditions detected (0 or 1 as of now)
int Specialization::verifyUpdateSequenceRaceConditions(LoopInfoSet& loopInfoSet, ArrayUpdatesSequence& arrayUpdates, VariableIdMapping* variableIdMapping) {
int cnt=0;
stringstream ss;
cout<<"STATUS: checking race conditions."<<endl;
cout<<"INFO: number of parallel loops: "<<numParLoops(loopInfoSet,variableIdMapping)<<endl;
VariableIdSet allIterVars;
for(LoopInfoSet::iterator lis=loopInfoSet.begin();lis!=loopInfoSet.end();++lis) {
allIterVars.insert((*lis).iterationVarId);
}
for(LoopInfoSet::iterator lis=loopInfoSet.begin();lis!=loopInfoSet.end();++lis) {
if((*lis).iterationVarType==ITERVAR_PAR) {
VariableId parVariable;
parVariable=(*lis).iterationVarId;
cout<<"INFO: checking parallel loop: "<<variableIdMapping->variableName(parVariable)<<endl;
// race check
// intersect w-set_i = empty
// w-set_i intersect r-set_j = empty, i!=j.
IndexToReadWriteDataMap indexToReadWriteDataMap;
for(ArrayUpdatesSequence::iterator i=arrayUpdates.begin();i!=arrayUpdates.end();++i) {
const EState* estate=(*i).first;
const PState* pstate=estate->pstate();
SgExpression* exp=(*i).second;
IndexVector index;
// use all vars for indexing or only outer+par loop variables
#ifdef USE_ALL_ITER_VARS
for(VariableIdSet::iterator ol=allIterVars.begin();ol!=allIterVars.end();++ol) {
VariableId otherVarId=*ol;
ROSE_ASSERT(otherVarId.isValid());
if(!pstate->varValue(otherVarId).isTop()) {
int otherIntVal=pstate->varValue(otherVarId).getIntValue();
index.push_back(otherIntVal);
}
}
#else
for(VariableIdSet::iterator ol=(*lis).outerLoopsVarIds.begin();ol!=(*lis).outerLoopsVarIds.end();++ol) {
VariableId otherVarId=*ol;
ROSE_ASSERT(otherVarId.isValid());
if(!pstate->varValue(otherVarId).isTop()&&pstate->varValue(otherVarId).isConstInt()) {
int otherIntVal=pstate->varValue(otherVarId).getIntValue();
index.push_back(otherIntVal);
}
}
if(!pstate->varValue(parVariable).isTop()&&pstate->varValue(parVariable).isConstInt()) {
int parIntVal=pstate->varValue(parVariable).getIntValue();
index.push_back(parIntVal);
}
#endif
if((*lis).isInAssociatedLoop(estate)) {
SgExpression* lhs=isSgExpression(SgNodeHelper::getLhs(exp));
SgExpression* rhs=isSgExpression(SgNodeHelper::getRhs(exp));
ROSE_ASSERT(isSgPntrArrRefExp(lhs)||SgNodeHelper::isFloatingPointAssignment(exp));
//cout<<"EXP: "<<exp->unparseToString()<<", lhs:"<<lhs->unparseToString()<<" :: "<<endl;
// read-set
RoseAst rhsast(rhs);
for(RoseAst::iterator j=rhsast.begin();j!=rhsast.end();++j) {
if(SgPntrArrRefExp* useRef=isSgPntrArrRefExp(*j)) {
j.skipChildrenOnForward();
ArrayElementAccessData access(useRef,variableIdMapping);
indexToReadWriteDataMap[index].readArrayAccessSet.insert(access);
} else if(SgVarRefExp* useRef=isSgVarRefExp(*j)) {
ROSE_ASSERT(useRef);
j.skipChildrenOnForward();
VariableId varId=variableIdMapping->variableId(useRef);
indexToReadWriteDataMap[index].readVarIdSet.insert(varId);
} else {
//cout<<"INFO: UpdateExtraction: ignored expression on rhs:"<<(*j)->unparseToString()<<endl;
}
}
if(SgPntrArrRefExp* arr=isSgPntrArrRefExp(lhs)) {
ArrayElementAccessData access(arr,variableIdMapping);
indexToReadWriteDataMap[index].writeArrayAccessSet.insert(access);
} else if(SgVarRefExp* var=isSgVarRefExp(lhs)) {
VariableId varId=variableIdMapping->variableId(var);
indexToReadWriteDataMap[index].writeVarIdSet.insert(varId);
} else {
cerr<<"Error: SSA Numbering: unknown LHS."<<endl;
exit(1);
}
ss<<"UPD"<<cnt<<":"<<pstate->toString(variableIdMapping)<<" : "<<exp->unparseToString()<<endl;
++cnt;
}
} // array sequence iter
// to be utilized later for more detailed output
#if 0
for(IndexToReadWriteDataMap::iterator imap=indexToReadWriteDataMap.begin();
imap!=indexToReadWriteDataMap.end();
++imap) {
// cout<<"DEBUG: INDEX: "<<(*imap).first<<" R-SET: ";
IndexVector index=(*imap).first;
cout<<"DEBUG: INDEX: ";
for(IndexVector::iterator iv=index.begin();iv!=index.end();++iv) {
if(iv!=index.begin())
cout<<",";
cout<<*iv;
}
cout<<" R-SET: ";
for(ArrayElementAccessDataSet::const_iterator i=indexToReadWriteDataMap[index].readArrayAccessSet.begin();i!=indexToReadWriteDataMap[index].readArrayAccessSet.end();++i) {
cout<<(*i).toString(variableIdMapping)<<" ";
}
cout<<endl;
cout<<"DEBUG: INDEX: ";
for(IndexVector::iterator iv=index.begin();iv!=index.end();++iv) {
if(iv!=index.begin())
cout<<",";
cout<<*iv;
}
cout<<" W-SET: ";
for(ArrayElementAccessDataSet::const_iterator i=indexToReadWriteDataMap[index].writeArrayAccessSet.begin();i!=indexToReadWriteDataMap[index].writeArrayAccessSet.end();++i) {
cout<<(*i).toString(variableIdMapping)<<" ";
}
cout<<endl;
cout<<"DEBUG: read-array-access:"<<indexToReadWriteDataMap[index].readArrayAccessSet.size()<<" read-var-access:"<<indexToReadWriteDataMap[index].readVarIdSet.size()<<endl;
cout<<"DEBUG: write-array-access:"<<indexToReadWriteDataMap[index].writeArrayAccessSet.size()<<" write-var-access:"<<indexToReadWriteDataMap[index].writeVarIdSet.size()<<endl;
} // imap
#endif
// perform the check now
// 1) compute vector if index-vectors for each outer-var-vector
// 2) check each index-vector. For each iteration of each par-loop iteration then.
//typedef set<int> ParVariableValueSet;
//ParVariableValueSet parVariableValueSet;
// MAP: par-variable-val -> vector of IndexVectors with this par-variable-val
typedef vector<IndexVector> ThreadVector;
typedef map<IndexVector,ThreadVector > CheckMapType;
CheckMapType checkMap;
for(IndexToReadWriteDataMap::iterator imap=indexToReadWriteDataMap.begin();
imap!=indexToReadWriteDataMap.end();
++imap) {
IndexVector index=(*imap).first;
IndexVector outVarIndex;
// if index.size()==0, it will analyze the loop independet of outer loops
if(index.size()>0) {
ROSE_ASSERT(index.size()>0);
for(size_t iv1=0;iv1<index.size()-1;iv1++) {
outVarIndex.push_back(index[iv1]);
}
ROSE_ASSERT(outVarIndex.size()<index.size());
} else {
// nothing to check
continue;
}
// last index of index of par-variable
//int parVariableValue=index[index.size()-1];
checkMap[outVarIndex].push_back(index);
}
//cout<<"INFO: race condition check-map size: "<<checkMap.size()<<endl;
// perform the check now
for(CheckMapType::iterator miter=checkMap.begin();miter!=checkMap.end();++miter) {
IndexVector outerVarIndexVector=(*miter).first;
ThreadVector threadVectorToCheck=(*miter).second;
//cout<<"DEBUG: to check: "<<threadVectorToCheck.size()<<endl;
for(ThreadVector::iterator tv1=threadVectorToCheck.begin();tv1!=threadVectorToCheck.end();++tv1) {
ArrayElementAccessDataSet wset=indexToReadWriteDataMap[*tv1].writeArrayAccessSet;
for(ThreadVector::iterator tv2=tv1;tv2!=threadVectorToCheck.end();++tv2) {
ThreadVector::iterator tv2b=tv2;
++tv2b;
if(tv2b!=threadVectorToCheck.end()) {
ArrayElementAccessDataSet rset2=indexToReadWriteDataMap[*tv2b].readArrayAccessSet;
ArrayElementAccessDataSet wset2=indexToReadWriteDataMap[*tv2b].writeArrayAccessSet;
// check intersect(rset,wset)
if(accessSetIntersect(wset,rset2)) {
// verification failed
cout<<"INFO: race condition detected (wset1,rset2)."<<endl;
return 1;
}
if(accessSetIntersect(wset,wset2)) {
// verification failed
cout<<"INFO: race condition detected (wset1,wset2)."<<endl;
return 1;
}
}
}
}
}
} // if parallel loop
} // foreach loop
return 0;
}
// TODO: this function ignores all reported memory access to unnamed memory cells
void extractVariableIdSetFromVarsInfo(VariableIdSet& varIdSet, VarsInfo& varsInfo) {
VariableIdInfoMap& vim=varsInfo.first;
for(VariableIdInfoMap::iterator i=vim.begin();i!=vim.end();++i) {
varIdSet.insert((*i).first);
}
}
int main(int argc, char* argv[]) {
try {
if(argc==1) {
cout << "Error: wrong command line options."<<endl;
exit(1);
}
#if 0
if(argc==3) {
csvAssertFileName=argv[2];
argc=2; // don't confuse ROSE command line
cout<< "INIT: CSV-output file: "<<csvAssertFileName<<endl;
}
#endif
// Command line option handling.
namespace po = boost::program_options;
po::options_description desc
("Woodpecker V0.1\n"
"Written by Markus Schordan\n"
"Supported options");
desc.add_options()
("help,h", "produce this help message.")
("rose-help", "show help for compiler frontend options.")
("version,v", "display the version.")
("stats", "display code statistics.")
("normalize", po::value< string >(), "normalize code (eliminate compound assignment operators).")
("inline",po::value< string >(), "perform inlining ([yes]|no).")
("eliminate-empty-if",po::value< string >(), "eliminate if-statements with empty branches in main function ([yes]/no).")
("eliminate-dead-code",po::value< string >(), "eliminate dead code (variables and expressions) ([yes]|no).")
("csv-const-result",po::value< string >(), "generate csv-file [arg] with const-analysis data.")
("generate-transformed-code",po::value< string >(), "generate transformed code with prefix rose_ ([yes]|no).")
("verbose",po::value< string >(), "print detailed output during analysis and transformation (yes|[no]).")
("generate-conversion-functions","generate code for conversion functions between variable names and variable addresses.")
("csv-assert",po::value< string >(), "name of csv file with reachability assert results'")
("enable-multi-const-analysis",po::value< string >(), "enable multi-const analysis.")
("transform-thread-variable", "transform code to use additional thread variable.")
;
// ("int-option",po::value< int >(),"option info")
po::store(po::command_line_parser(argc, argv).
options(desc).allow_unregistered().run(), args);
po::notify(args);
if (args.count("help")) {
cout << "woodpecker <filename> [OPTIONS]"<<endl;
cout << desc << "\n";
return 0;
}
if (args.count("rose-help")) {
argv[1] = strdup("--help");
}
if (args.count("version")) {
cout << "Woodpecker version 0.1\n";
cout << "Written by Markus Schordan 2013\n";
return 0;
}
if (args.count("csv-assert")) {
csvAssertFileName=args["csv-assert"].as<string>().c_str();
}
if (args.count("csv-const-result")) {
csvConstResultFileName=args["csv-const-result"].as<string>().c_str();
}
boolOptions.init(argc,argv);
// temporary fake optinos
boolOptions.registerOption("arith-top",false); // temporary
boolOptions.registerOption("semantic-fold",false); // temporary
boolOptions.registerOption("post-semantic-fold",false); // temporary
// regular options
boolOptions.registerOption("normalize",false);
boolOptions.registerOption("inline",true);
boolOptions.registerOption("eliminate-empty-if",true);
boolOptions.registerOption("eliminate-dead-code",true);
boolOptions.registerOption("generate-transformed-code",true);
boolOptions.registerOption("enable-multi-const-analysis",false);
boolOptions.registerOption("verbose",false);
boolOptions.processOptions();
if(boolOptions["verbose"])
detailedOutput=1;
// clean up string-options in argv
for (int i=1; i<argc; ++i) {
if (string(argv[i]) == "--csv-assert"
|| string(argv[i]) == "--csv-const-result"
) {
// do not confuse ROSE frontend
argv[i] = strdup("");
assert(i+1<argc);
argv[i+1] = strdup("");
}
}
global_option_multiconstanalysis=boolOptions["enable-multi-const-analysis"];
#if 0
if(global_option_multiconstanalysis) {
cout<<"INFO: Using flow-insensitive multi-const-analysis."<<endl;
} else {
cout<<"INFO: Using flow-insensitive unique-const-analysis."<<endl;
}
#endif
cout << "INIT: Parsing and creating AST started."<<endl;
SgProject* root = frontend(argc,argv);
// AstTests::runAllTests(root);
// inline all functions
cout << "INIT: Parsing and creating AST finished."<<endl;
if(args.count("stats")) {
printCodeStatistics(root);
exit(0);
}
VariableIdMapping variableIdMapping;
variableIdMapping.computeVariableSymbolMapping(root);
if(args.count("transform-thread-variable")) {
Threadification* threadTransformation=new Threadification(&variableIdMapping);
threadTransformation->transform(root);
root->unparse(0,0);
delete threadTransformation;
cout<<"STATUS: generated program with introduced thread-variable."<<endl;
exit(0);
}
SgFunctionDefinition* mainFunctionRoot=0;
if(boolOptions["inline"]) {
cout<<"STATUS: eliminating non-called trivial functions."<<endl;
// inline functions
TrivialInlining tin;
tin.setDetailedOutput(detailedOutput);
tin.inlineFunctions(root);
DeadCodeElimination dce;
// eliminate non called functions
int numEliminatedFunctions=dce.eliminateNonCalledTrivialFunctions(root);
cout<<"STATUS: eliminated "<<numEliminatedFunctions<<" functions."<<endl;
} else {
cout<<"INFO: Inlining: turned off."<<endl;
}
if(boolOptions["eliminate-empty-if"]) {
DeadCodeElimination dce;
cout<<"STATUS: Eliminating empty if-statements."<<endl;
size_t num=0;
size_t numTotal=num;
do {
num=dce.eliminateEmptyIfStmts(root);
cout<<"INFO: Number of if-statements eliminated: "<<num<<endl;
numTotal+=num;
} while(num>0);
cout<<"STATUS: Total number of empty if-statements eliminated: "<<numTotal<<endl;
}
if(boolOptions["normalize"]) {
cout <<"STATUS: Normalization started."<<endl;
RewriteSystem rewriteSystem;
rewriteSystem.resetStatistics();
rewriteSystem.rewriteCompoundAssignmentsInAst(root,&variableIdMapping);
cout <<"STATUS: Normalization finished."<<endl;
}
cout<<"STATUS: performing flow-insensitive const analysis."<<endl;
VarConstSetMap varConstSetMap;
VariableIdSet variablesOfInterest;
FIConstAnalysis fiConstAnalysis(&variableIdMapping);
fiConstAnalysis.setOptionMultiConstAnalysis(global_option_multiconstanalysis);
fiConstAnalysis.setDetailedOutput(detailedOutput);
fiConstAnalysis.runAnalysis(root, mainFunctionRoot);
variablesOfInterest=fiConstAnalysis.determinedConstantVariables();
cout<<"INFO: variables of interest: "<<variablesOfInterest.size()<<endl;
if(detailedOutput)
printResult(variableIdMapping,varConstSetMap);
if(csvConstResultFileName) {
VariableIdSet setOfUsedVarsInFunctions=AnalysisAbstractionLayer::usedVariablesInsideFunctions(root,&variableIdMapping);
VariableIdSet setOfUsedVarsGlobalInit=AnalysisAbstractionLayer::usedVariablesInGlobalVariableInitializers(root,&variableIdMapping);
VariableIdSet setOfAllUsedVars = setOfUsedVarsInFunctions;
setOfAllUsedVars.insert(setOfUsedVarsGlobalInit.begin(), setOfUsedVarsGlobalInit.end());
cout<<"INFO: number of used vars inside functions: "<<setOfUsedVarsInFunctions.size()<<endl;
cout<<"INFO: number of used vars in global initializations: "<<setOfUsedVarsGlobalInit.size()<<endl;
cout<<"INFO: number of vars inside functions or in global inititializations: "<<setOfAllUsedVars.size()<<endl;
fiConstAnalysis.filterVariables(setOfAllUsedVars);
fiConstAnalysis.writeCvsConstResult(variableIdMapping, string(csvConstResultFileName));
}
if(args.count("generate-conversion-functions")) {
string conversionFunctionsFileName="conversionFunctions.C";
ConversionFunctionsGenerator gen;
set<string> varNameSet;
std::list<SgVariableDeclaration*> globalVarDeclList=SgNodeHelper::listOfGlobalVars(root);
for(std::list<SgVariableDeclaration*>::iterator i=globalVarDeclList.begin();i!=globalVarDeclList.end();++i) {
SgInitializedNamePtrList& initNamePtrList=(*i)->get_variables();
for(SgInitializedNamePtrList::iterator j=initNamePtrList.begin();j!=initNamePtrList.end();++j) {
SgInitializedName* initName=*j;
if ( true || isSgArrayType(initName->get_type()) ) { // optional filter (array variables only)
SgName varName=initName->get_name();
string varNameString=varName; // implicit conversion
varNameSet.insert(varNameString);
}
}
}
string code=gen.generateCodeForGlobalVarAdressMaps(varNameSet);
ofstream myfile;
myfile.open(conversionFunctionsFileName.c_str());
myfile<<code;
myfile.close();
}
VariableConstInfo vci=*(fiConstAnalysis.getVariableConstInfo());
DeadCodeElimination dce;
if(boolOptions["eliminate-dead-code"]) {
cout<<"STATUS: performing dead code elimination."<<endl;
dce.setDetailedOutput(detailedOutput);
dce.setVariablesOfInterest(variablesOfInterest);
dce.eliminateDeadCodePhase1(root,&variableIdMapping,vci);
cout<<"STATUS: Eliminated "<<dce.numElimVars()<<" variable declarations."<<endl;
cout<<"STATUS: Eliminated "<<dce.numElimAssignments()<<" variable assignments."<<endl;
cout<<"STATUS: Replaced "<<dce.numElimVarUses()<<" uses of variables with constant."<<endl;
cout<<"STATUS: Eliminated "<<dce.numElimVars()<<" dead variables."<<endl;
cout<<"STATUS: Dead code elimination phase 1: finished."<<endl;
cout<<"STATUS: Performing condition const analysis."<<endl;
} else {
cout<<"STATUS: Dead code elimination: turned off."<<endl;
}
if(csvAssertFileName) {
cout<<"STATUS: performing flow-insensensitive condition-const analysis."<<endl;
Labeler labeler(root);
fiConstAnalysis.performConditionConstAnalysis(&labeler);
cout<<"INFO: Number of true-conditions : "<<fiConstAnalysis.getTrueConditions().size()<<endl;
cout<<"INFO: Number of false-conditions : "<<fiConstAnalysis.getFalseConditions().size()<<endl;
cout<<"INFO: Number of non-const-conditions: "<<fiConstAnalysis.getNonConstConditions().size()<<endl;
cout<<"STATUS: performing flow-insensensitive reachability analysis."<<endl;
ReachabilityAnalysis ra;
PropertyValueTable reachabilityResults=ra.fiReachabilityAnalysis(labeler, fiConstAnalysis);
cout<<"STATUS: generating file "<<csvAssertFileName<<endl;
reachabilityResults.writeFile(csvAssertFileName,true);
}
#if 0
rdAnalyzer->determineExtremalLabels(startFunRoot);
rdAnalyzer->run();
#endif
cout << "INFO: Remaining functions in program: "<<numberOfFunctions(root)<<endl;
if(boolOptions["generate-transformed-code"]) {
cout << "STATUS: generating transformed source code."<<endl;
root->unparse(0,0);
}
std::list<int> fakelist;
fakelist.push_back(1);
std::list<int>::iterator myit=fakelist.begin();
fakelist.erase(myit);
cout<< "STATUS: finished."<<endl;
// main function try-catch
} catch(char* str) {
cerr << "*Exception raised: " << str << endl;
return 1;
} catch(const char* str) {
cerr << "Exception raised: " << str << endl;
return 1;
} catch(string str) {
cerr << "Exception raised: " << str << endl;
return 1;
}
return 0;
}
