mirror of
https://github.com/reactos/CMake.git
synced 2024-11-26 04:50:24 +00:00
311 lines
7.2 KiB
C++
311 lines
7.2 KiB
C++
/*=========================================================================
|
|
|
|
Program: Insight Segmentation & Registration Toolkit
|
|
Module: $RCSfile$
|
|
Language: C++
|
|
Date: $Date$
|
|
Version: $Revision$
|
|
|
|
|
|
Copyright (c) 2000 National Library of Medicine
|
|
All rights reserved.
|
|
|
|
See COPYRIGHT.txt for copyright details.
|
|
|
|
=========================================================================*/
|
|
#include "cmSystemTools.h"
|
|
#include "errno.h"
|
|
#include <sys/stat.h>
|
|
#include "cmRegularExpression.h"
|
|
|
|
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
|
#include <windows.h>
|
|
#include <direct.h>
|
|
inline int Mkdir(const char* dir)
|
|
{
|
|
return _mkdir(dir);
|
|
}
|
|
#else
|
|
#include <sys/types.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
inline int Mkdir(const char* dir)
|
|
{
|
|
return mkdir(dir, 00700);
|
|
}
|
|
#endif
|
|
|
|
|
|
bool cmSystemTools::MakeDirectory(const char* path)
|
|
{
|
|
std::string dir = path;
|
|
// replace all of the \ with /
|
|
size_t pos = 0;
|
|
while((pos = dir.find('\\', pos)) != std::string::npos)
|
|
{
|
|
dir[pos] = '/';
|
|
pos++;
|
|
}
|
|
pos = dir.find(':');
|
|
if(pos == std::string::npos)
|
|
{
|
|
pos = 0;
|
|
}
|
|
while((pos = dir.find('/', pos)) != std::string::npos)
|
|
{
|
|
std::string topdir = dir.substr(0, pos);
|
|
Mkdir(topdir.c_str());
|
|
pos++;
|
|
}
|
|
if(Mkdir(path) != 0)
|
|
{
|
|
// if it is some other error besides directory exists
|
|
// then return false
|
|
if(errno != EEXIST)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
// replace replace with with as many times as it shows up in source.
|
|
// write the result into source.
|
|
void cmSystemTools::ReplaceString(std::string& source,
|
|
const char* replace,
|
|
const char* with)
|
|
{
|
|
int lengthReplace = strlen(replace);
|
|
std::string rest;
|
|
size_t start = source.find(replace);
|
|
while(start != std::string::npos)
|
|
{
|
|
rest = source.substr(start+lengthReplace);
|
|
source = source.substr(0, start);
|
|
source += with;
|
|
source += rest;
|
|
start = source.find(replace, start + lengthReplace );
|
|
}
|
|
}
|
|
|
|
// return true if the file exists
|
|
bool cmSystemTools::FileExists(const char* filename)
|
|
{
|
|
struct stat fs;
|
|
if (stat(filename, &fs) != 0)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
// convert windows slashes to unix slashes \ with /
|
|
void cmSystemTools::ConvertToUnixSlashes(std::string& path)
|
|
{
|
|
std::string::size_type pos = path.find('\\');
|
|
while(pos != std::string::npos)
|
|
{
|
|
path[pos] = '/';
|
|
pos = path.find('\\');
|
|
}
|
|
// remove any trailing slash
|
|
if(path[path.size()-1] == '/')
|
|
{
|
|
path = path.substr(0, path.size()-1);
|
|
}
|
|
}
|
|
|
|
|
|
int cmSystemTools::Grep(const char* dir, const char* file, const char* expression)
|
|
{
|
|
std::string path = dir;
|
|
path += "/";
|
|
path += file;
|
|
std::ifstream fin(path.c_str());
|
|
char buffer[2056];
|
|
int count = 0;
|
|
cmRegularExpression reg(expression);
|
|
while(fin)
|
|
{
|
|
fin.getline(buffer, sizeof(buffer));
|
|
count += reg.find(buffer);
|
|
}
|
|
return count;
|
|
}
|
|
|
|
|
|
void cmSystemTools::ConvertCygwinPath(std::string& pathname)
|
|
{
|
|
if(pathname.find("/cygdrive/") != std::string::npos)
|
|
{
|
|
std::string cygStuff = pathname.substr(0, 11);
|
|
std::string replace;
|
|
replace += cygStuff.at(10);
|
|
replace += ":";
|
|
cmSystemTools::ReplaceString(pathname, cygStuff.c_str(), replace.c_str());
|
|
}
|
|
}
|
|
|
|
|
|
bool cmSystemTools::ParseFunction(std::ifstream& fin,
|
|
std::string& name,
|
|
std::vector<std::string>& arguments)
|
|
{
|
|
name = "";
|
|
arguments = std::vector<std::string>();
|
|
const int BUFFER_SIZE = 4096;
|
|
char inbuffer[BUFFER_SIZE];
|
|
if(!fin)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(fin.getline(inbuffer, BUFFER_SIZE ) )
|
|
{
|
|
cmRegularExpression blankLine("^$");
|
|
cmRegularExpression comment("^#.*");
|
|
cmRegularExpression oneLiner("[ \t]*([A-Za-z_0-9]*).*\\((.*)\\)");
|
|
cmRegularExpression multiLine("[ \t]*([A-Za-z_0-9]*).*\\((.*)");
|
|
cmRegularExpression lastLine("(.*)\\)");
|
|
|
|
// BEGIN VERBATIM JUNK SHOULD BE REMOVED
|
|
cmRegularExpression verbatim("BEGIN MAKE VERBATIM");
|
|
if(verbatim.find(inbuffer))
|
|
{
|
|
cmRegularExpression endVerbatim("END MAKE VERBATIM");
|
|
name = "VERBATIM";
|
|
bool done = false;
|
|
while(!done)
|
|
{
|
|
if(fin.getline(inbuffer, BUFFER_SIZE))
|
|
{
|
|
if(endVerbatim.find(inbuffer))
|
|
{
|
|
done = true;
|
|
}
|
|
else
|
|
{
|
|
arguments.push_back(inbuffer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
done = true;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
// END VERBATIM JUNK SHOULD BE REMOVED
|
|
|
|
// check for black line or comment
|
|
if(blankLine.find(inbuffer) || comment.find(inbuffer))
|
|
{
|
|
return false;
|
|
}
|
|
// look for a oneline fun(arg arg2)
|
|
else if(oneLiner.find(inbuffer))
|
|
{
|
|
// the arguments are the second match
|
|
std::string args = oneLiner.match(2);
|
|
name = oneLiner.match(1);
|
|
// break up the arguments
|
|
cmSystemTools::GetArguments(args, arguments);
|
|
return true;
|
|
}
|
|
// look for a start of a multiline with no trailing ")" fun(arg arg2
|
|
else if(multiLine.find(inbuffer))
|
|
{
|
|
name = multiLine.match(1);
|
|
std::string args = multiLine.match(2);
|
|
cmSystemTools::GetArguments(args, arguments);
|
|
// Read lines until the closing paren is hit
|
|
bool done = false;
|
|
while(!done)
|
|
{
|
|
// read lines until the end paren is found
|
|
if(fin.getline(inbuffer, BUFFER_SIZE ) )
|
|
{
|
|
if(lastLine.find(inbuffer))
|
|
{
|
|
done = true;
|
|
std::string args = lastLine.match(1);
|
|
cmSystemTools::GetArguments(args, arguments);
|
|
}
|
|
else
|
|
{
|
|
std::string line = inbuffer;
|
|
cmSystemTools::GetArguments(line, arguments);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cmSystemTools::Error("Parse error in read function missing end )",
|
|
inbuffer);
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
cmSystemTools::Error("Parse error in read function ", inbuffer);
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
|
|
}
|
|
|
|
void cmSystemTools::GetArguments(std::string& line,
|
|
std::vector<std::string>& arguments)
|
|
{
|
|
cmRegularExpression argument("[\t ]*([-/\\\\{}\\$A-Za-z_0-9]+)[\t ]*");
|
|
cmRegularExpression argumentWithSpaces("[\t ]*\"([- /\\\\{}\\$A-Za-z_0-9]+)\"[\t ]*");
|
|
std::string arg(" ");
|
|
while(arg.length() )
|
|
{
|
|
arg = "";
|
|
long endpos;
|
|
|
|
if (argumentWithSpaces.find(line.c_str()))
|
|
{
|
|
arg = argumentWithSpaces.match(1);
|
|
endpos = argumentWithSpaces.end(1);
|
|
}
|
|
else if(argument.find(line.c_str()))
|
|
{
|
|
arg = argument.match(1);
|
|
endpos = argument.end(1);
|
|
}
|
|
if(arg.length())
|
|
{
|
|
arguments.push_back(arg);
|
|
line = line.substr(endpos, line.length() - endpos);
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmSystemTools::Error(const char* m1, const char* m2)
|
|
{
|
|
std::string message = "CMake Error: ";
|
|
if(m1)
|
|
{
|
|
message += m1;
|
|
}
|
|
if(m2)
|
|
{
|
|
message += m2;
|
|
}
|
|
#ifdef _WIN32
|
|
// MessageBox(0, message.c_str(), 0, MB_OK);
|
|
std::cerr << message.c_str() << std::endl;
|
|
#else
|
|
std::cerr << message.c_str() << std::endl;
|
|
#endif
|
|
}
|