void UmlClassMember::write_type(FileOut & out, const UmlTypeSpec & t, Q3CString s, const char * k_name, const char * k_type)
{
s = s.simplifyWhiteSpace();
int index;
// remove k_name and all after it except []
if (k_name && *k_name && ((index = s.find(k_name, 0)) != -1)) {//[rageek] Removed CS=FALSE - rethink this, case sensitive
//remove name
s.remove(index, strlen(k_name));
for (;;) {
if (s[index] == ' ')
s.remove(index, 1);
if (s[index] != '[')
break;
index += 1;
int index2;
if ((index2 = s.find(index, ']')) == -1)
break;
index = index2 + 1;
}
s.resize(index);
}
else if ((index = s.find('=')) != -1) {
s.resize(index);
s = s.simplifyWhiteSpace();
}
if (k_type && *k_type && ((index = s.find(k_type)) == -1))
out.idref_datatype(s);
else if (s != k_type) {
// have modifiers
if (t.type != 0) {
s.replace(index, strlen(k_type), t.type->name());
out.idref(s, t.type);
}
else
out.idref_datatype(s.replace(index, strlen(k_type), t.explicit_type));
}
else if (t.type != 0)
out.idref(t.type);
else
out.idref_datatype(t.explicit_type);
}
void UmlClassMember::remove_comments(Q3CString & s)
{
int index;
if ((index = s.find("${comment}")) != -1)
s.replace(index, 10, " ");
index = 0;
while ((index = s.find('#', index)) != -1) {
int index2 = s.find('\n', index + 1);
if (index2 == -1) {
s.resize(index);
break;
}
s.remove(index, index2 - index);
}
index = 0;
while ((index = s.find("//", index)) != -1) {
int index2 = s.find('\n', index + 2);
if (index2 == -1) {
s.resize(index);
break;
}
s.remove(index, index2 - index);
}
index = 0;
while ((index = s.find("/*", index)) != -1) {
int index2 = s.find("*/", index + 2);
if (index2 == -1) {
s.resize(index);
break;
}
s.replace(index, index2 + 2 - index, " ");
}
s = s.simplifyWhiteSpace();
}
// remove first and last line in comment if non significant
Q3CString Lex::simplify_comment(Q3CString & 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;
}
}
}
Q3CString Q3CString::rightJustify(uint width, char fill, bool truncate) const
{
Q3CString result;
int len = qstrlen(constData());
int padlen = width - len;
if (padlen > 0) {
result.resize(len+padlen);
memset(result.data(), fill, padlen);
memcpy(result.data()+padlen, constData(), len);
} else {
if (truncate)
result = left(width);
else
result = *this;
}
return result;
}
bool UmlOperation::new_one(Class * container, const Q3CString & name,
const Q3ValueList<FormalParameterList> & tmplts,
const Q3CString & oper_templ,
UmlTypeSpec & type, Q3CString str_actuals,
UmlClass * first_actual_class, Q3CString type_def,
aVisibility visibility,
bool finalp, bool abstractp, bool staticp,
bool nativep, bool strictfp, bool synchronizedp,
const Q3CString & array, Q3CString comment,
Q3CString description, Q3CString annotation
#ifdef ROUNDTRIP
, bool roundtrip, Q3PtrList<UmlItem> & expected_order
#endif
)
{
// the "(" was read
#ifdef TRACE
QLOG_INFO() <<"OPERATION '" << name << "'\n";
#endif
UmlClass * cl = container->get_uml();
UmlOperation * op;
#ifdef ROUNDTRIP
bool may_roundtrip = roundtrip &&
(!container->from_libp() || (visibility != PrivateVisibility));
UmlTypeSpec return_type;
Q3ValueList<UmlParameter> params;
Q3ValueList<UmlTypeSpec> exceptions;
Q3CString body;
if (may_roundtrip)
#else
if (
# ifdef REVERSE
container->from_libp() &&
# endif
(visibility == PrivateVisibility))
#endif
op = 0;
else {
op = UmlBaseOperation::create(cl, name);
if (op == 0) {
JavaCatWindow::trace(Q3CString("<font face=helvetica><b>cannot add operation <i>")
+ name + "</i> in <i>" + cl->name()
+ "</i></b></font><br>");
return FALSE;
}
#ifndef ROUNDTRIP
# if defined(REVERSE)
Statistic::one_operation_more();
# endif
#endif
}
Q3CString def;
#ifdef ROUNDTRIP
if (may_roundtrip || (op != 0)) {
#else
if (op != 0) {
op->set_Visibility(visibility);
if (staticp) op->set_isClassMember(TRUE);
if (abstractp) op->set_isAbstract(TRUE);
if (finalp) op->set_isJavaFinal(TRUE);
if (synchronizedp) op->set_isJavaSynchronized(TRUE);
if (! annotation.isEmpty()) op->set_JavaAnnotations(annotation);
#endif
def = JavaSettings::operationDef();
int index;
if (((index = def.find("${(}")) == -1) ||
((index = def.find("${)}", index + 4)) == -1) ||
((index = def.find("${throws}", index + 4)) == -1) ||
(def.find("${body}", index + 9) == -1) ||
((index = def.find("${type}")) == -1)) {
// use a definition where ${body] is not indented
def = " ${comment}${@}${visibility}${final}${static}${abstract}${synchronized}${type} ${name}${(}${)}${throws}${staticnl}{\n${body}}\n";
index = def.find("${type}");
}
if (!array.isEmpty())
def.insert(index + 7, (const char *)array);
if (nativep) {
def.insert(index, "native ");
index += 7;
// no body
int index2 = def.find("${throws}", index+7);
if (index2 != -1) {
def.resize(index2 + 12);
def[index2 + 9] = ';';
def[index2 + 10] = '\n';
}
}
if (strictfp) {
def.insert(index, "strictfp ");
index += 9;
}
if (! oper_templ.isEmpty())
def.insert(index, (const char *)(oper_templ + " "));
if (name == cl->name()) {
// constructor, remove useless ${}
if ((index = def.find("${static}")) != -1)
def.remove(index, 9);
if ((index = def.find("${type}")) != -1)
def.remove(index, (((const char *) def)[index + 7] == ' ') ? 8 : 7);
if ((index = def.find("${final}")) != -1)
def.remove(index, 8);
if ((index = def.find("${abstract}")) != -1)
def.remove(index, 11);
}
if (type.type != 0) {
UmlClass::manage_generic(def, type, str_actuals, "${type}");
#ifdef ROUNDTRIP
return_type = type;
#else
op->set_ReturnType(type);
#endif
}
else if (first_actual_class != 0) {
#ifndef ROUNDTRIP
UmlTypeSpec return_type;
#endif
return_type.type = first_actual_class;
def.replace(def.find("${type}"), 7, type_def);
#ifndef ROUNDTRIP
op->set_ReturnType(return_type);
#endif
}
else if (!type.explicit_type.isEmpty()) {
// not a contructor
#ifdef ROUNDTRIP
return_type = type;
#else
op->set_ReturnType(type);
#endif
}
}
// parameters
unsigned rank = 0;
UmlParameter param;
#ifdef ROUNDTRIP
if (may_roundtrip)
while (read_param(container, rank++, tmplts, param, def, FALSE))
params.append(param);
else
#endif
while (read_param(container, rank, tmplts, param, def, op == 0)) {
if ((op != 0) && ! op->addParameter(rank, param)) {
JavaCatWindow::trace(Q3CString("<font face=helvetica><b>cannot add param <i>")
+ name + "</i> in <i>" + cl->name()
+ "</i></b></font><br>");
# ifdef TRACE
QLOG_INFO() <<"ERROR cannot add param '" << param.name << "' type '" << param.type.Type() << '\n';
# endif
return FALSE;
}
rank += 1;
}
Q3CString s = Lex::read_word();
if (!s.isEmpty() && (*((const char *) s) == '[')) {
#ifdef ROUNDTRIP
if (may_roundtrip)
#else
if (op != 0)
#endif
// do not place it at the same place
def.insert(def.find("${type}") + 7, (const char *)s);
s = Lex::read_word();
}
if (s.isEmpty()) {
Lex::premature_eof();
return FALSE;
}
if (s == "throws") {
// throws
rank = 0;
for (;;) {
if ((s = Lex::read_word()).isEmpty()) {
Lex::premature_eof();
return FALSE;
}
#ifdef ROUNDTRIP
if (may_roundtrip) {
UmlTypeSpec typespec;
container->compute_type(s, typespec, tmplts);
exceptions.append(typespec);
}
else
#endif
if (op != 0) {
UmlTypeSpec typespec;
container->compute_type(s, typespec, tmplts);
if (! op->addException(rank++, typespec)) {
# ifdef TRACE
QLOG_INFO() <<"cannot add exception " << s << '\n';
# endif
return FALSE;
}
}
if (((s = Lex::read_word()) == "{") || (s == ";"))
break;
if (s != ",") {
Lex::error_near(s, " ',' expected");
return FALSE;
}
}
}
// definition
if (abstractp || nativep ||
(cl->stereotype() == "interface") ||
(cl->stereotype() == "@interface")) {
if ((s == "default") && (cl->stereotype() == "@interface")) {
int index = def.find("${)}");
Lex::mark();
s = Lex::read_word();
if (s == "{") {
int level = 1;
char c;
for (;;) {
if ((c = Lex::read_word_bis()) == 0)
return FALSE;
else if (c == '{')
level += 1;
else if ((c == '}') && (--level == 0))
break;
}
s = Lex::region();
}
def.insert(index + 4, (const char *)(" default" + s));
s = Lex::read_word();
}
if (s != ";") {
Lex::error_near(s, " ';' expected");
return FALSE;
}
#ifdef REVERSE
# ifndef ROUNDTRIP
if ((op != 0) && !container->from_libp())
op->set_JavaBody(0);
# endif
#endif
}
else if (s != "{") {
Lex::error_near(s, " '{' expected");
return FALSE;
}
else {
Lex::mark();
// goto the end of the body
#ifndef ROUNDTRIP
Q3CString body;
#endif
int level = 1; // '{' already read
char c;
for (;;) {
if ((c = Lex::read_word_bis()) == 0)
return FALSE;
else if (c == '{')
level += 1;
else if ((c == '}') && (--level == 0))
break;
}
#ifdef REVERSE
if (
# ifdef ROUNDTRIP
may_roundtrip || (op != 0)
# else
(op != 0) && !container->from_libp()
# endif
) {
body = Lex::region();
body.truncate(body.length() - 1); // remove }
// remove fist \n
if (*((const char *) body) == '\n')
body.remove(0, 1);
// remove last spaces and tabs
int ln = body.length();
while (ln && ((body[ln - 1] == ' ') || (body[ln - 1] == '\t')))
ln -= 1;
body.truncate(ln);
if (!body.isEmpty() && (body[ln - 1] != '\n'))
body += "\n";
# ifndef ROUNDTRIP
op->set_JavaBody(body);
op->set_JavaContextualBodyIndent(FALSE);
# endif
}
#endif
}
#ifdef ROUNDTRIP
if (may_roundtrip) {
if (((op = already_exist_from_id(container, body)) != 0) ||
((op = already_exist(container, name, params)) != 0)) {
// update already existing operation
op->set_usefull();
{
// remove \r in case of preserve body
Q3CString current_body = op->javaBody();
int index = 0;
while ((index = current_body.find('\r', index)) != -1)
current_body.remove(index, 1);
if (nequal(current_body, body)) {
container->set_updated();
op->set_JavaBody(body);
op->set_JavaContextualBodyIndent(FALSE);
}
}
if (op->visibility() != visibility) {
container->set_updated();
op->set_Visibility(visibility);
}
if (op->isClassMember() != staticp) {
container->set_updated();
op->set_isClassMember(staticp);
}
if (op->isAbstract() != abstractp) {
container->set_updated();
op->set_isAbstract(abstractp);
}
if (op->isJavaFinal() != finalp) {
container->set_updated();
op->set_isJavaFinal(finalp);
}
if (op->isJavaSynchronized() != synchronizedp) {
container->set_updated();
op->set_isJavaSynchronized(synchronizedp);
}
if (nequal(op->javaAnnotations(), annotation)) {
container->set_updated();
op->set_JavaAnnotations(annotation);
}
if (!op->returnType().equal(return_type)) {
container->set_updated();
op->set_ReturnType(return_type);
}
Q3ValueList<UmlParameter>::Iterator itp1;
const Q3ValueList<UmlParameter> old_params = op->params();
Q3ValueList<UmlParameter>::ConstIterator itp2;
for (rank = 0, itp1 = params.begin(), itp2 = old_params.begin();
(itp1 != params.end()) && (itp2 != old_params.end());
++itp1, ++itp2, rank += 1) {
UmlParameter & p1 = *itp1;
const UmlParameter & p2 = *itp2;
if ((p1.name != p2.name) ||
nequal(p1.default_value, p2.default_value) ||
!p1.type.equal(p2.type)) {
if (p1.dir != InputDirection)
p1.dir = p2.dir;
op->replaceParameter(rank, p1);
container->set_updated();
}
else if ((p1.dir == InputDirection) && (p2.dir != InputDirection)) {
op->replaceParameter(rank, p1);
container->set_updated();
}
}
if (itp1 != params.end()) {
// have missing params
container->set_updated();
do {
op->addParameter(rank, *itp1);
itp1++;
rank += 1;
} while (itp1 != params.end());
}
else if (itp2 != old_params.end()) {
// have extra params
container->set_updated();
do {
op->removeParameter(rank);
itp2++;
} while (itp2 != old_params.end());
}
Q3ValueList<UmlTypeSpec>::ConstIterator ite1;
const Q3ValueList<UmlTypeSpec> old_exceptions = op->exceptions();
Q3ValueList<UmlTypeSpec>::ConstIterator ite2;
for (rank = 0, ite1 = exceptions.begin(), ite2 = old_exceptions.begin();
(ite1 != exceptions.end()) && (ite2 != old_exceptions.end());
++ite1, ++ite2, rank += 1) {
const UmlTypeSpec & e1 = *ite1;
if (!e1.equal(*ite2)) {
op->replaceException(rank, e1);
container->set_updated();
}
}
if (ite1 != exceptions.end()) {
// have missing exceptions
container->set_updated();
do {
op->addException(rank, *ite1);
ite1++;
rank += 1;
} while (ite1 != exceptions.end());
}
else if (ite2 != old_exceptions.end()) {
// have extra exceptions
container->set_updated();
do {
op->removeException(rank);
ite2++;
} while (ite2 != old_exceptions.end());
}
if (neq(def, op->javaDecl())) {
container->set_updated();
op->set_JavaDecl(def);
}
Lex::clear_comments(); // params & body comments
Lex::finish_line();
if (def.find("${description}") != -1) {
if (nequal(op->description(), description)) {
container->set_updated();
op->set_Description(description);
}
}
else if (nequal(op->description(), Lex::simplify_comment(comment))) {
op->set_Description(comment); // comment was set
container->set_updated();
}
expected_order.append(op);
return TRUE;
}
// operation doesn't yet exist
container->set_updated();
op = UmlBaseOperation::create(cl, name);
if (op == 0) {
JavaCatWindow::trace(Q3CString("<font face=helvetica><b>cannot add operation <i>")
+ name + "</i> in <i>" + cl->name()
+ "</i></b></font><br>");
throw 0;
}
expected_order.append(op);
Q3ValueList<UmlParameter>::ConstIterator itp;
for (rank = 0, itp = params.begin(); itp != params.end(); ++itp)
op->addParameter(rank++, *itp);
Q3ValueList<UmlTypeSpec>::ConstIterator ite;
for (rank = 0, ite = exceptions.begin(); ite != exceptions.end(); ++ite)
op->addException(rank++, *ite);
}
if (op != 0) {
op->set_JavaContextualBodyIndent(FALSE);
op->set_Visibility(visibility);
if (staticp) op->set_isClassMember(TRUE);
if (abstractp) op->set_isAbstract(TRUE);
if (finalp) op->set_isJavaFinal(TRUE);
if (synchronizedp) op->set_isJavaSynchronized(TRUE);
if (! annotation.isEmpty()) op->set_JavaAnnotations(annotation);
op->set_JavaBody(body);
op->set_ReturnType(return_type);
if (def != JavaSettings::operationDef())
op->set_JavaDecl(def);
}
#else
if ((op != 0) && (def != JavaSettings::operationDef()))
op->set_JavaDecl(def);
#endif
Lex::clear_comments(); // params & body comments
Lex::finish_line();
if (!comment.isEmpty())
if (op != 0)
op->set_Description((def.find("${description}") != -1)
? description : Lex::simplify_comment(comment));
return TRUE;
}
bool UmlOperation::read_param(Class * container, unsigned rank,
const Q3ValueList<FormalParameterList> & tmplts,
UmlParameter & param, Q3CString & def, bool bypass)
{
#ifdef TRACE
QLOG_INFO() <<"UmlOperation::manage_param " << rank << "\n";
#endif
bool finalp = FALSE;
bool in = FALSE;
bool ellipsis = FALSE;
Q3CString array;
bool type_read = FALSE;
Q3ValueList<UmlTypeSpec> actuals;
Q3CString str_actuals;
Q3CString annotation;
param.name = param.default_value = 0;
Q3CString s = Lex::read_word();
#ifdef TRACE
QLOG_INFO() <<"commence par " << s << '\n';
#endif
if (s == ")")
return FALSE;
for (;;) {
if (s.isEmpty()) {
Lex::premature_eof();
return FALSE;
}
else if (s == "final")
finalp = TRUE;
else if ((s == "void") || (s == "byte") || (s == "char") ||
(s == "short") || (s == "int") || (s == "long") ||
(s == "float") || (s == "double")) {
if (type_read) {
Lex::error_near(s);
return FALSE;
}
param.type.type = 0;
param.type.explicit_type = s;
type_read = TRUE;
in = TRUE;
}
else if ((s == ")") || (s == ",")) {
if (param.name.isEmpty() && !type_read) {
Lex::error_near(s);
return FALSE;
}
if (s == ")")
Lex::unread_word(s);
if (! bypass) {
param.dir = (finalp || in)
? InputDirection : InputOutputDirection;
Q3CString s;
if (rank != 0)
s = ", ";
if (! annotation.isEmpty())
s += annotation + " ";
if (finalp)
s += "final ";
if ((param.type.type != 0) &&
!param.type.explicit_type.isEmpty())
s += param.type.explicit_type;
else {
s += "${t";
s += Q3CString().setNum(rank);
s += "}";
if (param.type.type != 0)
s += str_actuals;
}
s += array;
s += (ellipsis) ? " ... ${p": " ${p";
s += Q3CString().setNum(rank);
s += "}";
def.insert(def.find("${)}"), // cannot be -1
(const char *)s);
}
return TRUE;
}
else if (Lex::identifierp(s)) {
if (!type_read) {
while (s.at(s.length() - 1) == '.') {
// type on several lines, managed in this case
Q3CString s2 = Lex::read_word();
if (Lex::identifierp(s2))
s += s2;
else {
Lex::error_near(s, " identifier expected");
return FALSE;
}
}
#ifdef TRACE
QLOG_INFO() <<"type = '" << s << "...'\n";
#endif
if (! bypass) {
Q3CString dummy;
container->read_type(param.type, 0, tmplts, 0, str_actuals, s,
0, dummy, dummy);
if (param.type.explicit_type == "String")
// at least for it !
in = TRUE;
}
else
Lex::bypass_type(s);
type_read = TRUE;
}
else if (param.name.isEmpty()) {
if (s == "...")
ellipsis = TRUE;
else {
param.name = s;
#ifdef TRACE
QLOG_INFO() <<"name = '" << param.name << "'\n";
#endif
}
}
else {
Lex::error_near(s);
#ifdef TRACE
QLOG_INFO() <<"ERROR '" << s << "' alors qu a deja le type et le nom '" << param.name << "'\n";
#endif
return FALSE;
}
}
else if (*((const char *) s) == '@')
annotation = s;
else if (*((const char *) s) == '[') {
in = FALSE;
array = s;
}
else {
Lex::error_near(s);
#ifdef TRACE
QLOG_INFO() <<"ERROR : '" << s << "'\n";
#endif
return FALSE;
}
s = Lex::read_word();
}
}
void UmlArtifact::gen_app(const Q3CString & path) {
Q3CString target;
Q3CString 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");
}
Q3CString tmplt;
Q3CString config;
Q3CString defines;
Q3CString includepath;
Q3CString dependpath;
Q3CString objectsdir;
Q3CString 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(QIODevice::WriteOnly))
QMessageBox::critical((QWidget *) 0, "Error", "Cannot open " + QString(pro));
else {
Q3TextStream 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 Q3PtrVector<UmlArtifact> & arts = associatedArtifacts();
unsigned index;
const char * sep;
Q3CString 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;
}
}
}
