void tst_Q3CString::simplifyWhiteSpace()
{
Q3CString j;
j.simplifyWhiteSpace();
Q3CString a;
a = "a ";
QCOMPARE(a.simplifyWhiteSpace(),(Q3CString)"a");
a=" a b ";
QCOMPARE(a.simplifyWhiteSpace(),(Q3CString)"a b");
}
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();
}
bool UmlAttribute::new_one(Class * container, const Q3CString & name,
const Q3CString & type, const Q3CString & modifier,
const Q3CString & pretype, const Q3CString & array,
aVisibility visibility, bool staticp, bool constp,
bool typenamep, bool mutablep, bool volatilep,
const Q3CString & bitfield, const Q3CString & value,
Q3CString comment, Q3CString description
#ifdef ROUNDTRIP
, bool roundtrip, Q3PtrList<UmlItem> & expected_order
#endif
)
{
#ifdef DEBUG_BOUML
cout << "ATTRIBUTE '" << name << "' type '" << type << "' modifier '" << modifier << "' array '" << array << "'\n";
#endif
if (
#ifdef REVERSE
container->from_libp() &&
#endif
(visibility == PrivateVisibility)) {
Lex::finish_line();
Lex::clear_comments();
return TRUE;
}
UmlClass * cl = container->get_uml();
UmlAttribute * at;
#ifdef ROUNDTRIP
bool created;
if (!roundtrip ||
((at = search_attr(cl, name)) == 0)) {
#endif
at = UmlBaseAttribute::create(cl, name);
if (at == 0) {
UmlCom::trace(Q3CString("<font face=helvetica><b>cannot add attribute <i>")
+ name + "</i> in <i>" + Q3CString(cl->name())
+ "</i></b></font><br><hr>");
return FALSE;
}
#ifdef REVERSE
# ifndef ROUNDTRIP
Statistic::one_attribute_more();
# else
if (roundtrip)
container->set_updated();
created = TRUE;
}
else
created = FALSE;
# endif
#endif
Lex::finish_line();
comment = Lex::get_comments(comment);
description = Lex::get_description(description);
bool pfunc = (type.find('$') != -1);
UmlTypeSpec typespec;
Q3CString typeform;
Q3CString stereotype;
if (! pfunc) {
typeform = (pretype.isEmpty())
? Q3CString("${type}")
: pretype + " ${type}";
container->compute_type(type, typespec, typeform);
}
else {
typespec.explicit_type = type.simplifyWhiteSpace();
int index = typespec.explicit_type.find("${name}");
if (index != -1)
typespec.explicit_type.remove(index, 7);
}
Q3CString decl = CppSettings::attributeDecl("");
int index = decl.find("${type}");
if ((index == -1) ||
(decl.find("${const}") == -1) ||
(decl.find("${name}") == -1) ||
(decl.find("${mutable}") == -1) ||
(decl.find("${volatile}") == -1) ||
(decl.find(';') == -1)) {
decl = " ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};";
index = decl.find("${type}");
}
if (pfunc)
decl.replace(index, decl.find("${name}") + 7 - index, type);
else {
if (!modifier.isEmpty())
decl.insert(index + 7, (const char*)(Q3CString(" ") + modifier));
if (typeform != "${type}")
decl.replace(index, 7, typeform);
else if (typespec.type == 0) {
Q3CString t = typespec.explicit_type;
int index2;
if (!t.isEmpty() &&
(t.at(t.length() - 1) == '>') &&
((index2 = t.find('<')) > 0)) {
stereotype = t.left(index2);
typespec.explicit_type =
// may be a,b ...
t.mid(index2 + 1, t.length() - 2 - index2);
decl.replace(index, 7, "${stereotype}<${type}>");
}
}
if (!array.isEmpty())
decl.insert(decl.find("${name}") + 7, "${multiplicity}");
if (!bitfield.isEmpty())
decl.insert(decl.find(';'), (const char *)(Q3CString(" : ") + bitfield));
}
if (typenamep) {
int index = decl.find("${const}") + 8; // find cannot return -1
int index2 = decl.find("${mutable}") + 10; // find cannot return -1
int index3 = decl.find("${volatile}") + 11; // find cannot return -1
if (index2 > index) index = index2;
if (index3 > index) index = index3;
decl.insert(index, "typename ");
}
if (!value.isEmpty() && ((index = decl.find("${value}")) != -1))
decl.insert(index + 2, "h_");
#ifdef ROUNDTRIP
if (roundtrip && !created) {
if (decl.find("${description}") != -1) {
if (nequal(at->description(), description)) {
at->set_Description(description);
container->set_updated();
}
}
else if (nequal(at->description(), Lex::simplify_comment(comment))) {
at->set_Description(comment); // comment was set
container->set_updated();
}
if (at->isReadOnly() != constp) {
at->set_isReadOnly(constp);
container->set_updated();
}
if (at->isCppMutable() != mutablep) {
at->set_isCppMutable(mutablep);
container->set_updated();
}
if (at->isVolatile() != volatilep) {
at->set_isVolatile(volatilep);
container->set_updated();
}
if (at->isClassMember() != staticp) {
at->set_isClassMember(staticp);
container->set_updated();
}
if (neq(at->multiplicity(), array)) {
at->set_Multiplicity(array);
container->set_updated();
}
if (!staticp) {
Q3CString v = at->defaultValue();
if (!v.isEmpty() && (((const char *) v)[0] == '='))
v = v.mid(1);
if (nequal(v, value)) {
at->set_DefaultValue(value);
container->set_updated();
}
}
if (at->visibility() != visibility) {
at->set_Visibility(visibility);
container->set_updated();
}
if (!stereotype.isEmpty()) {
Q3CString cppst;
if (!at->stereotype().isEmpty())
cppst = CppSettings::relationAttributeStereotype(at->stereotype());
if (cppst != stereotype) {
at->set_Stereotype(stereotype);
container->set_updated();
}
}
if (!at->type().equal(typespec)) {
at->set_Type(typespec);
container->set_updated();
}
if (neq(at->cppDecl(), decl)) {
at->set_CppDecl(decl);
container->set_updated();
}
at->set_usefull();
expected_order.append(at);
}
else {
#endif
if (!comment.isEmpty())
at->set_Description((decl.find("${description}") != -1)
? description : Lex::simplify_comment(comment));
if (constp)
at->set_isReadOnly(TRUE);
if (mutablep)
at->set_isCppMutable(TRUE);
if (volatilep)
at->set_isVolatile(TRUE);
if (staticp)
at->set_isClassMember(TRUE);
if (!array.isEmpty())
at->set_Multiplicity(array);
if (! value.isEmpty())
at->set_DefaultValue(value);
at->set_Visibility(visibility);
if (! stereotype.isEmpty())
at->set_Stereotype(stereotype);
at->set_Type(typespec);
at->set_CppDecl(decl);
#ifdef ROUNDTRIP
if (roundtrip)
expected_order.append(at);
}
#endif
return TRUE;
}
static void parse( MetaTranslator *tor, const char *initialContext,
const char *defaultContext )
{
QMap<Q3CString, Q3CString> qualifiedContexts;
QStringList namespaces;
Q3CString context;
Q3CString ext;
Q3CString text;
Q3CString comment;
Q3CString functionContext = initialContext;
Q3CString prefix;
bool utf8 = FALSE;
yyTok = getToken();
while ( yyTok != Tok_Eof ) {
switch ( yyTok ) {
case Tok_i18n:
utf8 = FALSE;
yyTok = getToken();
if ( match( Tok_LeftParen ) &&
( matchString( &context ) || matchSString( &context ) ) &&
match( Tok_Comma ) &&
( matchString( &text ) || matchSString( &text ) ) )
{
if ( ( match( Tok_Comma ) &&
( matchString( &comment ) || matchSString( &comment ) ) &&
match( Tok_RightParen ) ) == false )
{
comment = "";
}
tor->insert( MetaTranslatorMessage( context, text, comment, QString::null, utf8 ) );
}
// else
// qDebug( " --- token failed ------------" );
break;
case Tok_x18n:
utf8 = FALSE;
yyTok = getToken();
if ( match( Tok_LeftParen ) &&
( matchString( &ext ) || matchSString( &ext ) ) &&
match( Tok_Comma ) &&
( matchString( &context ) || matchSString( &context ) ) &&
match( Tok_Comma ) &&
( matchString( &text ) || matchSString( &text ) ) )
{
if ( ( match( Tok_Comma ) &&
( matchString( &comment ) || matchSString( &comment ) ) &&
match( Tok_RightParen ) ) == false )
{
comment = "";
}
tor->insert( MetaTranslatorMessage( context, text, comment, QString::null, utf8 ) );
}
// else
// qDebug( " --- token failed ------------" );
break;
case Tok_Ident:
if ( !prefix.isNull() )
prefix += "::";
prefix += yyIdent;
yyTok = getToken();
if ( yyTok != Tok_Gulbrandsen )
prefix = (const char *) 0;
break;
case Tok_Comment:
comment = yyComment;
comment = comment.simplifyWhiteSpace();
yyTok = getToken();
break;
case Tok_Gulbrandsen:
// at top level?
if ( yyBraceDepth == (int) namespaces.count() && yyParenDepth == 0 )
functionContext = prefix;
yyTok = getToken();
break;
case Tok_RightBrace:
case Tok_Semicolon:
if ( yyBraceDepth >= 0 &&
yyBraceDepth + 1 == (int) namespaces.count() )
namespaces.remove( namespaces.fromLast() );
if ( yyBraceDepth == (int) namespaces.count() ) {
functionContext = defaultContext;
}
yyTok = getToken();
break;
default:
yyTok = getToken();
}
}
// if ( yyBraceDepth != 0 )
// qWarning( "%s: Unbalanced braces in PHP code", (const char *) yyFileName );
// if ( yyParenDepth != 0 )
// qWarning( "%s: Unbalanced parentheses in PHP code", (const char *) yyFileName );
}
