CMake/Source/cmDependsJavaParserHelper.cxx

353 lines
8.9 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2005-01-29 01:13:58 +03:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2005-01-29 01:13:58 +03:00
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
2005-01-29 01:13:58 +03:00
#include "cmDependsJavaParserHelper.h"
#include "cmDependsJavaLexer.h"
#include "cmSystemTools.h"
#include <cmsys/FStream.hxx>
2005-01-29 01:13:58 +03:00
int cmDependsJava_yyparse(yyscan_t yyscanner);
2005-01-29 01:13:58 +03:00
cmDependsJavaParserHelper::cmDependsJavaParserHelper()
{
this->CurrentDepth = 0;
this->UnionsAvailable = 0;
this->LastClassId = 0;
CurrentClass tl;
tl.Name = "*";
this->ClassStack.push_back(tl);
}
cmDependsJavaParserHelper::~cmDependsJavaParserHelper()
{
this->CleanupParser();
}
void cmDependsJavaParserHelper::CurrentClass::AddFileNamesForPrinting(
std::vector<std::string>* files, const char* prefix, const char* sep) const
2005-01-29 01:13:58 +03:00
{
std::string rname = "";
if (prefix) {
2005-01-29 01:13:58 +03:00
rname += prefix;
rname += sep;
}
2005-01-29 01:13:58 +03:00
rname += this->Name;
files->push_back(rname);
std::vector<CurrentClass>::const_iterator it;
for (it = this->NestedClasses.begin(); it != this->NestedClasses.end();
++it) {
2005-01-29 01:13:58 +03:00
it->AddFileNamesForPrinting(files, rname.c_str(), sep);
}
2005-01-29 01:13:58 +03:00
}
void cmDependsJavaParserHelper::DeallocateParserType(char** pt)
{
if (!pt) {
2005-01-29 01:13:58 +03:00
return;
}
if (!*pt) {
2005-01-29 01:13:58 +03:00
return;
}
2016-06-27 23:44:16 +03:00
*pt = CM_NULLPTR;
this->UnionsAvailable--;
2005-01-29 01:13:58 +03:00
}
void cmDependsJavaParserHelper::AddClassFound(const char* sclass)
{
if (!sclass) {
2005-01-29 01:13:58 +03:00
return;
}
std::vector<std::string>::iterator it;
for (it = this->ClassesFound.begin(); it != this->ClassesFound.end(); it++) {
if (*it == sclass) {
2005-01-29 01:13:58 +03:00
return;
}
}
2005-01-29 01:13:58 +03:00
this->ClassesFound.push_back(sclass);
}
void cmDependsJavaParserHelper::AddPackagesImport(const char* sclass)
{
std::vector<std::string>::iterator it;
for (it = this->PackagesImport.begin(); it != this->PackagesImport.end();
it++) {
if (*it == sclass) {
2005-01-29 01:13:58 +03:00
return;
}
}
2005-01-29 01:13:58 +03:00
this->PackagesImport.push_back(sclass);
}
void cmDependsJavaParserHelper::SafePrintMissing(const char* str, int line,
int cnt)
2005-01-29 01:13:58 +03:00
{
if (str) {
2005-01-29 01:13:58 +03:00
std::cout << line << " String " << cnt << " exists: ";
unsigned int cc;
for (cc = 0; cc < strlen(str); cc++) {
2005-01-29 01:13:58 +03:00
unsigned char ch = str[cc];
if (ch >= 32 && ch <= 126) {
2005-01-29 01:13:58 +03:00
std::cout << (char)ch;
} else {
2005-01-29 01:13:58 +03:00
std::cout << "<" << (int)ch << ">";
break;
}
}
std::cout << "- " << strlen(str) << std::endl;
}
2005-01-29 01:13:58 +03:00
}
void cmDependsJavaParserHelper::Print(const char* place, const char* str)
{
if (this->Verbose) {
2005-01-29 01:13:58 +03:00
std::cout << "[" << place << "=" << str << "]" << std::endl;
}
2005-01-29 01:13:58 +03:00
}
void cmDependsJavaParserHelper::CombineUnions(char** out, const char* in1,
char** in2, const char* sep)
2005-01-29 01:13:58 +03:00
{
size_t len = 1;
if (in1) {
2005-01-29 01:13:58 +03:00
len += strlen(in1);
}
if (*in2) {
2005-01-29 01:13:58 +03:00
len += strlen(*in2);
}
if (sep) {
2005-01-29 01:13:58 +03:00
len += strlen(sep);
}
*out = new char[len];
2005-01-29 01:13:58 +03:00
*out[0] = 0;
if (in1) {
2005-01-29 01:13:58 +03:00
strcat(*out, in1);
}
if (sep) {
2005-01-29 01:13:58 +03:00
strcat(*out, sep);
}
if (*in2) {
2005-01-29 01:13:58 +03:00
strcat(*out, *in2);
}
if (*in2) {
2005-01-29 01:13:58 +03:00
this->DeallocateParserType(in2);
}
this->UnionsAvailable++;
2005-01-29 01:13:58 +03:00
}
void cmDependsJavaParserHelper::CheckEmpty(
int line, int cnt, cmDependsJavaParserHelper::ParserType* pt)
2005-01-29 01:13:58 +03:00
{
int cc;
int kk = -cnt + 1;
for (cc = 1; cc <= cnt; cc++) {
2005-01-29 01:13:58 +03:00
cmDependsJavaParserHelper::ParserType* cpt = pt + kk;
this->SafePrintMissing(cpt->str, line, cc);
kk++;
}
2005-01-29 01:13:58 +03:00
}
void cmDependsJavaParserHelper::PrepareElement(
cmDependsJavaParserHelper::ParserType* me)
2005-01-29 01:13:58 +03:00
{
// Inititalize self
2016-06-27 23:44:16 +03:00
me->str = CM_NULLPTR;
2005-01-29 01:13:58 +03:00
}
void cmDependsJavaParserHelper::AllocateParserType(
cmDependsJavaParserHelper::ParserType* pt, const char* str, int len)
2005-01-29 01:13:58 +03:00
{
2016-06-27 23:44:16 +03:00
pt->str = CM_NULLPTR;
if (len == 0) {
len = (int)strlen(str);
}
if (len == 0) {
2005-01-29 01:13:58 +03:00
return;
}
this->UnionsAvailable++;
pt->str = new char[len + 1];
2005-01-29 01:13:58 +03:00
strncpy(pt->str, str, len);
pt->str[len] = 0;
this->Allocates.push_back(pt->str);
}
void cmDependsJavaParserHelper::StartClass(const char* cls)
{
CurrentClass cl;
cl.Name = cls;
this->ClassStack.push_back(cl);
this->CurrentDepth++;
2005-01-29 01:13:58 +03:00
}
void cmDependsJavaParserHelper::EndClass()
{
if (this->ClassStack.empty()) {
2005-01-29 01:13:58 +03:00
std::cerr << "Error when parsing. Current class is null" << std::endl;
abort();
}
if (this->ClassStack.size() <= 1) {
2005-01-29 01:13:58 +03:00
std::cerr << "Error when parsing. Parent class is null" << std::endl;
abort();
}
CurrentClass& current = this->ClassStack.back();
CurrentClass& parent = this->ClassStack[this->ClassStack.size() - 2];
this->CurrentDepth--;
parent.NestedClasses.push_back(current);
this->ClassStack.pop_back();
2005-01-29 01:13:58 +03:00
}
void cmDependsJavaParserHelper::PrintClasses()
{
if (this->ClassStack.empty()) {
2005-01-29 01:13:58 +03:00
std::cerr << "Error when parsing. No classes on class stack" << std::endl;
abort();
}
std::vector<std::string> files = this->GetFilesProduced();
std::vector<std::string>::iterator sit;
for (sit = files.begin(); sit != files.end(); ++sit) {
std::cout << " " << *sit << ".class" << std::endl;
}
2005-01-29 01:13:58 +03:00
}
std::vector<std::string> cmDependsJavaParserHelper::GetFilesProduced()
2005-01-29 01:13:58 +03:00
{
std::vector<std::string> files;
CurrentClass const& toplevel = this->ClassStack.front();
std::vector<CurrentClass>::const_iterator it;
for (it = toplevel.NestedClasses.begin(); it != toplevel.NestedClasses.end();
++it) {
2016-06-27 23:44:16 +03:00
it->AddFileNamesForPrinting(&files, CM_NULLPTR, "$");
}
2005-01-29 01:13:58 +03:00
return files;
}
int cmDependsJavaParserHelper::ParseString(const char* str, int verb)
{
if (!str) {
2005-01-29 01:13:58 +03:00
return 0;
}
2005-01-29 01:13:58 +03:00
this->Verbose = verb;
this->InputBuffer = str;
this->InputBufferPos = 0;
this->CurrentLine = 0;
2005-01-29 01:13:58 +03:00
yyscan_t yyscanner;
cmDependsJava_yylex_init(&yyscanner);
cmDependsJava_yyset_extra(this, yyscanner);
int res = cmDependsJava_yyparse(yyscanner);
cmDependsJava_yylex_destroy(yyscanner);
if (res != 0) {
2005-01-29 01:13:58 +03:00
std::cout << "JP_Parse returned: " << res << std::endl;
return 0;
}
2005-01-29 01:13:58 +03:00
if (verb) {
if (!this->CurrentPackage.empty()) {
std::cout << "Current package is: " << this->CurrentPackage << std::endl;
}
2005-01-29 01:13:58 +03:00
std::cout << "Imports packages:";
if (!this->PackagesImport.empty()) {
std::vector<std::string>::iterator it;
for (it = this->PackagesImport.begin(); it != this->PackagesImport.end();
++it) {
std::cout << " " << *it;
2005-01-29 01:13:58 +03:00
}
}
2005-01-29 01:13:58 +03:00
std::cout << std::endl;
std::cout << "Depends on:";
if (!this->ClassesFound.empty()) {
std::vector<std::string>::iterator it;
for (it = this->ClassesFound.begin(); it != this->ClassesFound.end();
++it) {
std::cout << " " << *it;
2005-01-29 01:13:58 +03:00
}
}
2005-01-29 01:13:58 +03:00
std::cout << std::endl;
std::cout << "Generated files:" << std::endl;
this->PrintClasses();
if (this->UnionsAvailable != 0) {
std::cout << "There are still " << this->UnionsAvailable
<< " unions available" << std::endl;
2005-01-29 01:13:58 +03:00
}
}
2005-01-29 01:13:58 +03:00
this->CleanupParser();
return 1;
}
void cmDependsJavaParserHelper::CleanupParser()
{
std::vector<char*>::iterator it;
for (it = this->Allocates.begin(); it != this->Allocates.end(); ++it) {
delete[] * it;
}
this->Allocates.erase(this->Allocates.begin(), this->Allocates.end());
2005-01-29 01:13:58 +03:00
}
int cmDependsJavaParserHelper::LexInput(char* buf, int maxlen)
{
if (maxlen < 1) {
2005-01-29 01:13:58 +03:00
return 0;
}
if (this->InputBufferPos < this->InputBuffer.size()) {
buf[0] = this->InputBuffer[this->InputBufferPos++];
if (buf[0] == '\n') {
this->CurrentLine++;
}
return 1;
}
buf[0] = '\n';
return 0;
2005-01-29 01:13:58 +03:00
}
void cmDependsJavaParserHelper::Error(const char* str)
{
unsigned long pos = static_cast<unsigned long>(this->InputBufferPos);
fprintf(stderr, "JPError: %s (%lu / Line: %d)\n", str, pos,
this->CurrentLine);
2005-01-29 01:13:58 +03:00
int cc;
std::cerr << "String: [";
for (cc = 0;
cc < 30 && *(this->InputBuffer.c_str() + this->InputBufferPos + cc);
cc++) {
2005-01-29 01:13:58 +03:00
std::cerr << *(this->InputBuffer.c_str() + this->InputBufferPos + cc);
}
2005-01-29 01:13:58 +03:00
std::cerr << "]" << std::endl;
}
void cmDependsJavaParserHelper::UpdateCombine(const char* str1,
2006-05-10 23:01:22 +04:00
const char* str2)
2005-01-29 01:13:58 +03:00
{
2016-06-27 23:44:16 +03:00
if (this->CurrentCombine == "" && str1 != CM_NULLPTR) {
2005-01-29 01:13:58 +03:00
this->CurrentCombine = str1;
}
2005-01-29 01:13:58 +03:00
this->CurrentCombine += ".";
this->CurrentCombine += str2;
}
int cmDependsJavaParserHelper::ParseFile(const char* file)
{
if (!cmSystemTools::FileExists(file)) {
2005-01-29 01:13:58 +03:00
return 0;
}
cmsys::ifstream ifs(file);
if (!ifs) {
2005-01-29 01:13:58 +03:00
return 0;
}
2005-01-29 01:13:58 +03:00
std::string fullfile = "";
std::string line;
while (cmSystemTools::GetLineFromStream(ifs, line)) {
2005-01-29 01:13:58 +03:00
fullfile += line + "\n";
}
2005-01-29 01:13:58 +03:00
return this->ParseString(fullfile.c_str(), 0);
}