summaryrefslogtreecommitdiff
path: root/Source/cmDependsJavaParserHelper.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'Source/cmDependsJavaParserHelper.cxx')
-rw-r--r--Source/cmDependsJavaParserHelper.cxx429
1 files changed, 429 insertions, 0 deletions
diff --git a/Source/cmDependsJavaParserHelper.cxx b/Source/cmDependsJavaParserHelper.cxx
new file mode 100644
index 0000000..7b595cc
--- /dev/null
+++ b/Source/cmDependsJavaParserHelper.cxx
@@ -0,0 +1,429 @@
+/*============================================================================
+ CMake - Cross Platform Makefile Generator
+ Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+ Distributed under the OSI-approved BSD License (the "License");
+ see accompanying file Copyright.txt for details.
+
+ 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.
+============================================================================*/
+#include "cmDependsJavaParserHelper.h"
+
+#include "cmSystemTools.h"
+#include "cmDependsJavaLexer.h"
+
+int cmDependsJava_yyparse( yyscan_t yyscanner );
+
+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<cmStdString> *files,
+ const char* prefix, const char* sep)
+{
+ cmStdString rname = "";
+ if ( prefix )
+ {
+ rname += prefix;
+ rname += sep;
+ }
+ rname += this->Name;
+ files->push_back(rname);
+ std::vector<CurrentClass>::iterator it;
+ for ( it = this->NestedClasses->begin();
+ it != this->NestedClasses->end();
+ ++ it )
+ {
+ it->AddFileNamesForPrinting(files, rname.c_str(), sep);
+ }
+}
+
+void cmDependsJavaParserHelper::DeallocateParserType(char** pt)
+{
+ if (!pt)
+ {
+ return;
+ }
+ if (!*pt)
+ {
+ return;
+ }
+ *pt = 0;
+ this->UnionsAvailable --;
+}
+
+void cmDependsJavaParserHelper::AddClassFound(const char* sclass)
+{
+ if( ! sclass )
+ {
+ return;
+ }
+ std::vector<cmStdString>::iterator it;
+ for ( it = this->ClassesFound.begin();
+ it != this->ClassesFound.end();
+ it ++ )
+ {
+ if ( *it == sclass )
+ {
+ return;
+ }
+ }
+ this->ClassesFound.push_back(sclass);
+}
+
+void cmDependsJavaParserHelper::AddPackagesImport(const char* sclass)
+{
+ std::vector<cmStdString>::iterator it;
+ for ( it = this->PackagesImport.begin();
+ it != this->PackagesImport.end();
+ it ++ )
+ {
+ if ( *it == sclass )
+ {
+ return;
+ }
+ }
+ this->PackagesImport.push_back(sclass);
+}
+
+void cmDependsJavaParserHelper::SafePrintMissing(const char* str,
+ int line, int cnt)
+{
+ if ( str )
+ {
+ std::cout << line << " String " << cnt << " exists: ";
+ unsigned int cc;
+ for ( cc = 0; cc < strlen(str); cc ++ )
+ {
+ unsigned char ch = str[cc];
+ if ( ch >= 32 && ch <= 126 )
+ {
+ std::cout << (char)ch;
+ }
+ else
+ {
+ std::cout << "<" << (int)ch << ">";
+ break;
+ }
+ }
+ std::cout << "- " << strlen(str) << std::endl;
+ }
+}
+void cmDependsJavaParserHelper::Print(const char* place, const char* str)
+{
+ if ( this->Verbose )
+ {
+ std::cout << "[" << place << "=" << str << "]" << std::endl;
+ }
+}
+
+void cmDependsJavaParserHelper::CombineUnions(char** out,
+ const char* in1, char** in2,
+ const char* sep)
+{
+ size_t len = 1;
+ if ( in1 )
+ {
+ len += strlen(in1);
+ }
+ if ( *in2 )
+ {
+ len += strlen(*in2);
+ }
+ if ( sep )
+ {
+ len += strlen(sep);
+ }
+ *out = new char [ len ];
+ *out[0] = 0;
+ if ( in1 )
+ {
+ strcat(*out, in1);
+ }
+ if ( sep )
+ {
+ strcat(*out, sep);
+ }
+ if ( *in2 )
+ {
+ strcat(*out, *in2);
+ }
+ if ( *in2 )
+ {
+ this->DeallocateParserType(in2);
+ }
+ this->UnionsAvailable ++;
+}
+
+void cmDependsJavaParserHelper
+::CheckEmpty(int line, int cnt, cmDependsJavaParserHelper::ParserType* pt)
+{
+ int cc;
+ int kk = -cnt + 1;
+ for ( cc = 1; cc <= cnt; cc ++)
+ {
+ cmDependsJavaParserHelper::ParserType* cpt = pt + kk;
+ this->SafePrintMissing(cpt->str, line, cc);
+ kk ++;
+ }
+}
+
+void cmDependsJavaParserHelper
+::PrepareElement(cmDependsJavaParserHelper::ParserType* me)
+{
+ // Inititalize self
+ me->str = 0;
+}
+
+void cmDependsJavaParserHelper
+::AllocateParserType(cmDependsJavaParserHelper::ParserType* pt,
+ const char* str, int len)
+{
+ pt->str = 0;
+ if ( len == 0 )
+ {
+ len = (int)strlen(str);
+ }
+ if ( len == 0 )
+ {
+ return;
+ }
+ this->UnionsAvailable ++;
+ pt->str = new char[ len + 1 ];
+ 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 ++;
+}
+
+void cmDependsJavaParserHelper::EndClass()
+{
+ CurrentClass* parent = 0;
+ CurrentClass* current = 0;
+ if ( this->ClassStack.size() > 0 )
+ {
+ current = &(*(this->ClassStack.end() - 1));
+ if ( this->ClassStack.size() > 1 )
+ {
+ parent = &(*(this->ClassStack.end() - 2));
+ }
+ }
+ if ( current == 0 )
+ {
+ std::cerr << "Error when parsing. Current class is null" << std::endl;
+ abort();
+ }
+ if ( parent == 0 )
+ {
+ std::cerr << "Error when parsing. Parent class is null" << std::endl;
+ abort();
+ }
+ this->CurrentDepth --;
+ parent->NestedClasses->push_back(*current);
+ this->ClassStack.erase(this->ClassStack.end()-1, this->ClassStack.end());
+}
+
+void cmDependsJavaParserHelper::PrintClasses()
+{
+ if ( this->ClassStack.size() == 0 )
+ {
+ std::cerr << "Error when parsing. No classes on class stack" << std::endl;
+ abort();
+ }
+ std::vector<cmStdString> files = this->GetFilesProduced();
+ std::vector<cmStdString>::iterator sit;
+ for ( sit = files.begin();
+ sit != files.end();
+ ++ sit )
+ {
+ std::cout << " " << sit->c_str() << ".class" << std::endl;
+ }
+}
+
+std::vector<cmStdString> cmDependsJavaParserHelper::GetFilesProduced()
+{
+ std::vector<cmStdString> files;
+ CurrentClass* toplevel = &(*(this->ClassStack.begin()));
+ std::vector<CurrentClass>::iterator it;
+ for ( it = toplevel->NestedClasses->begin();
+ it != toplevel->NestedClasses->end();
+ ++ it )
+ {
+ it->AddFileNamesForPrinting(&files, 0, "$");
+ }
+ return files;
+}
+
+int cmDependsJavaParserHelper::ParseString(const char* str, int verb)
+{
+ if ( !str)
+ {
+ return 0;
+ }
+ this->Verbose = verb;
+ this->InputBuffer = str;
+ this->InputBufferPos = 0;
+ this->CurrentLine = 0;
+
+
+ yyscan_t yyscanner;
+ cmDependsJava_yylex_init(&yyscanner);
+ cmDependsJava_yyset_extra(this, yyscanner);
+ int res = cmDependsJava_yyparse(yyscanner);
+ cmDependsJava_yylex_destroy(yyscanner);
+ if ( res != 0 )
+ {
+ std::cout << "JP_Parse returned: " << res << std::endl;
+ return 0;
+ }
+
+ if ( verb )
+ {
+ if ( this->CurrentPackage.size() > 0 )
+ {
+ std::cout << "Current package is: " <<
+ this->CurrentPackage.c_str() << std::endl;
+ }
+ std::cout << "Imports packages:";
+ if ( this->PackagesImport.size() > 0 )
+ {
+ std::vector<cmStdString>::iterator it;
+ for ( it = this->PackagesImport.begin();
+ it != this->PackagesImport.end();
+ ++ it )
+ {
+ std::cout << " " << it->c_str();
+ }
+ }
+ std::cout << std::endl;
+ std::cout << "Depends on:";
+ if ( this->ClassesFound.size() > 0 )
+ {
+ std::vector<cmStdString>::iterator it;
+ for ( it = this->ClassesFound.begin();
+ it != this->ClassesFound.end();
+ ++ it )
+ {
+ std::cout << " " << it->c_str();
+ }
+ }
+ 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;
+ }
+ }
+ 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());
+}
+
+int cmDependsJavaParserHelper::LexInput(char* buf, int maxlen)
+{
+ if ( maxlen < 1 )
+ {
+ return 0;
+ }
+ if ( this->InputBufferPos < this->InputBuffer.size() )
+ {
+ buf[0] = this->InputBuffer[ this->InputBufferPos++ ];
+ if ( buf[0] == '\n' )
+ {
+ this->CurrentLine ++;
+ }
+ return(1);
+ }
+ else
+ {
+ buf[0] = '\n';
+ return( 0 );
+ }
+}
+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);
+ int cc;
+ std::cerr << "String: [";
+ for ( cc = 0;
+ cc < 30 && *(this->InputBuffer.c_str() + this->InputBufferPos + cc);
+ cc ++ )
+ {
+ std::cerr << *(this->InputBuffer.c_str() + this->InputBufferPos + cc);
+ }
+ std::cerr << "]" << std::endl;
+}
+
+void cmDependsJavaParserHelper::UpdateCombine(const char* str1,
+ const char* str2)
+{
+ if ( this->CurrentCombine == "" && str1 != 0)
+ {
+ this->CurrentCombine = str1;
+ }
+ this->CurrentCombine += ".";
+ this->CurrentCombine += str2;
+}
+
+int cmDependsJavaParserHelper::ParseFile(const char* file)
+{
+ if ( !cmSystemTools::FileExists(file))
+ {
+ return 0;
+ }
+ std::ifstream ifs(file);
+ if ( !ifs )
+ {
+ return 0;
+ }
+
+ cmStdString fullfile = "";
+ cmStdString line;
+ while ( cmSystemTools::GetLineFromStream(ifs, line) )
+ {
+ fullfile += line + "\n";
+ }
+ return this->ParseString(fullfile.c_str(), 0);
+}
+