OovString StringJoin(OovStringVec const &tokens, char delimiter)
{
OovString str;
for(size_t i=0; i<tokens.size(); i++)
{
str += tokens[i];
if(i < tokens.size()-1)
{
str += delimiter;
}
}
return str;
}
void ComponentsFile::parseProjRefs(OovStringRef const arg, OovString &rootDir,
OovStringVec &excludes)
{
excludes.clear();
OovStringVec tokens = StringSplit(arg, '!');
if(rootDir.size() == 0)
rootDir = tokens[0];
if(tokens.size() > 1)
{
excludes.resize(tokens.size()-1);
std::copy(tokens.begin()+1, tokens.end(), excludes.begin());
}
}
void BuildVarSettingsDialog::addFilterList()
{
GuiTreeItem parent;
OovString filterTag;
int index = getComboId("FilterNameComboboxtext", mFilterNames);
if(index != BAD_INDEX)
{
switch(index)
{
case FT_BuildConfig:
filterTag = OptFilterNameBuildConfig;
break;
case FT_BuildMode:
filterTag = OptFilterNameBuildMode;
break;
case FT_Component:
filterTag = OptFilterNameComponent;
break;
case FT_Platform:
filterTag = OptFilterNamePlatform;
break;
}
}
OovStringVec filterVals = mFilterValuesTreeView.getSelected();
if(filterVals.size() > 0)
{
VariableFilter filter(filterTag, filterVals[0]);
mFiltersTreeView.appendText(parent, filter.getFilterAsString());
}
updateSettingText();
}
void Editor::updateDebugDataValue()
{
OovStringVec strs = mVarView.getSelected();
if(strs.size() > 0)
{
mEditFiles.getDebugger().startGetVariable(strs[0]);
}
}
void BuildVariablesDialog::removeVariableSetting()
{
OovStringVec vars = mVarListTreeView.getSelected();
if(vars.size() > 0)
{
BuildVariable origBuildVar;
origBuildVar.initVarFromString(vars[0]);
mVarListTreeView.removeSelected();
mProject.removeName(origBuildVar.getVarFilterName());
}
}
OovString CompoundValueRef::getAsString(const OovStringVec &vec,
char delimiter)
{
OovString str;
for(size_t i=0; i<vec.size(); i++)
{
str += vec[i];
str += delimiter;
}
return str;
}
void CMaker::addLibsAndIncs(OovStringRef const compName, OovString &str)
{
OovStringVec extraIncs;
OovStringVec libs = getCompLibrariesAndIncs(compName, extraIncs);
addCommandAndNames(CT_TargLinkLibs, compName, libs, str);
if(extraIncs.size())
{
str += "include_directories(";
appendNames(extraIncs, ',', str);
str += ")\n\n";
}
}
void deleteSelected()
{
OovString selStr = mPathMapList.getSelected();
if(selStr.length() > 0)
{
OovStringVec vec = selStr.split(" > ");
if(vec.size() == 2)
{
mPathMapList.removeSelected();
mDiagramPathMap->remove(ZonePathReplaceItem(vec[0], vec[1]));
}
}
}
size_t ComponentGraph::getComponentIndex(OovStringVec const &compPaths,
OovStringRef const dir)
{
size_t compIndex = NO_INDEX;
for(size_t i=0; i<compPaths.size(); i++)
{
std::string const &compPath = compPaths[i];
if(compPath.compare(dir) == 0)
{
compIndex = i;
break;
}
}
return compIndex;
}
bool FileStat::isOutputOld(OovStringRef const outputFn,
OovStringVec const &inputs, size_t *oldIndex)
{
bool old = false;
for(size_t i=0; i<inputs.size(); i++)
{
if(isOutputOld(outputFn, inputs[i]))
{
old = true;
if(oldIndex)
*oldIndex = i;
break;
}
}
return old;
}
// First arg at index 0 is the command.
OovString OovIpcMsg::getArg(size_t argNum) const
{
OovStringVec args = split(',');
OovString arg;
#if(DEBUG_IPC)
if(argNum == 0)
{
FILE *fp = fopen("IPC.txt", "a");
fprintf(fp, "RCV: %s\n", cmdStr.getStr());
fclose(fp);
}
#endif
if(argNum < args.size())
{
arg = args[argNum];
}
return arg;
}
static int getErrorPosition(OovStringRef const line, int &charOffset)
{
int lineNum = -1;
OovStringVec tokens = StringSplit(line, ':');
auto iter = std::find_if(tokens.begin(), tokens.end(),
[](OovStringRef const tok)
{ return(isdigit(tok[0])); }
);
int starti = iter-tokens.begin();
if(tokens[starti].getInt(0, INT_MAX, lineNum))
{
if(static_cast<unsigned int>(starti+1) < tokens.size())
{
tokens[starti+1].getInt(0, INT_MAX, charOffset);
}
}
return lineNum;
}
GraphSize OperationDrawer::drawClass(DiagramDrawer &drawer, const OperationClass &node,
const OperationDrawOptions & /*options*/, bool draw)
{
GraphPoint startpos = node.getPosition();
const ModelType *type = node.getType();
OovStringRef const typeName = type->getName();
int rectx = 0;
int recty = 0;
const ModelClassifier *classifier = type->getClass();
if(classifier)
{
if(draw)
{
drawer.groupText(true, false);
}
OovStringVec strs;
std::vector<GraphPoint> positions;
strs.push_back(typeName);
splitStrings(strs, 30, 40);
for(auto const &str : strs)
{
recty += mCharHeight + (mPad * 2);
positions.push_back(GraphPoint(startpos.x+mPad, startpos.y + recty - mPad));
int curx = static_cast<int>(drawer.getTextExtentWidth(str)) + mPad*2;
if(curx > rectx)
rectx = curx;
}
if(draw)
{
drawer.groupShapes(true, Color(0,0,0), Color(245,245,255));
drawer.drawRect(GraphRect(startpos.x, startpos.y, rectx, recty));
drawer.groupShapes(false, Color(0,0,0), Color(245,245,255));
for(size_t i=0; i<strs.size(); i++)
{
drawer.drawText(positions[i], strs[i]);
}
drawer.groupText(false, false);
}
}
return GraphSize(rectx, recty);
}
OovStringVec Tokenizer::getDiagResults()
{
OovStringVec diagResults;
if(mTransUnit)
{
int numDiags = clang_getNumDiagnostics(mTransUnit);
for (int i = 0; i<numDiags && diagResults.size() < 10; i++)
{
CXDiagnostic diag = clang_getDiagnostic(mTransUnit, i);
// CXDiagnosticSeverity sev = clang_getDiagnosticSeverity(diag);
// if(sev >= CXDiagnostic_Error)
OovString diagStr = getDisposedString(clang_formatDiagnostic(diag,
clang_defaultDiagnosticDisplayOptions()));
if(diagStr.find(mSourceFilename) != std::string::npos)
{
diagResults.push_back(diagStr);
}
}
}
return diagResults;
}
void BuildVariablesDialog::editVariable()
{
OovStringVec vars = mVarListTreeView.getSelected();
if(vars.size() > 0)
{
OovString var = vars[0];
if(sBuildVarSettingsDialog->editVariable(var))
{
mVarListTreeView.removeSelected();
GuiTreeItem parent;
mVarListTreeView.appendText(parent, var);
BuildVariable origBuildVar;
origBuildVar.initVarFromString(vars[0]);
mProject.removeName(origBuildVar.getVarFilterName());
BuildVariable newBuildVar;
newBuildVar.initVarFromString(var);
mProject.setNameValue(newBuildVar.getVarFilterName(), newBuildVar.getVarValue());
}
}
}
int main(int argc, char * argv[])
{
int ret = 1;
bool verbose = false;
bool writeToProject = false;
const char *projDir = nullptr;
const char *projName = "PROJNAME";
for(int argi=1; argi<argc; argi++)
{
if(argv[argi][0] == '-')
{
switch(argv[argi][1])
{
case 'v':
verbose = true;
break;
case 'w':
writeToProject = true;
break;
case 'n':
projName = &argv[argi][2];
break;
}
}
else
projDir = argv[argi];
}
if(projDir)
{
Project::setProjectDirectory(projDir);
CMaker maker(projName, verbose);
FilePath outDir;
if(writeToProject)
{
outDir.setPath(Project::getSrcRootDirectory(), FP_Dir);
}
else
{
outDir.setPath(Project::getBuildOutputDir("CMake"), FP_Dir);
FileEnsurePathExists(outDir);
if(maker.mVerbose)
printf("Output directory %s\n", outDir.getStr());
}
if(maker.mCompTypes.read())
{
maker.makeToolchainFiles(outDir);
maker.makeTopLevelFiles(outDir);
maker.mBuildPkgs.read();
FilePath topMlFp(outDir, FP_File);
topMlFp.appendFile("CMakeLists.txt");
maker.makeTopMakelistsFile(topMlFp);
OovStringVec compNames = maker.mCompTypes.getComponentNames(true);
if(compNames.size() > 0)
{
maker.makeComponentFiles(writeToProject, outDir, compNames);
ret = 0;
}
else
fprintf(stderr, "Components must be defined\n");
}
else
fprintf(stderr, "Unable to read project files\n");
}
else
{
fprintf(stderr, "OovCMaker version %s\n", OOV_VERSION);
fprintf(stderr, " OovCMaker projectDirectory [switches]\n");
fprintf(stderr, " switches -v=verbose, -w=write to project, -nProjName\n");
}
return ret;
}
void CMaker::makeComponentFile(OovStringRef const compName,
ComponentTypesFile::eCompTypes compType,
OovStringVec const &sources, OovStringRef const destName)
{
OovString str;
if(mVerbose)
printf("Processing %s\n %s\n", compName.getStr(), destName.getStr());
if(compType == ComponentTypesFile::CT_Program)
{
if(mVerbose)
printf(" Executable\n");
addCommandAndNames(CT_Exec, compName, sources, str);
addLibsAndIncs(compName, str);
str += "install(TARGETS ";
str += compName;
str += "\n EXPORT ";
str += mProjectName;
str += "Targets";
str += "\n RUNTIME DESTINATION \"${INSTALL_BIN_DIR}\" COMPONENT lib)\n";
}
else if(compType == ComponentTypesFile::CT_SharedLib)
{
if(mVerbose)
printf(" SharedLib\n");
addCommandAndNames(CT_Shared, compName, sources, str);
addLibsAndIncs(compName, str);
str += "install(TARGETS ";
str += compName;
str += "\n LIBRARY DESTINATION \"${INSTALL_LIB_DIR}\" COMPONENT lib)\n";
}
else if(compType == ComponentTypesFile::CT_StaticLib)
{
if(mVerbose)
printf(" Library\n");
OovStringVec headers = mCompTypes.getComponentIncludes(compName);
discardDirs(headers);
OovStringVec allFiles = headers;
allFiles.insert(allFiles.end(), sources.begin(), sources.end() );
std::sort(allFiles.begin(), allFiles.end(), compareNoCase);
if(sources.size() == 0)
{
addCommandAndNames(CT_Interface, compName, allFiles, str);
str += "set_target_properties(";
str += compName;
str += " PROPERTIES LINKER_LANGUAGE CXX)\n";
}
else
addCommandAndNames(CT_Static, compName, allFiles, str);
addCommandAndNames(CT_TargHeaders, compName, headers, str);
str += "install(TARGETS ";
str += compName;
str += "\n EXPORT ";
str += mProjectName;
str += "Targets";
str += "\n ARCHIVE DESTINATION \"${INSTALL_LIB_DIR}\" COMPONENT lib";
str += "\n PUBLIC_HEADER DESTINATION \"${INSTALL_INCLUDE_DIR}/";
str += mProjectName;
str += "\" COMPONENT dev)\n";
}
writeFile(destName, str);
}
