TDE
/
tdesdk
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdesdk
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '508a49f9ef'
${ noResults }
tdesdk/umbrello/umbrello/codegenerators/adawriter.cpp

687 lines
25 KiB
Raw Blame History

/***************************************************************************
* adawriter.cpp - description *
* ------------------- *
* Based on javawriter.cpp by Luis De la Parra Blum *
* copyright : (C) 2002 by Oliver Kellogg *
* (C) 2003-2007 Umbrello UML Modeller Authors <uml-devel@uml.sf.net> *
***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "adawriter.h"
#include <kdebug.h>
#include <tdelocale.h>
#include <tdemessagebox.h>
#include <tqfile.h>
#include <tqregexp.h>
#include <tqtextstream.h>
#include "../umldoc.h"
#include "../uml.h"
#include "../classifier.h"
#include "../enum.h"
#include "../classifierlistitem.h"
#include "../umlclassifierlistitemlist.h"
#include "../umltemplatelist.h"
#include "../folder.h"
#include "../association.h"
#include "../attribute.h"
#include "../operation.h"
#include "../template.h"
#include "../umlnamespace.h"
const TQString AdaWriter::defaultPackageSuffix = "_Holder";
AdaWriter::AdaWriter() {
}
AdaWriter::~AdaWriter() {}
/**
* returns "Ada"
*/
Uml::Programming_Language AdaWriter::getLanguage() {
return Uml::pl_Ada;
}
bool AdaWriter::isOOClass(UMLClassifier *c) {
Uml::Object_Type ot = c->getBaseType();
if (ot == Uml::ot_Interface)
return true;
if (ot == Uml::ot_Enum)
return false;
if (ot != Uml::ot_Class) {
kDebug() << "AdaWriter::isOOClass: unknown object type " << ot << endl;
return false;
}
TQString stype = c->getStereotype();
if (stype == "CORBAConstant" || stype == "CORBATypedef" ||
stype == "CORBAStruct" || stype == "CORBAUnion")
return false;
// CORBAValue, CORBAInterface, and all empty/unknown stereotypes are
// assumed to be OO classes.
return true;
}
TQString AdaWriter::className(UMLClassifier *c, bool inOwnScope) {
// If the class has an enclosing package then it is assumed that
// the class name is the type name; if the class does not have an
// enclosing package then the class name acts as the Ada package
// name.
TQString retval;
TQString className = cleanName(c->getName());
UMLPackage *umlPkg = c->getUMLPackage();
if (umlPkg == UMLApp::app()->getDocument()->getRootFolder(Uml::mt_Logical)) {
if (! inOwnScope)
retval = className + '.';
retval.append("Object");
} else {
if (! inOwnScope)
retval = umlPkg->getFullyQualifiedName(".") + '.';
retval.append(className);
}
return retval;
}
TQString AdaWriter::packageName(UMLPackage *p) {
// If the class has an enclosing package then it is assumed that
// the class name is the type name; if the class does not have an
// enclosing package then the class name acts as the Ada package
// name.
UMLPackage *umlPkg = p->getUMLPackage();
TQString className = cleanName(p->getName());
TQString retval;
if (umlPkg == UMLApp::app()->getDocument()->getRootFolder(Uml::mt_Logical))
umlPkg = NULL;
UMLClassifier *c = dynamic_cast<UMLClassifier*>(p);
if (umlPkg == NULL) {
retval = className;
if (c == NULL || !isOOClass(c))
retval.append(defaultPackageSuffix);
} else {
retval = umlPkg->getFullyQualifiedName(".");
}
return retval;
}
void AdaWriter::computeAssocTypeAndRole(UMLClassifier *c,
UMLAssociation *a,
TQString& typeName, TQString& roleName) {
UMLClassifier* assocEnd = dynamic_cast<UMLClassifier*>(a->getObject(Uml::B));
if (assocEnd == NULL)
return;
const Uml::Association_Type assocType = a->getAssocType();
if (assocType != Uml::at_Aggregation && assocType != Uml::at_Composition)
return;
const TQString multi = a->getMulti(Uml::B);
bool hasNonUnityMultiplicity = (!multi.isEmpty() && multi != "1");
hasNonUnityMultiplicity &= !multi.contains(TQRegExp("^1 *\\.\\. *1$"));
roleName = cleanName(a->getRoleName(Uml::B));
if (roleName.isEmpty())
roleName = cleanName(a->getName());
if (roleName.isEmpty()) {
TQString artificialName = cleanName(assocEnd->getName());
if (hasNonUnityMultiplicity) {
roleName = artificialName;
roleName.append("_Vector");
} else {
roleName = "M_";
roleName.append(artificialName);
}
}
typeName = className(assocEnd, (assocEnd == c));
if (hasNonUnityMultiplicity)
typeName.append("_Array_Ptr");
else if (assocType == Uml::at_Aggregation)
typeName.append("_Ptr");
}
void AdaWriter::writeClass(UMLClassifier *c) {
if (!c) {
kDebug() << "Cannot write class of NULL concept!" << endl;
return;
}
const bool isClass = !c->isInterface();
TQString classname = cleanName(c->getName());
TQString fileName = packageName(c).lower();
fileName.replace('.', '-');
//find an appropriate name for our file
fileName = overwritableName(c, fileName, ".ads");
if (fileName.isEmpty()) {
emit codeGenerated(c, false);
return;
}
TQFile file;
if (!openFile(file, fileName)) {
emit codeGenerated(c, false);
return;
}
// Start generating the code.
TQTextStream ada(&file);
//try to find a heading file(license, comments, etc)
TQString str;
str = getHeadingFile(".ads");
if (!str.isEmpty()) {
str.replace(TQRegExp("%filename%"), fileName);
str.replace(TQRegExp("%filepath%"), file.name());
ada << str << endl;
}
// Import referenced classes.
UMLPackageList imports;
findObjectsRelated(c, imports);
if (imports.count()) {
for (UMLPackage *con = imports.first(); con; con = imports.next()) {
if (con->getBaseType() != Uml::ot_Datatype)
ada << "with " << packageName(con) << "; " << m_endl;
}
ada << m_endl;
}
// Generate generic formals.
UMLTemplateList template_params = c->getTemplateList();
if (template_params.count()) {
ada << getIndent() << "generic" << m_endl;
m_indentLevel++;
for (UMLTemplate *t = template_params.first(); t; t = template_params.next()) {
TQString formalName = t->getName();
TQString typeName = t->getTypeName();
if (typeName == "class") {
ada << getIndent() << "type " << formalName << " is tagged private;"
<< m_endl;
} else {
// Check whether it's a data type.
UMLClassifier *typeObj = t->getType();
if (typeObj == NULL) {
kError() << "AdaWriter::writeClass(template_param "
<< typeName << "): typeObj is NULL" << endl;
ada << getIndent() << "type " << formalName << " is new " << typeName
<< " with private; -- CHECK: codegen error"
<< m_endl;
} else if (typeObj->getBaseType() == Uml::ot_Datatype) {
ada << getIndent() << formalName << " : " << typeName << ";"
<< m_endl;
} else {
ada << getIndent() << "type " << typeName << " is new "
<< formalName << " with private;" << m_endl;
}
}
}
m_indentLevel--;
}
// Here comes the package proper.
TQString pkg = packageName(c);
ada << getIndent() << "package " << pkg << " is" << m_endl << m_endl;
m_indentLevel++;
if (c->getBaseType() == Uml::ot_Enum) {
UMLEnum *ue = static_cast<UMLEnum*>(c);
UMLClassifierListItemList litList = ue->getFilteredList(Uml::ot_EnumLiteral);
uint i = 0;
ada << getIndent() << "type " << classname << " is (" << m_endl;
m_indentLevel++;
for (UMLClassifierListItem *lit = litList.first(); lit; lit = litList.next()) {
TQString enumLiteral = cleanName(lit->getName());
ada << getIndent() << enumLiteral;
if (++i < litList.count())
ada << "," << m_endl;
}
m_indentLevel--;
ada << ");" << m_endl << m_endl;
m_indentLevel--;
ada << getIndent() << "end " << pkg << ";" << m_endl << m_endl;
return;
}
if (! isOOClass(c)) {
TQString stype = c->getStereotype();
if (stype == "CORBAConstant") {
ada << getIndent() << "-- " << stype << " is Not Yet Implemented" << m_endl << m_endl;
} else if(stype == "CORBAStruct") {
if (isClass) {
UMLAttributeList atl = c->getAttributeList();
UMLAttribute *at;
ada << getIndent() << "type " << classname << " is record" << m_endl;
m_indentLevel++;
for (at = atl.first(); at; at = atl.next()) {
TQString name = cleanName(at->getName());
TQString typeName = at->getTypeName();
ada << getIndent() << name << " : " << typeName;
TQString initialVal = at->getInitialValue();
if (initialVal.latin1() && ! initialVal.isEmpty())
ada << " := " << initialVal;
ada << ";" << m_endl;
}
m_indentLevel--;
ada << getIndent() << "end record;" << m_endl << m_endl;
}
} else if(stype == "CORBAUnion") {
ada << getIndent() << "-- " << stype << " is Not Yet Implemented" << m_endl << m_endl;
} else if(stype == "CORBATypedef") {
ada << getIndent() << "-- " << stype << " is Not Yet Implemented" << m_endl << m_endl;
} else {
ada << getIndent() << "-- " << stype << ": Unknown stereotype" << m_endl << m_endl;
}
m_indentLevel--;
ada << getIndent() << "end " << pkg << ";" << m_endl << m_endl;
return;
}
// Write class Documentation if non-empty or if force option set.
if (forceDoc() || !c->getDoc().isEmpty()) {
ada << "--" << m_endl;
ada << "-- class " << classname << endl;
ada << formatDoc(c->getDoc(), "-- ");
ada << m_endl;
}
UMLClassifierList superclasses = c->getSuperClasses();
const TQString name = className(c);
ada << getIndent() << "type " << name << " is ";
if (c->getAbstract())
ada << "abstract ";
if (superclasses.isEmpty()) {
ada << "tagged ";
} else {
// FIXME: Multiple inheritance is not yet supported
UMLClassifier* parent = superclasses.first();
ada << "new " << className(parent, false) << " with ";
}
ada << "private;" << m_endl << m_endl;
ada << getIndent() << "type " << name << "_Ptr is access all " << name << "'Class;" << m_endl << m_endl;
ada << getIndent() << "type " << name << "_Array is array (Positive range <>) of " << name << "_Ptr;" << m_endl << m_endl;
ada << getIndent() << "type " << name << "_Array_Ptr is access " << name << "_Array;" << m_endl << m_endl;
// Generate accessors for public attributes.
UMLAttributeList atl;
if (isClass) {
UMLAttributeList atpub;
atpub.setAutoDelete(false);
atl = c->getAttributeList();
UMLAttribute *at;
for (at = atl.first(); at; at = atl.next()) {
if (at->getVisibility() == Uml::Visibility::Public)
atpub.append(at);
}
if (forceSections() || atpub.count())
ada << getIndent() << "-- Accessors for public attributes:" << m_endl << m_endl;
for (at = atpub.first(); at; at = atpub.next()) {
TQString member = cleanName(at->getName());
ada << getIndent() << "procedure Set_" << member << " (";
if (! at->getStatic())
ada << "Self : access " << name << "; ";
ada << "To : " << at->getTypeName() << ");" << m_endl;
ada << getIndent() << "function Get_" << member;
if (! at->getStatic())
ada << " (Self : access " << name << ")";
ada << " return " << at->getTypeName() << ";" << m_endl
<< m_endl;
}
}
// Generate public operations.
UMLOperationList opl(c->getOpList());
UMLOperationList oppub;
oppub.setAutoDelete(false);
UMLOperation *op;
for (op = opl.first(); op; op = opl.next()) {
if (op->getVisibility() == Uml::Visibility::Public)
oppub.append(op);
}
if (forceSections() || oppub.count())
ada << getIndent() << "-- Public methods:" << m_endl << m_endl;
for (op = oppub.first(); op; op = oppub.next())
writeOperation(op, ada);
m_indentLevel--;
ada << getIndent() << "private" << m_endl << m_endl;
m_indentLevel++;
UMLAssociationList aggregations = c->getAggregations();
UMLAssociationList compositions = c->getCompositions();
ada << getIndent() << "type " << name << " is ";
if (c->getAbstract())
ada << "abstract ";
if (superclasses.isEmpty()) {
ada << "tagged ";
} else {
// FIXME: Multiple inheritance is not yet supported
UMLClassifier* parent = superclasses.first();
ada << "new " << className(parent, false) << " with ";
}
ada << "record" << m_endl;
m_indentLevel++;
if (forceSections() || !aggregations.isEmpty()) {
ada << getIndent() << "-- Aggregations:" << m_endl;
for (UMLAssociation *a = aggregations.first(); a; a = aggregations.next()) {
if (c != a->getObject(Uml::A))
continue;
TQString typeName, roleName;
computeAssocTypeAndRole(c, a, typeName, roleName);
ada << getIndent() << roleName << " : " << typeName << ";" << m_endl;
}
ada << endl;
}
if (forceSections() || !compositions.isEmpty()) {
ada << getIndent() << "-- Compositions:" << m_endl;
for (UMLAssociation *a = compositions.first(); a; a = compositions.next()) {
if (c != a->getObject(Uml::A))
continue;
TQString typeName, roleName;
computeAssocTypeAndRole(c, a, typeName, roleName);
ada << getIndent() << roleName << " : " << typeName << ";" << m_endl;
}
ada << endl;
}
if (isClass && (forceSections() || atl.count())) {
ada << getIndent() << "-- Attributes:" << m_endl;
UMLAttribute *at;
for (at = atl.first(); at; at = atl.next()) {
if (at->getStatic())
continue;
ada << getIndent() << cleanName(at->getName()) << " : "
<< at->getTypeName();
if (at && at->getInitialValue().latin1() && ! at->getInitialValue().isEmpty())
ada << " := " << at->getInitialValue();
ada << ";" << m_endl;
}
}
bool haveAttrs = (isClass && atl.count());
if (aggregations.isEmpty() && compositions.isEmpty() && !haveAttrs)
ada << getIndent() << "null;" << m_endl;
m_indentLevel--;
ada << getIndent() << "end record;" << m_endl << m_endl;
if (haveAttrs) {
bool seen_static_attr = false;
for (UMLAttribute *at = atl.first(); at; at = atl.next()) {
if (! at->getStatic())
continue;
if (! seen_static_attr) {
ada << getIndent() << "-- Static attributes:" << m_endl;
seen_static_attr = true;
}
ada << getIndent();
if (at->getVisibility() == Uml::Visibility::Private)
ada << "-- Private: ";
ada << cleanName(at->getName()) << " : " << at->getTypeName();
if (at && at->getInitialValue().latin1() && ! at->getInitialValue().isEmpty())
ada << " := " << at->getInitialValue();
ada << ";" << m_endl;
}
if (seen_static_attr)
ada << m_endl;
}
// Generate protected operations.
UMLOperationList opprot;
opprot.setAutoDelete(false);
for (op = opl.first(); op; op = opl.next()) {
if (op->getVisibility() == Uml::Visibility::Protected)
opprot.append(op);
}
if (forceSections() || opprot.count())
ada << getIndent() << "-- Protected methods:" << m_endl << m_endl;
for (op = opprot.first(); op; op = opprot.next())
writeOperation(op, ada);
// Generate private operations.
// These are currently only generated as comments in the private part
// of the spec.
// Once umbrello supports the merging of automatically generated and
// hand written code sections, private operations should be generated
// into the package body.
UMLOperationList oppriv;
oppriv.setAutoDelete(false);
for (op = opl.first(); op; op = opl.next()) {
const Uml::Visibility::Value vis = op->getVisibility();
if (vis == Uml::Visibility::Private ||
vis == Uml::Visibility::Implementation)
oppriv.append(op);
}
if (forceSections() || oppriv.count())
ada << getIndent() << "-- Private methods:" << m_endl << m_endl;
for (op = oppriv.first(); op; op = oppriv.next())
writeOperation(op, ada, true);
m_indentLevel--;
ada << getIndent() << "end " << pkg << ";" << m_endl << m_endl;
file.close();
emit codeGenerated(c, true);
}
void AdaWriter::writeOperation(UMLOperation *op, TQTextStream &ada, bool is_comment) {
UMLAttributeList atl = op->getParmList();
TQString rettype = op->getTypeName();
bool use_procedure = (rettype.isEmpty() || rettype == "void");
ada << getIndent();
if (is_comment)
ada << "-- ";
if (use_procedure)
ada << "procedure ";
else
ada << "function ";
ada << cleanName(op->getName()) << " ";
if (! (op->getStatic() && atl.count() == 0))
ada << "(";
UMLClassifier *parentClassifier = static_cast<UMLClassifier*>(op->getUMLPackage());
if (! op->getStatic()) {
ada << "Self : access " << className(parentClassifier);
if (atl.count())
ada << ";" << m_endl;
}
if (atl.count()) {
uint i = 0;
m_indentLevel++;
for (UMLAttribute *at = atl.first(); at; at = atl.next()) {
ada << getIndent();
if (is_comment)
ada << "-- ";
ada << cleanName(at->getName()) << " : ";
Uml::Parameter_Direction pk = at->getParmKind();
if (pk == Uml::pd_Out)
ada << "out ";
else if (pk == Uml::pd_InOut)
ada << "in out ";
else
ada << "in ";
ada << at->getTypeName();
if (! at->getInitialValue().isEmpty())
ada << " := " << at->getInitialValue();
if (++i < atl.count()) //FIXME gcc warning
ada << ";" << m_endl;
}
m_indentLevel--;
}
if (! (op->getStatic() && atl.count() == 0))
ada << ")";
if (! use_procedure)
ada << " return " << rettype;
if (op->getAbstract())
ada << " is abstract";
ada << ";" << m_endl << m_endl;
}
TQStringList AdaWriter::defaultDatatypes() {
TQStringList l;
l.append("Boolean");
l.append("Character");
l.append("Positive");
l.append("Natural");
l.append("Integer");
l.append("Short_Integer");
l.append("Long_Integer");
l.append("Float");
l.append("Long_Float");
l.append("Duration");
l.append("String");
return l;
}
/**
* Check whether the given string is a reserved word for the
* language of this code generator
*
* @param rPossiblyReservedKeyword The string to check.
*/
bool AdaWriter::isReservedKeyword(const TQString & rPossiblyReservedKeyword) {
const TQStringList keywords = reservedKeywords();
TQStringList::ConstIterator it;
for (it = keywords.begin(); it != keywords.end(); ++it)
if ((*it).lower() == rPossiblyReservedKeyword.lower())
return true;
return false;
}
/**
* get list of reserved keywords
*/
const TQStringList AdaWriter::reservedKeywords() const {
static TQStringList keywords;
if ( keywords.isEmpty() ) {
keywords.append( "abort" );
keywords.append( "abs" );
keywords.append( "abstract" );
keywords.append( "accept" );
keywords.append( "access" );
keywords.append( "aliased" );
keywords.append( "all" );
keywords.append( "and" );
keywords.append( "Argument_Error" );
keywords.append( "array" );
keywords.append( "Assert_Failure" );
keywords.append( "at" );
keywords.append( "begin" );
keywords.append( "body" );
keywords.append( "Boolean" );
keywords.append( "case" );
keywords.append( "Character" );
keywords.append( "constant" );
keywords.append( "Constraint_Error" );
keywords.append( "Conversion_Error" );
keywords.append( "Data_Error" );
keywords.append( "declare" );
keywords.append( "delay" );
keywords.append( "delta" );
keywords.append( "Dereference_Error" );
keywords.append( "Device_Error" );
keywords.append( "digits" );
keywords.append( "do" );
keywords.append( "Duration" );
keywords.append( "else" );
keywords.append( "elsif" );
keywords.append( "end" );
keywords.append( "End_Error" );
keywords.append( "entry" );
keywords.append( "exception" );
keywords.append( "exit" );
keywords.append( "false" );
keywords.append( "Float" );
keywords.append( "for" );
keywords.append( "function" );
keywords.append( "generic" );
keywords.append( "goto" );
keywords.append( "if" );
keywords.append( "in" );
keywords.append( "Index_Error" );
keywords.append( "Integer" );
keywords.append( "is" );
keywords.append( "Layout_Error" );
keywords.append( "Length_Error" );
keywords.append( "limited" );
keywords.append( "Long_Float" );
keywords.append( "Long_Integer" );
keywords.append( "Long_Long_Float" );
keywords.append( "Long_Long_Integer" );
keywords.append( "loop" );
keywords.append( "mod" );
keywords.append( "Mode_Error" );
keywords.append( "Name_Error" );
keywords.append( "Natural" );
keywords.append( "new" );
keywords.append( "not" );
keywords.append( "null" );
keywords.append( "of" );
keywords.append( "or" );
keywords.append( "others" );
keywords.append( "out" );
keywords.append( "package" );
keywords.append( "Pattern_Error" );
keywords.append( "Picture_Error" );
keywords.append( "Pointer_Error" );
keywords.append( "Positive" );
keywords.append( "pragma" );
keywords.append( "private" );
keywords.append( "procedure" );
keywords.append( "Program_Error" );
keywords.append( "protected" );
keywords.append( "raise" );
keywords.append( "range" );
keywords.append( "record" );
keywords.append( "rem" );
keywords.append( "renames" );
keywords.append( "requeue" );
keywords.append( "return" );
keywords.append( "reverse" );
keywords.append( "select" );
keywords.append( "separate" );
keywords.append( "Short_Float" );
keywords.append( "Short_Integer" );
keywords.append( "Short_Short_Float" );
keywords.append( "Short_Short_Integer" );
keywords.append( "Status_Error" );
keywords.append( "Storage_Error" );
keywords.append( "String" );
keywords.append( "subtype" );
keywords.append( "Tag_Error" );
keywords.append( "tagged" );
keywords.append( "task" );
keywords.append( "Tasking_Error" );
keywords.append( "terminate" );
keywords.append( "Terminator_Error" );
keywords.append( "then" );
keywords.append( "Time_Error" );
keywords.append( "Translation_Error" );
keywords.append( "true" );
keywords.append( "type" );
keywords.append( "until" );
keywords.append( "Update_Error" );
keywords.append( "use" );
keywords.append( "Use_Error" );
keywords.append( "when" );
keywords.append( "while" );
keywords.append( "Wide_Character" );
keywords.append( "Wide_String" );
keywords.append( "with" );
keywords.append( "xor" );
}
return keywords;
}
#include "adawriter.moc"
View Git Blame Copy Permalink