void makeInlineDoc(int endCode)
{
int len=endCode-iCodeLen;
QCString par=inputString.mid(iCodeLen,len);
//fprintf(stderr,"\n inline code: \n<%s>",par.data());
gBlock.doc=par;
gBlock.inbodyDocs=par;
gBlock.section=Entry::VARIABLE_SEC;
gBlock.spec=VhdlDocGen::MISCELLANEOUS;
gBlock.fileName = yyFileName;
gBlock.endBodyLine=yyLineNr-1;
gBlock.lang=SrcLangExt_VHDL;
Entry *temp=new Entry(gBlock);
Entry* compound=getVhdlCompound();
if (compound)
{
compound->addSubEntry(temp);
}
else
{
temp->type="misc"; // global code like library ieee...
VhdlParser::current_root->addSubEntry(temp);
}
strComment.resize(0);
gBlock.reset();
}// makeInlineDoc
int KNFile::findString(const char *s)
{
QCString searchBuffer;
searchBuffer.resize(2048);
char *buffPtr = searchBuffer.data(), *pos;
int readBytes, currentFilePos;
while(!atEnd())
{
currentFilePos = at();
readBytes = readBlock(buffPtr, 2047);
if(readBytes == -1)
return -1;
else
buffPtr[readBytes] = 0; // terminate string
pos = strstr(buffPtr, s);
if(pos == 0)
{
if(!atEnd())
at(at() - strlen(s));
else
return -1;
}
else
{
return currentFilePos + (pos - buffPtr);
}
}
return -1;
}
void VhdlParser::oneLineComment(QCString qcs)
{
bool isEndCode=qcs.contains("\\endcode");
int index = qcs.find("\\code");
if (isEndCode)
{
int end = inputString.find(qcs.data(),iCodeLen);
makeInlineDoc(end);
}
else if (index > 0)
{
// assert(false);
strComment=qcs;
startCodeBlock(index);
strComment.resize(0);
}
if (!isEndCode && index==-1)
{
int j=qcs.find("--!");
qcs=qcs.right(qcs.length()-3-j);
if (!checkMultiComment(qcs,iDocLine))
{
handleCommentBlock(qcs,TRUE);
}
}
}
void Nntp::readyRead()
{
// new data arrived on the command socket
// of we should read the list of available groups, let's do so
if ( readGroups ) {
parseGroups();
return;
}
// of we should read an article, let's do so
if ( readArticle ) {
parseArticle();
return;
}
// read the new data from the socket
QCString s;
s.resize( commandSocket->bytesAvailable() + 1 );
commandSocket->readBlock( s.data(), commandSocket->bytesAvailable() );
if ( !url() )
return;
// of the code of the server response was 200, we know that the
// server is ready to get commands from us now
if ( s.left( 3 ) == "200" )
connectionReady = TRUE;
}
/**
* Execute a KDM/GDM remote control command.
* @param cmd the command to execute. FIXME: undocumented yet.
* @param buf the result buffer.
* @return result:
* @li If true, the command was successfully executed.
* @p ret might contain addional results.
* @li If false and @p ret is empty, a communication error occurred
* (most probably KDM is not running).
* @li If false and @p ret is non-empty, it contains the error message
* from KDM.
*/
bool DM::exec(const char *cmd, QCString &buf)
{
bool ret = false;
int tl;
unsigned len = 0;
if(fd < 0)
goto busted;
tl = strlen(cmd);
if(::write(fd, cmd, tl) != tl)
{
bust:
::close(fd);
fd = -1;
busted:
buf.resize(0);
return false;
}
if(DMType == OldKDM)
{
buf.resize(0);
return true;
}
for(;;)
{
if(buf.size() < 128)
buf.resize(128);
else if(buf.size() < len * 2)
buf.resize(len * 2);
if((tl = ::read(fd, buf.data() + len, buf.size() - len)) <= 0)
{
if(tl < 0 && errno == EINTR)
continue;
goto bust;
}
len += tl;
if(buf[len - 1] == '\n')
{
buf[len - 1] = 0;
if(len > 2 && (buf[0] == 'o' || buf[0] == 'O') && (buf[1] == 'k' || buf[1] == 'K') && buf[2] <= 32)
ret = true;
break;
}
}
return ret;
}
QCString OutputGenerator::getContents() const
{
QCString s;
s.resize(a.size()+1);
memcpy(s.data(),a.data(),a.size());
s.at(a.size())='\0';
return s;
}
void VHDLLanguageScanner::parseInput(const char *fileName,const char *fileBuf,Entry *root,
bool ,QStrList&)
{
g_thisParser=this;
bool inLine=false;
inputString=fileBuf;
// fprintf(stderr,"\n ============= %s\n ==========\n",fileBuf);
if (strlen(fileName)==0)
{
inLine=true;
}
yyFileName+=fileName;
bool xilinx_ucf=isConstraintFile(yyFileName,".ucf");
bool altera_qsf=isConstraintFile(yyFileName,".qsf");
// support XILINX(ucf) and ALTERA (qsf) file
if (xilinx_ucf)
{
VhdlDocGen::parseUCF(fileBuf,root,yyFileName,FALSE);
return;
}
if (altera_qsf)
{
VhdlDocGen::parseUCF(fileBuf,root,yyFileName,TRUE);
return;
}
libUse.setAutoDelete(true);
yyLineNr=1;
VhdlParser::current_root=root;
VhdlParser::lastCompound=0;
VhdlParser::lastEntity=0;
VhdlParser::currentCompound=0;
VhdlParser::lastEntity=0;
VhdlParser::current=new Entry();
VhdlParser::initEntry(VhdlParser::current);
groupEnterFile(fileName,yyLineNr);
lineParse=new int[200]; // Dimitri: dangerous constant: should be bigger than largest token id in VhdlParserConstants.h
VhdlParserIF::parseVhdlfile(fileBuf,inLine);
delete VhdlParser::current;
VhdlParser::current=0;
if (!inLine)
VhdlParser::mapLibPackage(root);
delete[] lineParse;
yyFileName.resize(0);
libUse.clear();
VhdlDocGen::resetCodeVhdlParserState();
}
void Editor::load( const QString &fn )
{
filename = fn;
QFile f( filename );
if ( !f.open( IO_ReadOnly ) )
return;
QCString txt;
txt.resize( f.size() );
f.readBlock( txt.data(), f.size() );
QString s( QString::fromLatin1( txt ) );
setText( s );
}
void hl_rcon::incomingData(int)
{
QCString temp;
QString mooh;
temp.resize( qsd->bytesAvailable() );
qsd->readBlock( temp.data(), qsd->bytesAvailable());
mooh=temp;
if(mooh.contains("challenge rcon")>=1)
sendRealCmd(mooh.right(11).left(10));
if(mooh.contains("Bad rcon_password")>=1)
emit logMsg("Bad rcon_password");
}
QCString dcopNetworkId()
{
QCString result;
result.resize(1025);
QFile file(DCOPClient::dcopServerFile());
if (!file.open(IO_ReadOnly))
return "";
int i = file.readLine(result.data(), 1024);
if (i <= 0)
return "";
result.data()[i-1] = '\0'; // strip newline
return result;
}
// remove first and last line in comment if non significant
QCString Lex::simplify_comment(QCString & comment)
{
if (comment.isEmpty())
return comment;
const char * s = comment;
const char * p = s;
for (;;) {
switch (*p) {
case 0:
return comment;
case ' ':
case '\t':
p += 1;
break;
case '\n':
comment.remove(0, p - s + 1);
if (comment.isEmpty())
return comment;
s = comment;
// no break
default:
p = s + comment.length() - 1;
while (p != s) {
switch(*p) {
case ' ':
case '\t':
p -= 1;
break;
case '\n':
comment.resize(p - s + 1);
// no break
default:
return comment;
}
}
if (*p == '\n')
comment = "";
return comment;
}
}
}
QCString MIMECodec::decodeQuotedPrintable(const QCString &text)
{
if (text.isEmpty() || !text.length())
return "";
QCString outstr;
outstr.resize(text.length() / 3 + 1);
outstr[0] = 0;
unsigned index = 0;
const char *str = text.data();
char c = 0, c1 = 0, c2 = 0, h = 0;
unsigned uLength = text.length();
while (index < uLength) {
c = str[index];
if (c == '=') {
c1 = index < uLength - 1 ? str[index + 1] : '\n';
c2 = index < uLength - 2 ? str[index + 2] : 'X';
if (c1 == '\r' && c2 == '\n')
index += 3;
else if (c1 == '\n')
index += 2;
else {
c1 = QChar(c1).upper();
c2 = QChar(c2).upper();
h = (((c1 >= 'A' && c1 <= 'F') ?
(c1 - 'A' + 10) :
(c1 - '0')) * 16) + ((c2 >= 'A' && c2 <= 'F') ? (c2 - 'A' + 10) : (c2 - '0'));
outstr += h;
index += 3;
}
} else {
outstr += c;
index++;
}
}
return outstr;
}
void TooltipManager::writeTooltips(CodeOutputInterface &ol)
{
QDictIterator<Definition> di(p->tooltipInfo);
Definition *d;
for (di.toFirst();(d=di.current());++di)
{
DocLinkInfo docInfo;
docInfo.name = d->qualifiedName();
docInfo.ref = d->getReference();
docInfo.url = d->getOutputFileBase();
docInfo.anchor = d->anchor();
SourceLinkInfo defInfo;
if (d->getBodyDef() && d->getStartBodyLine()!=-1)
{
defInfo.file = d->getBodyDef()->name();
defInfo.line = d->getStartBodyLine();
defInfo.url = d->getSourceFileBase();
defInfo.anchor = d->getSourceAnchor();
}
SourceLinkInfo declInfo; // TODO: fill in...
QCString decl;
if (d->definitionType()==Definition::TypeMember)
{
MemberDef *md = (MemberDef*)d;
decl = md->declaration();
if (!decl.isEmpty() && decl.at(0)=='@') // hide enum values
{
decl.resize(0);
}
}
ol.writeTooltip(di.currentKey(), // id
docInfo, // symName
decl, // decl
d->briefDescriptionAsTooltip(), // desc
defInfo,
declInfo
);
}
}
QCString MIMECodec::encodeQuotedPrintable(const QCString &str, bool compat, bool footer)
{
if (str.isEmpty() || !str.length())
return "";
const int wrap = 76;
int i;
QCString prestr = str;
QSettings sett;
bool addFooter = sett.readBoolEntry(AQ_KEYBASE + "/email/addFooter", true);
qWarning(AQ_KEYBASE + "/email/addFooter");
qWarning("addFooter %d", addFooter);
if (footer && addFooter) {
sett.setPath("InfoSiAL", "AbanQ", QSettings::User);
QString filepre(sett.readEntry(AQ_KEYBASE + "/email/footerText",
AQ_DATA + "/text_mail.txt"));
if (filepre.isEmpty()) {
sett.setPath("InfoSiAL", "FacturaLUX", QSettings::User);
filepre = sett.readEntry("/facturalux/lite/email/footerText",
AQ_DATA + "/text_mail.txt");
}
QFile fipre(filepre);
if (fipre.exists() && fipre.open(IO_ReadOnly)) {
QTextStream t(&fipre);
QCString pretxt = t.read().local8Bit();
fipre.close();
if (!pretxt.isEmpty())
prestr += "\n" + pretxt;
} else
for (i = 0; i < 257; i++) prestr += preencode[i];
}
QCString outstr;
unsigned uLength = prestr.length();
const char *ptrStr = prestr.data();
outstr.resize(uLength);
outstr[0] = 0;
unsigned index = 0, lindex = 0;
char c = 0, c1 = 0, c2 = 0, c3 = 0;
while (index < uLength) {
c = ptrStr[index++];
if (((c >= 33 && c <= 60) || (c >= 62 && c <= 126) || c == 9 || c == 32) &&
!(compat && QCString("!\"#@[\\]^`{|}~").find(c) != -1)) {
outstr += c;
lindex++;
} else {
char h1 = (c & 240) / 16, h2 = c & 15;
h1 = h1 < 10 ? h1 + '0' : h1 - 10 + 'A';
h2 = h2 < 10 ? h2 + '0' : h2 - 10 + 'A';
outstr += '=';
outstr += h1;
outstr += h2;
lindex += 3;
}
c1 = index < uLength ? ptrStr[index] : 'a';
c2 = index + 1 < uLength ? ptrStr[index + 1] : 'a';
c3 = index + 2 < uLength ? ptrStr[index + 2] : 'a';
if (lindex == wrap - 1 || ((c1 < 33 || (c1 > 60 && c1 < 62) || c1 > 126 || (compat && QCString("!\"#@[\\]^`{|}~").find(c1) != -1) ||
c2 < 33 || (c2 > 60 && c2 < 62) || c2 > 126 || (compat && QCString("!\"#@[\\]^`{|}~").find(c2) != -1) ||
c3 < 33 || (c3 > 60 && c3 < 62) || c3 > 126 || (compat && QCString("!\"#@[\\]^`{|}~").find(c3) != -1)) && lindex == wrap - 3)) {
outstr += "=\r\n";
lindex = 0;
}
}
return outstr;
}
void UmlOperation::set_cpp(const char * return_form_or_inherit,
const char * params, QCString body,
bool inlinep, const char * if_def,
const char * end_if) {
if (*return_form_or_inherit == ':') {
// inherit
if (inlinep) {
QCString s = remove_throw(CppSettings::operationDecl());
int index = s.find("${)}");
s.resize(index + 5);
s.insert(index, params);
s.append(" ");
s.append(return_form_or_inherit);
if (!body.isEmpty()) {
s.append(" {\n ");
s.append(body);
s.append("}\n");
}
else
s.append(" {\n}\n");
conditional(s, if_def, end_if);
set_CppDecl(s);
set_CppDef("");
}
else {
QCString s = remove_throw(CppSettings::operationDecl());
int index = s.find("${)}");
s.resize(index + 5);
s.insert(index, params);
s.append(";");
conditional(s, if_def, end_if);
set_CppDecl(s);
s = remove_throw(CppSettings::operationDef());
index = s.find("${)}");
s.resize(index + 5);
s.insert(index, params);
s.append(" ");
s.append(return_form_or_inherit);
if (!body.isEmpty()) {
s.append(" {\n ");
s.append(body);
s.append("}\n");
}
else
s.append(" {\n}\n");
conditional(s, if_def, end_if);
set_CppDef(s);
}
}
else {
// return
if (inlinep) {
QCString s = remove_throw(CppSettings::operationDecl());
int index = s.find("${type}");
s.replace(index, 7, return_form_or_inherit);
s.insert(s.find("${)}", index), params);
s.resize(s.findRev(";") + 1);
if (!body.isEmpty()) {
s.append(" {\n ");
s.append(body);
s.append("}\n");
}
else
s.append(" {\n}\n");
conditional(s, if_def, end_if);
set_CppDecl(s);
set_CppDef("");
}
else {
QCString s = remove_throw(CppSettings::operationDecl());
int index = s.find("${type}");
s.replace(index, 7, return_form_or_inherit);
s.insert(s.find("${)}", index), params);
conditional(s, if_def, end_if);
set_CppDecl(s);
s = remove_throw(CppSettings::operationDef());
index = s.find("${type}");
s.replace(index, 7, return_form_or_inherit);
s.insert(s.find("${)}", index), params);
conditional(s, if_def, end_if);
set_CppDef(s);
set_CppBody(body);
}
}
}
void VhdlParser::handleCommentBlock(const char* doc1,bool brief)
{
int position=0;
static bool isIn;
QCString doc(doc1);
if (doc.isEmpty()) return;
if (checkMultiComment(doc,yyLineNr))
{
strComment.resize(0);
return;
}
isIn=checkInlineCode(doc);
bool isEndCode=doc.contains("\\endcode");
// empty comment --!
if (isEndCode)
{
int end=inputString.find(doc.data(),iCodeLen);
makeInlineDoc(end);
strComment.resize(0);
isIn=false;
}
if (isIn)
{
isIn=false;
return;
}
VhdlDocGen::prepareComment(doc);
bool needsEntry=FALSE;
Protection protection=Public;
int lineNr;
if (iDocLine==-1)
lineNr=yyLineNr;
if (oldEntry==current)
{
//printf("\n find pending message < %s > at line: %d \n ",doc.data(),iDocLine);
str_doc.doc=doc;
str_doc.iDocLine=iDocLine;
str_doc.brief=brief;
str_doc.pending=TRUE;
return;
}
oldEntry=current;
if (brief)
{
current->briefLine = yyLineNr;
}
else
{
current->docLine = yyLineNr;
}
// printf("parseCommentBlock file<%s>\n [%s]\n at line [%d] \n ",yyFileName.data(),doc.data(),iDocLine);
while (parseCommentBlock(
g_thisParser,
current,
doc, // text
yyFileName, // file
iDocLine, // line of block start
brief,
0,
FALSE,
protection,
position,
needsEntry
)
)
{
//printf("parseCommentBlock position=%d [%s]\n",position,doc.data()+position);
if (needsEntry) newEntry();
}
if (needsEntry)
{
if (varr)
{
varr=FALSE;
current->name=varName;
current->section=Entry::VARIABLEDOC_SEC;
varName="";
}
newEntry();
}
iDocLine=-1;
strComment.resize(0);
}
void UmlArtifact::gen_app(const QCString & path) {
QCString target;
QCString pro;
propertyValue("genpro target", target);
propertyValue("genpro pro", pro);
if (target.isEmpty()) {
if ((target = name()) == "executable")
target = UmlPackage::getProject()->name();
#ifdef WIN32
target += ".exe";
#endif
}
if (pro.isEmpty()) {
pro = target;
#ifdef WIN32
if (pro.right(4) == ".exe")
pro.resize(pro.length() - 4);
#endif
QDir d(path);
pro = d.absFilePath(pro + ".pro");
}
QCString tmplt;
QCString config;
QCString defines;
QCString includepath;
QCString dependpath;
QCString objectsdir;
QCString footer;
if (!propertyValue("genpro tmplt", tmplt))
tmplt = "app";
if (!propertyValue("genpro config", config))
config = "debug warn_on qt";
if (!propertyValue("genpro defines", defines))
defines = "WITHCPP WITHJAVA WITHPHP WITHPYTHON WITHIDL";
else if (defines.find("WITHPHP") == -1) {
int n = 0;
if (defines.find("WITHCPP") != -1)
n += 1;
if (defines.find("WITHJAVA") != -1)
n += 1;
if (defines.find("WITHIDL") != -1)
n += 1;
if (n > 1)
defines += " WITHPHP WITHPYTHON";
}
else if (defines.find("WITHPYTHON") == -1) {
int n = 0;
if (defines.find("WITHCPP") != -1)
n += 1;
if (defines.find("WITHJAVA") != -1)
n += 1;
if (defines.find("WITHIDL") != -1)
n += 1;
if (defines.find("WITHPHP") != -1)
n += 1;
if (n > 1)
defines += " WITHPYTHON";
}
propertyValue("genpro includepath", includepath);
propertyValue("genpro dependpath", dependpath);
propertyValue("genpro objectsdir", objectsdir);
propertyValue("genpro footer", footer);
for (;;) {
Dialog dialog(this, path, pro, target, tmplt, config, defines,
includepath, dependpath, objectsdir, footer);
if (dialog.exec() != QDialog::Accepted)
return;
set_PropertyValue("genpro pro", pro);
set_PropertyValue("genpro path", path);
set_PropertyValue("genpro target", target);
set_PropertyValue("genpro tmplt", tmplt);
set_PropertyValue("genpro config", config);
set_PropertyValue("genpro defines", defines);
set_PropertyValue("genpro includepath", includepath);
set_PropertyValue("genpro dependpath", dependpath);
set_PropertyValue("genpro objectsdir", objectsdir);
set_PropertyValue("genpro footer", footer);
QFile f(pro);
if (! f.open(IO_WriteOnly))
QMessageBox::critical((QWidget *) 0, "Error", "Cannot open " + QString(pro));
else {
QTextStream t(&f);
QFileInfo tfi(target);
QFileInfo pfi(pro);
t << "TEMPLATE\t= " << tmplt << '\n';
t << "TARGET\t\t= " << tfi.fileName() << '\n';
if ((target.find('/') != -1) &&
(pro.find('/') != -1) &&
(tfi.dirPath(TRUE) != pfi.dirPath(TRUE)))
t << "DESTDIR\t\t= " << tfi.dirPath(TRUE) << '\n';
if (! objectsdir.isEmpty())
t << "OBJECTS_DIR\t= " << objectsdir << '\n';
t << "CONFIG\t\t+= " << config << '\n';
if (!includepath.isEmpty())
t << "INCLUDEPATH\t= " << includepath << '\n';
if (!dependpath.isEmpty())
t << "DEPENDPATH\t= " << dependpath << '\n';
if (!defines.isEmpty())
t << "DEFINES\t\t= " << defines << '\n';
QString prodir = pfi.dirPath(TRUE);
const QVector<UmlArtifact> & arts = associatedArtifacts();
unsigned index;
const char * sep;
QCString ext;
ext = CppSettings::headerExtension();
sep = "HEADERS\t\t= ";
for (index = 0; index != arts.count(); index += 1) {
UmlArtifact * art = arts[index];
if ((art->stereotype() == "source") && !art->cppHeader().isEmpty()) {
QString s = art->way(prodir, TRUE);
if (! s.isEmpty()) {
t << sep << s << art->name() << '.' << ext;
sep = " \\\n\t\t ";
}
}
}
t << '\n';
ext = CppSettings::sourceExtension();
sep = "SOURCES\t\t= ";
for (index = 0; index != arts.count(); index += 1) {
UmlArtifact * art = arts[index];
if ((art->stereotype() != "source") || !art->cppSource().isEmpty()) {
QString s = art->way(prodir, FALSE);
if (! s.isEmpty()) {
t << sep << s << art->name();
if (art->stereotype() == "source")
t << '.' << ext;
sep = " \\\n\t\t ";
}
}
}
t << '\n' << footer << '\n';
f.close();
return;
}
}
}
bool UmlAttribute::manage_enum_item(QCString name, UmlClass * cl
#ifdef ROUNDTRIP
, bool roundtrip,
QList<UmlItem> & expected_order
#endif
)
{
QCString comment = Lex::get_comments();
QCString description = Lex::get_description();
UmlAttribute * item = 0; // initialize to avoid warning
#ifdef ROUNDTRIP
Class * container = 0; // initialize to avoid warning
bool created = FALSE; // initialize to avoid warning
#endif
if (!Package::scanning()) {
#ifdef ROUNDTRIP
container = cl->get_class();
if (!roundtrip ||
((item = search_attr(container, name)) == 0)) {
#endif
if ((item = UmlBaseAttribute::create(cl, name)) == 0) {
JavaCatWindow::trace(QCString("<font face=helvetica><b>cannot add enum item <i>")
+ name + "</i> in <i>" + cl->name()
+ "</i></b></font><br>");
return FALSE;
}
item->set_Visibility(PublicVisibility);
#ifdef ROUNDTRIP
if (roundtrip)
container->set_updated();
created = TRUE;
}
#endif
}
Lex::mark();
QCString aux;
QCString s;
if ((s = Lex::read_word()).isEmpty()) {
if (! Package::scanning())
Lex::premature_eof();
return FALSE;
}
else if ((s == ";") || (s == "}")) {
aux = Lex::region();
Lex::unread_word(s);
}
else if (s == ",") {
aux = Lex::region();
Lex::finish_line();
comment = Lex::get_comments(comment);
description = Lex::get_description(description);
}
else if ((s == "(") || (s == "{")) {
char c = UmlOperation::skip_expr(1); // goes after opt init and body
if (c == 0) {
if (! Package::scanning())
Lex::premature_eof();
return FALSE;
}
// c is ',' or ';'
if (c == ';')
Lex::unread_word(";");
aux = Lex::region();
}
else {
if (! Package::scanning())
Lex::error_near(s);
return FALSE;
}
if (!Package::scanning()) {
// here aux = opt init and body + final character , ; or }
QCString decl = JavaSettings::enumItemDecl();
int index;
if ((decl.find("${name}") == -1) ||
((index = decl.find("${value}")) == -1)) {
decl = " ${name}${value},${comment}";
index = decl.find("${value}");
}
aux.resize(aux.length()); // remove , ; or }, warning resize count \000
if (!aux.stripWhiteSpace().isEmpty())
decl.replace(index, 8, aux);
#ifdef ROUNDTRIP
if (roundtrip && !created) {
if (decl.find("${description}") != -1) {
if (nequal(item->description(), description)) {
item->set_Description(description);
container->set_updated();
}
}
else if (nequal(item->description(), Lex::simplify_comment(comment))) {
item->set_Description(comment); // comment was changed
container->set_updated();
}
if (neq(item->javaDecl(), decl)) {
item->set_JavaDecl(decl);
container->set_updated();
}
item->set_usefull();
expected_order.append(item);
}
else {
#endif
if (!comment.isEmpty())
item->set_Description((decl.find("${description}") != -1)
? description : Lex::simplify_comment(comment));
item->set_JavaDecl(decl);
#ifdef ROUNDTRIP
if (roundtrip)
expected_order.append(item);
}
#endif
}
return TRUE;
}
bool ClassContainer::read_type(UmlTypeSpec & typespec, Class ** cl,
const QValueList<FormalParameterList> & tmplts,
QValueList<UmlTypeSpec> * actuals,
QCString & str_actuals, QCString s,
UmlClass ** first_actual_class, QCString & def,
QCString & genericname) {
str_actuals = 0;
if (actuals != 0)
actuals->clear();
if (s.isEmpty() && (s = Lex::read_word()).isEmpty()) {
Lex::premature_eof();
return FALSE;
}
QCString path; // type without <..>
QCString type; // real type form
bool internal_template = FALSE; // true if type is ...<...>...
int pfixdef_length = 0; // generic form including first class
int first_actual_class_length = 0; // first class's name length
genericname = s;
for (;;) {
internal_template = (path != type);
path += s;
type += s;
s = Lex::read_word();
if (s != "<")
break;
type += s;
str_actuals = s;
// read <...>
do {
Lex::mark();
int level = 0;
QCString firstword; // first element in current actual
int pfixlen = 0; // type length including firstword
for (;;) {
s = Lex::read_word(TRUE);
if (s == ",") {
if (level == 0)
break;
}
else if (s == ">") {
if (level-- == 0)
break;
}
else if (s == "]")
level -= 1;
else if ((s == "<") || (s == "["))
level += 1;
else if (s.isEmpty()) {
Lex::premature_eof();
return FALSE;
}
else if (firstword.isEmpty()) {
firstword = s;
pfixlen = type.length() + Lex::region().length();
}
}
QCString e = Lex::region();
type += e;
str_actuals += e;
if (actuals != 0) {
UmlTypeSpec t;
e.resize(e.length()); // remove , or >
e = e.stripWhiteSpace();
if (! e.isEmpty())
compute_type(e, t, tmplts);
if (actuals != 0)
actuals->append(t);
}
else if ((first_actual_class != 0) &&
(*first_actual_class == 0) &&
!firstword.isEmpty()) {
UmlTypeSpec t;
compute_type(firstword, t, tmplts);
if (t.type != 0) {
*first_actual_class = t.type;
first_actual_class_length = firstword.length();
pfixdef_length = pfixlen - first_actual_class_length;
}
}
} while (s == ",");
s = Lex::read_word();
if (s.isEmpty() || (*s != '.'))
break;
str_actuals = 0;
if (actuals != 0)
actuals->clear();
}
if (! s.isEmpty())
Lex::unread_word(s);
compute_type(path, typespec, tmplts, cl);
if (typespec.type != 0) {
if (internal_template)
// typespec.type stay unchanged
typespec.explicit_type = type;
}
else if ((first_actual_class != 0) && (*first_actual_class != 0)) {
def = type.left(pfixdef_length) + "${type}" +
type.mid(pfixdef_length+first_actual_class_length);
}
else
// path may be not good
typespec.explicit_type = type;
return TRUE;
}