From 579eac3923e14b76a880aab07d8bf3d5bcfdb850 Mon Sep 17 00:00:00 2001 From: cas Date: Fri, 22 Oct 1999 18:05:40 +0000 Subject: [PATCH] Initial revision --- src/CPPExt/CPPExt.cxx | 996 ++++++++++++++++++++++++ src/CPPExt/CPPExt.hxx | 188 +++++ src/CPPExt/CPPExt_Alias.cxx | 78 ++ src/CPPExt/CPPExt_Define.hxx | 101 +++ src/CPPExt/CPPExt_Enum.cxx | 92 +++ src/CPPExt/CPPExt_Exception.cxx | 148 ++++ src/CPPExt/CPPExt_MPV.cxx | 395 ++++++++++ src/CPPExt/CPPExt_Package.cxx | 286 +++++++ src/CPPExt/CPPExt_PersistentCSFDB.cxx | 597 ++++++++++++++ src/CPPExt/CPPExt_PersistentOBJS.cxx | 1024 +++++++++++++++++++++++++ src/CPPExt/CPPExt_PersistentOBJY.cxx | 987 ++++++++++++++++++++++++ src/CPPExt/CPPExt_Pointer.cxx | 43 ++ src/CPPExt/CPPExt_Standard.edl | 334 ++++++++ src/CPPExt/CPPExt_Storable.cxx | 569 ++++++++++++++ src/CPPExt/CPPExt_Template.edl | 874 +++++++++++++++++++++ src/CPPExt/CPPExt_TemplateCSFDB.edl | 243 ++++++ src/CPPExt/CPPExt_TemplateOBJS.edl | 426 ++++++++++ src/CPPExt/CPPExt_TemplateOBJY.edl | 287 +++++++ src/CPPExt/CPPExt_Transient.cxx | 431 +++++++++++ src/CPPExt/FILES | 20 + 20 files changed, 8119 insertions(+) create mode 100755 src/CPPExt/CPPExt.cxx create mode 100755 src/CPPExt/CPPExt.hxx create mode 100755 src/CPPExt/CPPExt_Alias.cxx create mode 100755 src/CPPExt/CPPExt_Define.hxx create mode 100755 src/CPPExt/CPPExt_Enum.cxx create mode 100755 src/CPPExt/CPPExt_Exception.cxx create mode 100755 src/CPPExt/CPPExt_MPV.cxx create mode 100755 src/CPPExt/CPPExt_Package.cxx create mode 100755 src/CPPExt/CPPExt_PersistentCSFDB.cxx create mode 100755 src/CPPExt/CPPExt_PersistentOBJS.cxx create mode 100755 src/CPPExt/CPPExt_PersistentOBJY.cxx create mode 100755 src/CPPExt/CPPExt_Pointer.cxx create mode 100755 src/CPPExt/CPPExt_Standard.edl create mode 100755 src/CPPExt/CPPExt_Storable.cxx create mode 100755 src/CPPExt/CPPExt_Template.edl create mode 100755 src/CPPExt/CPPExt_TemplateCSFDB.edl create mode 100755 src/CPPExt/CPPExt_TemplateOBJS.edl create mode 100755 src/CPPExt/CPPExt_TemplateOBJY.edl create mode 100755 src/CPPExt/CPPExt_Transient.cxx create mode 100755 src/CPPExt/FILES diff --git a/src/CPPExt/CPPExt.cxx b/src/CPPExt/CPPExt.cxx new file mode 100755 index 0000000..0d0bec6 --- /dev/null +++ b/src/CPPExt/CPPExt.cxx @@ -0,0 +1,996 @@ +// CLE : Extracteur C++ pour CAS.CADE +// Matra-Datavision 1995 +// +// 10/1995 +// +#include +#include +#include +#include + +// Standard Extractor API : list the EDL files used by this program +// +Handle(TColStd_HSequenceOfHAsciiString) CPP_TemplatesUsed() +{ + Handle(TColStd_HSequenceOfHAsciiString) result = new TColStd_HSequenceOfHAsciiString; + + result->Append(new TCollection_HAsciiString("CPPExt_Template.edl")); + result->Append(new TCollection_HAsciiString("CPPExt_TemplateOBJY.edl")); + result->Append(new TCollection_HAsciiString("CPPExt_TemplateCSFDB.edl")); + result->Append(new TCollection_HAsciiString("CPPExt_TemplateOBJS.edl")); + + return result; +} + + +Handle(EDL_API)& CPP_LoadTemplate(const Handle(TColStd_HSequenceOfHAsciiString)& edlsfullpath, + const Handle(TCollection_HAsciiString)& outdir, + const Standard_CString DBMS) +{ + static Handle(EDL_API) api = new EDL_API; + static Standard_Boolean alreadyLoaded = Standard_False; + + api->ClearVariables(); + + if (!alreadyLoaded) { + alreadyLoaded = Standard_True; + + for(Standard_Integer i = 1; i <= edlsfullpath->Length(); i++) { + api->AddIncludeDirectory(edlsfullpath->Value(i)->ToCString()); + } + + if (api->Execute("CPPExt_Template.edl") != EDL_NORMAL) { + ErrorMsg << "CPPExt" << "unable to load : CPPExt_Template.edl" << endm; + Standard_NoSuchObject::Raise(); + } + if (api->Execute("CPPExt_TemplateOBJY.edl") != EDL_NORMAL) { + ErrorMsg << "CPPExt" << "unable to load : CPPExt_TemplateOBJY.edl" << endm; + Standard_NoSuchObject::Raise(); + } + if (api->Execute("CPPExt_TemplateCSFDB.edl") != EDL_NORMAL) { + ErrorMsg << "CPPExt" << "unable to load : CPPExt_TemplateCSFDB.edl" << endm; + Standard_NoSuchObject::Raise(); + } + if (api->Execute("CPPExt_TemplateOBJS.edl") != EDL_NORMAL) { + ErrorMsg << "CPPExt" << "unable to load : CPPExt_TemplateOBJS.edl" << endm; + Standard_NoSuchObject::Raise(); + } + } + + // full path of the destination directory + // + api->AddVariable(VFullPath,outdir->ToCString()); + + // templates for methods extraction + // + api->AddVariable(VMethodHeader,"MethodHeader"); + api->AddVariable(VConstructorHeader,"ConstructorHeader"); + + // DBMS extraction type + // + api->AddVariable("%CPPEXTDBMS",DBMS); + + return api; +} + +// write the content of a variable into a file +// +void CPP_WriteFile(const Handle(EDL_API)& api, + const Handle(TCollection_HAsciiString)& aFileName, + const Standard_CString var) +{ + // ...now we write the result + // + api->OpenFile("HTFile",aFileName->ToCString()); + api->WriteFile("HTFile",var); + api->CloseFile("HTFile"); +} + + +// sort the used types : +// +// FullList : all the used types +// List : the types that must have a full definition +// Incp : the types that only have to be declared +// +void CPP_UsedTypes(const Handle(MS_MetaSchema)& aMeta, + const Handle(MS_Common)& aCommon, + const Handle(TColStd_HSequenceOfHAsciiString)& List, + const Handle(TColStd_HSequenceOfHAsciiString)& Incp) +{ + if (aCommon->IsKind(STANDARD_TYPE(MS_Type))) { + if (aCommon->IsKind(STANDARD_TYPE(MS_Class))) { + Handle(MS_Class) aClass = *((Handle(MS_Class)*)&aCommon); + + MS::ClassUsedTypes(aMeta,aClass,List,Incp); + } + } +} + +// build a return, parameter or field type in c++ +// return a or a Handle_ +// +Handle(TCollection_HAsciiString) CPP_BuildType(const Handle(MS_MetaSchema)& aMeta, + const Handle(TCollection_HAsciiString)& aTypeName) +{ + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_Type) aType; + + if (aMeta->IsDefined(aTypeName)) { + aType = aMeta->GetType(aTypeName); + + if (aType->IsKind(STANDARD_TYPE(MS_Alias))) { + Handle(MS_Alias) analias = *((Handle(MS_Alias)*)&aType); + + aType = aMeta->GetType(analias->DeepType()); + } + + if (aType->IsKind(STANDARD_TYPE(MS_Class))) { + Handle(MS_Class) aClass; + + aClass = *((Handle(MS_Class)*)&aType); + + if (aClass->IsPersistent() || aClass->IsTransient()) { + result->AssignCat("Handle_"); + result->AssignCat(aTypeName); + } + else { + result->AssignCat(aTypeName); + } + } + else { + result->AssignCat(aTypeName); + } + } + else { + ErrorMsg << "CPPExt" << "type " << aType->FullName()->ToCString() << " not defined..." << endm; + Standard_NoSuchObject::Raise(); + } + + return result; +} + +// Build a c++ field +// +Handle(TCollection_HAsciiString) CPP_BuildField(const Handle(MS_MetaSchema)& aMeta, + const Handle(MS_Field)& aField) +{ + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_Type) aType; + Handle(TColStd_HSequenceOfInteger) dim; + Standard_Integer i; + + result->AssignCat(CPP_BuildType(aMeta,aField->TYpe())); + result->AssignCat(" "); + result->AssignCat(aField->Name()); + + dim = aField->Dimensions(); + + for (i = 1; i <= dim->Length(); i++) { + result->AssignCat("["); + result->AssignCat(new TCollection_HAsciiString(dim->Value(i))); + result->AssignCat("]"); + } + + result->AssignCat(";\n"); + + return result; +} + +// Build a parameter list for methods +// the output is in C++ +// +Handle(TCollection_HAsciiString) CPP_BuildParameterList(const Handle(MS_MetaSchema)& aMeta, + const Handle(MS_HArray1OfParam)& aSeq, + const Standard_Boolean withDefaultValue) +{ + Standard_Integer i; + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_Type) aType; + Handle(MS_Class) aClass; + + if(!aSeq.IsNull()) { + for (i = 1; i <= aSeq->Length(); i++) { + if (i > 1) { + result->AssignCat(","); + } + + if (!aSeq->Value(i)->IsOut()) { + result->AssignCat("const "); + } + + if (aMeta->IsDefined(aSeq->Value(i)->TypeName())) { + aType = aMeta->GetType(aSeq->Value(i)->TypeName()); + + if (aType->IsKind(STANDARD_TYPE(MS_Class))) { + aClass = *((Handle(MS_Class)*)&aType); + + if (aClass->IsPersistent() || aClass->IsTransient()) { + result->AssignCat("Handle("); + result->AssignCat(aSeq->Value(i)->TypeName()); + result->AssignCat(")& "); + result->AssignCat(aSeq->Value(i)->Name()); + } + else { + result->AssignCat(aSeq->Value(i)->TypeName()); + result->AssignCat("& "); + result->AssignCat(aSeq->Value(i)->Name()); + } + } // CLASS ^ + else if ((aType->IsKind(STANDARD_TYPE(MS_Imported)) || aType->IsKind(STANDARD_TYPE(MS_Pointer)) || aSeq->Value(i)->IsItem() || aSeq->Value(i)->IsOut()) && !(aType->IsKind(STANDARD_TYPE(MS_Alias)))) { + result->AssignCat(aSeq->Value(i)->TypeName()); + result->AssignCat("& "); + result->AssignCat(aSeq->Value(i)->Name()); + } + // WARNING : ALIASES + // + else if (aType->IsKind(STANDARD_TYPE(MS_Alias))) { + Handle(MS_Alias) analias = *((Handle(MS_Alias)*)&aType); + Handle(TCollection_HAsciiString) deeptype = analias->DeepType(); + + if (aMeta->IsDefined(deeptype)) { + Handle(MS_Type) dt = aMeta->GetType(deeptype); + + + if (dt->IsKind(STANDARD_TYPE(MS_Class))) { + aClass = *((Handle(MS_Class)*)&dt); + + if (aClass->IsPersistent() || aClass->IsTransient()) { + result->AssignCat("Handle("); + result->AssignCat(aSeq->Value(i)->TypeName()); + result->AssignCat(")& "); + result->AssignCat(aSeq->Value(i)->Name()); + } + else { + result->AssignCat(aSeq->Value(i)->TypeName()); + result->AssignCat("& "); + result->AssignCat(aSeq->Value(i)->Name()); + } + } + else if (dt->IsKind(STANDARD_TYPE(MS_Imported)) || dt->IsKind(STANDARD_TYPE(MS_Pointer)) || aSeq->Value(i)->IsItem() || aSeq->Value(i)->IsOut()) { + result->AssignCat(aSeq->Value(i)->TypeName()); + result->AssignCat("& "); + result->AssignCat(aSeq->Value(i)->Name()); + } + else { + result->AssignCat(aSeq->Value(i)->TypeName()); + if (aSeq->Value(i)->IsOut()) { + result->AssignCat("& "); + } + else { + result->AssignCat(" "); + } + result->AssignCat(aSeq->Value(i)->Name()); + } + } + else { + ErrorMsg << "CPPExt" << "incomplete alias deep type in method's parameter..." << endm; + Standard_NoSuchObject::Raise(); + } + } + else { + result->AssignCat(aSeq->Value(i)->TypeName()); + if (aSeq->Value(i)->IsOut()) { + result->AssignCat("& "); + } + else { + result->AssignCat(" "); + } + result->AssignCat(aSeq->Value(i)->Name()); + } + } + else { + result->AssignCat(aSeq->Value(i)->TypeName()); + result->AssignCat("& "); + result->AssignCat(aSeq->Value(i)->Name()); + } + + if (aSeq->Value(i)->GetValueType() != MS_NONE && withDefaultValue) { + MS_ParamWithValue* pwv = (MS_ParamWithValue*)aSeq->Value(i).operator->(); + result->AssignCat(" = "); + result->AssignCat(pwv->GetValue()); + } + } + } + return result; +} + +// build a c++ declaration method +// the result is in the EDL variable VMethod +// +// template used : +// +// MethodTemplateDef +// ConstructorTemplateDef +// MethodTemplateDec +// ConstructorTemplateDec +// InlineMethodTemplateDec +// +// the EDL variables : +// VMethodHeader : must contains the name of the template used for +// methods construction +// VConstructorHeader : must contains the name of the template used for +// constructors construction +// +void CPP_BuildMethod(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Method)& m, + const Handle(TCollection_HAsciiString)& methodName, + const Standard_Boolean forDeclaration = Standard_True) +{ + Handle(MS_InstMet) im; + Handle(MS_ClassMet) cm; + Handle(MS_Construc) ct; + Handle(MS_Param) retType; + + Handle(TCollection_HAsciiString) MetTemplate, + ConTemplate; + + Standard_Boolean InlineMethod; + + MetTemplate = api->GetVariableValue(VMethodHeader); + ConTemplate = api->GetVariableValue(VConstructorHeader); + + // here we process all the common attributes of methods + // + api->AddVariable(VMethodName,methodName->ToCString()); + api->AddVariable(VVirtual,""); + + // it s inline method ? + // + if (m->IsInline()) { + api->AddVariable(VIsInline,"yes"); + InlineMethod = Standard_True; + } + else { + InlineMethod = Standard_False; + api->AddVariable(VIsInline,"no"); + } + + // it s returning const ? + // + if (m->IsConstReturn()) { + api->AddVariable(VRetSpec,"const"); + } + else { + api->AddVariable(VRetSpec,""); + } + + // it s returning & ? + // + if (m->IsRefReturn()) { + api->AddVariable(VAnd,"&"); + } + else { + api->AddVariable(VAnd,""); + } + + api->AddVariable(VArgument,CPP_BuildParameterList(aMeta,m->Params(),forDeclaration)->ToCString()); + + // it s returning a type or void + // + retType = m->Returns(); + + if (!retType.IsNull()) { + api->AddVariable(VReturn,CPP_BuildType(aMeta,retType->TypeName())->ToCString()); + } + else { + api->AddVariable(VReturn,"void"); + } + + // now the specials attributes + // + // instance methods + // + if (m->IsKind(STANDARD_TYPE(MS_InstMet))) { + im = *((Handle(MS_InstMet)*)&m); + + api->AddVariable(VIsCreateMethod,"no"); + + if (!im->IsDeferred() || !forDeclaration) { + if (!im->IsStatic() && forDeclaration) { + api->AddVariable(VVirtual,"virtual"); + } + + if (im->IsConst()) { + api->AddVariable(VMetSpec,"const"); + } + else { + api->AddVariable(VMetSpec,""); + } + } + else if (forDeclaration) { + api->AddVariable(VVirtual,"virtual"); + + if (im->IsConst()) { + api->AddVariable(VMetSpec,"const = 0"); + } + else { + api->AddVariable(VMetSpec," = 0"); + } + } + + api->Apply(VMethod,MetTemplate->ToCString()); + + if (InlineMethod) { + api->Apply(VMethod,"InlineMethodTemplateDec"); + } + } + // + // class methods + // + else if (m->IsKind(STANDARD_TYPE(MS_ClassMet))) { + api->AddVariable(VIsCreateMethod,"no"); + api->AddVariable(VMetSpec,""); + if (forDeclaration) { + api->AddVariable(VVirtual,"static"); + } + api->Apply(VMethod,MetTemplate->ToCString()); + + if (InlineMethod) { + api->Apply(VMethod,"InlineMethodTemplateDec"); + } + } + // + // constructors + // + else if (m->IsKind(STANDARD_TYPE(MS_Construc))) { + api->AddVariable(VIsCreateMethod,"yes"); + api->Apply(VMethod,ConTemplate->ToCString()); + + if (InlineMethod) { + api->Apply(VMethod,"InlineMethodTemplateDec"); + } + } + // + // package methods + // + else if (m->IsKind(STANDARD_TYPE(MS_ExternMet))) { + api->AddVariable(VIsCreateMethod,"no"); + api->AddVariable(VMetSpec,""); + if (forDeclaration) { + api->AddVariable(VVirtual,"static"); + } + + api->Apply(VMethod,MetTemplate->ToCString()); + if (InlineMethod) { + api->Apply(VMethod,"InlineMethodTemplateDec"); + } + } +} + +// build an INLINE "function call" body method for "C++: function call" comment +// +Handle(TCollection_HAsciiString) CPP_BuildFunctionCall(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_MemberMet)& method, + const Standard_Boolean isInlineMode) +{ + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_Param) retType; + Standard_Integer i; + Handle(MS_Type) type; + Standard_CString calltype; + + type = aMeta->GetType(method->Class()); + + if (type->IsKind(STANDARD_TYPE(MS_StdClass))) { + Handle(MS_StdClass) stdclass = *((Handle(MS_StdClass)*)&type); + + if (stdclass->IsTransient() || stdclass->IsPersistent()) { + calltype = "->"; + } + else { + calltype = "."; + } + } + + // for inline function mode + // + if (isInlineMode) { + result->AssignCat("inline "); + } + + // it s returning a type or void + // + retType = method->Returns(); + + if (!retType.IsNull()) { + if (method->IsConstReturn()) { + result->AssignCat("const "); + } + + result->AssignCat(CPP_BuildType(aMeta,retType->TypeName())); + + if (method->IsRefReturn()) { + result->AssignCat("& "); + } + } + else { + result->AssignCat( "void"); + } + + result->AssignCat(" "); + result->AssignCat(method->Name()); + result->AssignCat("("); + + if (method->IsKind(STANDARD_TYPE(MS_InstMet))) { + Handle(MS_InstMet) im = *((Handle(MS_InstMet)*)&method); + + // if immutable + // + if (im->IsConst()) { + result->AssignCat("const "); + } + } + + result->AssignCat(CPP_BuildType(aMeta,method->Class())); + result->AssignCat("& me"); + + if (!method->Params().IsNull()) { + result->AssignCat(","); + result->AssignCat(CPP_BuildParameterList(aMeta,method->Params(),Standard_True)); + } + + + result->AssignCat(") {\n"); + + if (!retType.IsNull()) { + result->AssignCat(" return"); + } + + result->AssignCat(" me"); + result->AssignCat(calltype); + result->AssignCat(method->Name()); + result->AssignCat("("); + + if (!method->Params().IsNull()) { + result->AssignCat(method->Params()->Value(1)->Name()); + for (i = 2; i <= method->Params()->Length(); i++) { + result->AssignCat(","); + result->AssignCat(method->Params()->Value(i)->Name()); + } + } + result->AssignCat(");\n"); + + result->AssignCat("}\n\n"); + + return result; +} + +// build a method from a "---C++: alias" comment +// +Handle(TCollection_HAsciiString) CPP_BuildAliasMethod(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_MemberMet)& method) +{ + Handle(TCollection_HAsciiString) result; + + if (!method->IsDestructor() && !method->IsFunctionCall()) { + result = new TCollection_HAsciiString(method->IsAlias()); + } + else { + result = new TCollection_HAsciiString("~"); + result->AssignCat(method->Class()); + result->AssignCat("()"); + } + // alias is kind : "void *new(size_t);" + // we only need to kill the quotes + // + if (method->IsQuotedAlias() && !method->IsDestructor()) { + result->Remove(1); + if (result->Value(result->Length()) == '"') { + result->Remove(result->Length()); + } + result->AssignCat("\n"); + } + // C++: function call + // + else if (method->IsFunctionCall()) { + result = CPP_BuildFunctionCall(aMeta,api,method,Standard_True); // <-- Standard_True = inline mode + } + else { + Handle(TCollection_HAsciiString) body = new TCollection_HAsciiString; + Handle(MS_HArray1OfParam) aSeq = method->Params(); + Standard_Integer i; + + if (!method->IsDestructor()) { + CPP_BuildMethod(aMeta,api,method,result,Standard_False); + } + else { + api->AddVariable(VMethod,result->ToCString()); + } + + result = api->GetVariableValue(VMethod); + + if (!method->Returns().IsNull()) { + body->AssignCat("return "); + } + + body->AssignCat(method->Name()); + body->AssignCat("("); + + if(!aSeq.IsNull()) { + for (i = 1; i < aSeq->Length(); i++) { + body->AssignCat(aSeq->Value(i)->Name()); + body->AssignCat(","); + } + + body->AssignCat(aSeq->Value(aSeq->Length())->Name()); + } + body->AssignCat(");"); + + api->AddVariable(VMBody,body->ToCString()); + api->Apply(VMethod,"MethodTemplateDef"); + + result = api->GetVariableValue(VMethod); + } + + return result; +} + + +// Build the list of friends methods and set the result at the end of +// publics +// +Standard_Boolean CPP_SetFriendMethod(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(TColStd_HSequenceOfHAsciiString)& FriendMets, + const Handle(TCollection_HAsciiString)& publics) +{ + if (publics.IsNull()) return Standard_False; + + Handle(MS_Method) friendmethod; + Standard_Integer i; + Standard_Boolean result = Standard_True; + Handle(TCollection_HAsciiString) aname, + oldclass = api->GetVariableValue(VClass); + + // templates for methods extraction + // + api->AddVariable(VMethodHeader,"ExternalMethodHeader"); + api->AddVariable(VConstructorHeader,"ExternalConstructorHeader"); + + for (i = 1; i <= FriendMets->Length(); i++) { + friendmethod.Nullify(); + friendmethod = MS::GetMethodFromFriendName(aMeta,FriendMets->Value(i)); + + if (!friendmethod.IsNull()) { + aname = FriendMets->Value(i)->Token(":"); + api->AddVariable(VClass,aname->ToCString()); + publics->AssignCat("friend "); + CPP_BuildMethod(aMeta,api,friendmethod,friendmethod->Name(),Standard_False); + api->Apply(VMethod,"MethodTemplateDec"); + publics->AssignCat(api->GetVariableValue(VMethod)); + } + else { + result = Standard_False; + } + } + + // templates for methods extraction + // + api->AddVariable(VMethodHeader,"MethodHeader"); + api->AddVariable(VConstructorHeader,"ConstructorHeader"); + api->AddVariable(VClass,oldclass->ToCString()); + + return result; +} + +// create the defines and the undefines that are around the include of +// a generic .lxx +// ex. : +// #define ItemHArray1 Quantity_Color +// #define ItemHArray1_hxx +// #define TheArray1 Quantity_Array1OfColor +// #define TheArray1_hxx +// #define TCollection_HArray1 Quantity_HArray1OfColor +// #define TCollection_HArray1_hxx +// #include +// #undef ItemHArray1 +// #undef ItemHArray1_hxx +// #undef TheArray1 +// #undef TheArray1_hxx +// #undef TCollection_HArray1 +// #undef TCollection_HArray1_hxx +// +void CPP_GenericDefine(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_InstClass)& aCreator, + const Standard_CString VARDefine, + const Standard_CString VARUndefine, + const Standard_Boolean handleUsed) +{ + Handle(MS_GenClass) aGenClass = Handle(MS_GenClass)::DownCast(aMeta->GetType(aCreator->GenClass())); + Handle(TColStd_HSequenceOfHAsciiString) theGenTypes = aCreator->GenTypes(); + Handle(TCollection_HAsciiString) publics = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) protecteds = new TCollection_HAsciiString; + Standard_Integer i, + itemLength; + Handle(MS_HSequenceOfGenType) realGentypes = aGenClass->GenTypes(); + + // we need this length because for item we must call + // CPP_BuildType and for nested class name we dont need. + // + itemLength = aGenClass->GenTypes()->Length(); + + for (i = 1; i <= theGenTypes->Length(); i++) { + if (!aGenClass->FullName()->IsSameString(theGenTypes->Value(i))) { + api->AddVariable(VDName,theGenTypes->Value(i)->ToCString()); + + // real name or Handle_name + // + if (i <= itemLength) { + if (!realGentypes->Value(i)->TYpeName().IsNull()) { + if (aMeta->IsDefined(realGentypes->Value(i)->TYpeName())) { + Handle(MS_Type) t = aMeta->GetType(realGentypes->Value(i)->TYpeName()); + + if (t->IsKind(STANDARD_TYPE(MS_Class))) { + Handle(MS_Class) c = *((Handle(MS_Class)*)&t); + + // if the items constraint is handled, the item is not the handle, + // like in other cases, but the type himself. + // + // ex. : the item : 'i' as transient + // will be defined as #define i class + // the item : 'i' as any + // will be defined as #define i Handle_Class + // + if (c->IsPersistent() || c->IsTransient()) { + api->AddVariable(VDValue,aCreator->InstTypes()->Value(i)->ToCString()); + api->Apply(VARDefine,"ItemConstraintHandle"); + api->Apply(VARUndefine,"ItemConstraintHandleUndef"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + else { + api->AddVariable(VDValue,CPP_BuildType(aMeta,aCreator->InstTypes()->Value(i))->ToCString()); + } + } + } + } + else { + api->AddVariable(VDValue,CPP_BuildType(aMeta,aCreator->InstTypes()->Value(i))->ToCString()); + } + api->AddVariable("%DBaseValue",aCreator->InstTypes()->Value(i)->ToCString()); + } + // real name + // + else { + api->AddVariable(VDValue,aCreator->InstTypes()->Value(i)->ToCString()); + api->AddVariable("%DBaseValue",aCreator->InstTypes()->Value(i)->ToCString()); + } + + api->Apply(VARDefine,"ItemDefine"); + api->Apply(VARUndefine,"ItemUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + } + + for (i = itemLength + 1; i <= theGenTypes->Length(); i++) { + if (!aGenClass->FullName()->IsSameString(theGenTypes->Value(i))) { + Handle(TCollection_HAsciiString) realName = CPP_BuildType(aMeta,aCreator->InstTypes()->Value(i)); + + if (!realName->IsSameString(aCreator->InstTypes()->Value(i))) { + api->AddVariable(VDName,theGenTypes->Value(i)->ToCString()); + api->AddVariable(VDValue,aCreator->InstTypes()->Value(i)->ToCString()); + api->Apply(VARDefine,"ItemHandleDefine"); + api->Apply(VARUndefine,"ItemHandleUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + } + } + + api->AddVariable(VDName,aGenClass->FullName()->ToCString()); + api->AddVariable(VDValue,aCreator->FullName()->ToCString()); + api->AddVariable("%DBaseValue",aCreator->FullName()->ToCString()); + + api->Apply(VARDefine,"ItemDefine"); + api->Apply(VARUndefine,"ItemUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + + // #define TCollection_HSequence_Type_() TColStd_HSequenceOfTransient_Type_() + // #define Handle_TCollection_HSequence Handle_TColStd_HSequenceOfTransient + // + if (aGenClass->IsTransient() || aGenClass->IsPersistent()) { + api->AddVariable(VDName,aGenClass->FullName()->ToCString()); + api->AddVariable(VDValue,aCreator->FullName()->ToCString()); + api->Apply(VARDefine,"ItemHandleDefine"); + api->Apply(VARUndefine,"ItemHandleUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + + api->AddVariable(VARDefine,publics->ToCString()); + api->AddVariable(VARUndefine,protecteds->ToCString()); +} + + + +void CPP_ClassTypeMgt(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Standard_CString var) +{ + Handle(TColStd_HSequenceOfHAsciiString) inh = aClass->GetFullInheritsNames(); + Standard_Integer i; + Handle(TCollection_HAsciiString) ichar; + Handle(TCollection_HAsciiString) str = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) str1 = new TCollection_HAsciiString; + + for (i = 1; i <= inh->Length(); i++) { + ichar = new TCollection_HAsciiString(i); + + api->AddVariable(VNb,ichar->ToCString()); + api->Apply(VNb,"TypeMgtAncestorType"); + + str1->AssignCat(api->GetVariableValue(VNb)); + str1->AssignCat(","); + + api->AddVariable(VAncestors,inh->Value(i)->ToCString()); + api->Apply(VInherits,"TypeMgtAncestor"); + str->AssignCat(api->GetVariableValue(VInherits)); + } + + api->AddVariable(VInherits,str->ToCString()); + api->AddVariable(VAncestors,str1->ToCString()); + api->AddVariable(VClass,aClass->FullName()->ToCString()); + + api->Apply(var,"TypeMgt"); +} + + +// Standard extractor API : launch the extraction of C++ files +// from the type +// +void CPP_Extract(const Handle(MS_MetaSchema)& aMeta, + const Handle(TCollection_HAsciiString)& aName, + const Handle(TColStd_HSequenceOfHAsciiString)& edlsfullpath, + const Handle(TCollection_HAsciiString)& outdir, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile, + const Standard_CString DBMS) +{ + Handle(MS_Type) srcType; + Handle(MS_Package) srcPackage; + + + // before begining, we look if the entity has something to extract... + // + if (aMeta->IsDefined(aName)) { + srcType = aMeta->GetType(aName); + } + else if (aMeta->IsPackage(aName)) { + srcPackage = aMeta->GetPackage(aName); + } + else { + ErrorMsg << "CPPExt" << aName->ToCString() << " not defined..." << endm; + Standard_NoSuchObject::Raise(); + } + + // ... and we load the templates + // + Handle(EDL_API) api; + + // Package Extraction + // + if (!srcPackage.IsNull()) { + if (srcPackage->Methods()->Length() > 0) { + api = CPP_LoadTemplate(edlsfullpath,outdir,DBMS); + CPP_Package(aMeta,api,srcPackage,outfile); + } + else { + return; + } + } + // Extraction of Classes + // + else if (srcType->IsKind(STANDARD_TYPE(MS_StdClass)) && !srcType->IsKind(STANDARD_TYPE(MS_GenClass)) && !srcType->IsKind(STANDARD_TYPE(MS_InstClass))) { + Handle(MS_StdClass) aClass = *((Handle(MS_StdClass)*)&srcType); + + if (aClass->Incomplete()) { + ErrorMsg << "CPPExt" << aName->ToCString() << " not complete..." << endm; + Standard_NoSuchObject::Raise(); + } + + if (aClass->IsGeneric()) { + return; + } + + api = CPP_LoadTemplate(edlsfullpath,outdir,DBMS); + + // Transient classes + // + if (aClass->IsTransient() && !aName->IsSameString(MS::GetTransientRootName())) { + Handle(TCollection_HAsciiString) aHandleFile = new TCollection_HAsciiString(outdir); + + aHandleFile->AssignCat("Handle_"); + aHandleFile->AssignCat(aName); + aHandleFile->AssignCat(".hxx"); + + outfile->Append(aHandleFile); + + if (aClass->GetInheritsNames()->Length() == 0) { + ErrorMsg << "CPPExt" << "incomplete metaschema..." << endm; + Standard_NoSuchObject::Raise(); + } + + CPP_TransientHandle(api,aName,aClass->GetInheritsNames()->Value(1),aHandleFile); + + if (aClass->IsKind(STANDARD_TYPE(MS_Error))) { + CPP_ExceptionClass(aMeta,api,aClass,outfile); + } + else { + CPP_TransientClass(aMeta,api,aClass,outfile); + } + } + // Persistent classes + // + else if (aClass->IsPersistent() && !aName->IsSameString(MS::GetPersistentRootName())) { + Handle(TCollection_HAsciiString) aHandleFile = new TCollection_HAsciiString(outdir); + + aHandleFile->AssignCat("Handle_"); + aHandleFile->AssignCat(aName); + aHandleFile->AssignCat(".hxx"); + + outfile->Append(aHandleFile); + + if (aClass->GetInheritsNames()->Length() == 0) { + ErrorMsg << "CPPExt" << "incomplete metaschema..." << endm; + Standard_NoSuchObject::Raise(); + } + + if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"OBJY")) { + CPP_PersistentHandleOBJY(api,aName,aClass->GetInheritsNames()->Value(1),aHandleFile); + CPP_PersistentClassOBJY(aMeta,api,aClass,outfile); + } + else if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"MEM")) { + } + else if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"OBJS")) { + CPP_PersistentHandleOBJS(api,aName,aClass->GetInheritsNames()->Value(1),aHandleFile); + CPP_PersistentClassOBJS(aMeta,api,aClass,outfile); + } + else if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"OO2")) { + } + else if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"CSFDB")) { + CPP_PersistentHandleCSFDB(api,aName,aClass->GetInheritsNames()->Value(1),aHandleFile); + CPP_PersistentClassCSFDB(aMeta,api,aClass,outfile); + } + } + // Storable classes + // + else if (aClass->IsStorable()) { + CPP_StorableClass(aMeta,api,aClass,outfile); + } + // MPV classes + // + else { + CPP_MPVClass(aMeta,api,aClass,outfile); + } + } + // Enumerations + // + else if (srcType->IsKind(STANDARD_TYPE(MS_Enum))) { + Handle(MS_Enum) anEnum = *((Handle(MS_Enum)*)&srcType); + + api = CPP_LoadTemplate(edlsfullpath,outdir,DBMS); + CPP_Enum(aMeta,api,anEnum,outfile); + } + // Aliases + // + else if (srcType->IsKind(STANDARD_TYPE(MS_Alias))) { + Handle(MS_Alias) anAlias = *((Handle(MS_Alias)*)&srcType); + + api = CPP_LoadTemplate(edlsfullpath,outdir,DBMS); + CPP_Alias(aMeta,api,anAlias,outfile); + } + else if (srcType->IsKind(STANDARD_TYPE(MS_Pointer))) { + Handle(MS_Pointer) aPointer = *((Handle(MS_Pointer)*)&srcType); + + api = CPP_LoadTemplate(edlsfullpath,outdir,DBMS); + CPP_Pointer(aMeta,api,aPointer,outfile); + } +} + diff --git a/src/CPPExt/CPPExt.hxx b/src/CPPExt/CPPExt.hxx new file mode 100755 index 0000000..2d57e9b --- /dev/null +++ b/src/CPPExt/CPPExt.hxx @@ -0,0 +1,188 @@ +#ifndef _CPPExt_HeaderFile +#define _CPPExt_HeaderFile +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#ifndef _Standard_Macro_HeaderFile +# include +#endif + +extern "C" { + + Standard_EXPORT Handle(TColStd_HSequenceOfHAsciiString) CPP_TemplatesUsed(); + + void Standard_EXPORT CPP_Extract(const Handle(MS_MetaSchema)& ams, + const Handle(TCollection_HAsciiString)& aname, + const Handle(TColStd_HSequenceOfHAsciiString)& edlsfullpath, + const Handle(TCollection_HAsciiString)& outdir, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile, + const Standard_CString); + +} + +Handle(TCollection_HAsciiString) CPP_BuildType(const Handle(MS_MetaSchema)&, + const Handle(TCollection_HAsciiString)&); + +void CPP_TransientHandle(const Handle(EDL_API)&, + const Handle(TCollection_HAsciiString)&, + const Handle(TCollection_HAsciiString)&, + const Handle(TCollection_HAsciiString)&); + + +void CPP_TransientClass(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)&, + const Handle(MS_Class)&, + const Handle(TColStd_HSequenceOfHAsciiString)&); + +void CPP_PersistentClassOBJY(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)&, + const Handle(MS_Class)&, + const Handle(TColStd_HSequenceOfHAsciiString)&); + +void CPP_PersistentHandleOBJY(const Handle(EDL_API)&, + const Handle(TCollection_HAsciiString)&, + const Handle(TCollection_HAsciiString)&, + const Handle(TCollection_HAsciiString)&); + +void CPP_PersistentClassCSFDB(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)&, + const Handle(MS_Class)&, + const Handle(TColStd_HSequenceOfHAsciiString)&); + +void CPP_PersistentHandleCSFDB(const Handle(EDL_API)&, + const Handle(TCollection_HAsciiString)&, + const Handle(TCollection_HAsciiString)&, + const Handle(TCollection_HAsciiString)&); + +void CPP_PersistentClassOBJS(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)&, + const Handle(MS_Class)&, + const Handle(TColStd_HSequenceOfHAsciiString)&); + +void CPP_PersistentHandleOBJS(const Handle(EDL_API)&, + const Handle(TCollection_HAsciiString)&, + const Handle(TCollection_HAsciiString)&, + const Handle(TCollection_HAsciiString)&); + +void CPP_ExceptionClass(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)&, + const Handle(MS_Class)&, + const Handle(TColStd_HSequenceOfHAsciiString)&); + +void CPP_MPVClass(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)&, + const Handle(MS_Class)&, + const Handle(TColStd_HSequenceOfHAsciiString)&); + +void CPP_StorableClass(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)&, + const Handle(MS_Class)&, + const Handle(TColStd_HSequenceOfHAsciiString)&); + +void CPP_Enum(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)&, + const Handle(MS_Enum)&, + const Handle(TColStd_HSequenceOfHAsciiString)&); + +void CPP_Alias(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)&, + const Handle(MS_Alias)&, + const Handle(TColStd_HSequenceOfHAsciiString)&); + +void CPP_Pointer(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)&, + const Handle(MS_Pointer)&, + const Handle(TColStd_HSequenceOfHAsciiString)&); + +void CPP_Package(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)&, + const Handle(MS_Package)&, + const Handle(TColStd_HSequenceOfHAsciiString)&); + +void CPP_BuildMethod(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Method)& m, + const Handle(TCollection_HAsciiString)& methodName, + const Standard_Boolean forDeclaration); + +// EDL variables +// +Standard_CString VClass = "%Class", + VTICIncludes = "%TICIncludes", + VInherits = "%Inherits", + VTICPublicmets = "%TICPublicmets", + VTICPublicfriends = "%TICPublicfriends", + VTICProtectedmets = "%TICProtectedmets", + VTICProtectedfields = "%TICProtectedfields", + VTICPrivatemets = "%TICPrivatemets", + VTICPrivatefriends = "%TICPrivatefriends", + VTICDefines = "%TICDefines", + VTICInlineIncludes = "%TICInlineIncludes", + VTICUndefines = "%TICUndefines", + VTICPrivatefields = "%TICPrivatefields", + VRetSpec = "%RetSpec", + VVirtual = "%Virtual", + VReturn = "%Return", + VAnd = "%And", + VMethodName = "%MethodName", + VArgument = "%Arguments", + VMetSpec = "%MetSpec", + VMethod = "%Method", + VMBody = "%MBody", + VDName = "%DName", + VDValue = "%DValue", + VIsInline = "%IsInline", + VIsCreateMethod = "%IsCreateMethod", + VIClass = "%IClass", + VSuffix = "%Suffix", + VCxxFile = "CxxFile", + VLxxFile = "LxxFile", + VInlineMethod = "%InlineMethod", + VoutClass = "%outClass", + VNb = "%Nb", + VValues = "%Values", + VSupplement = "%Supplement", + VTypeMgt = "%TypeMgt", + VMethods = "%Methods", + VAncestors = "%Ancestors", + VFullPath = "%FullPath", + VMethodHeader = "%MethodHeader", + VConstructorHeader = "%ConstructorHeader", + VTICSuppMethod = "%TICSuppMethod"; + +#endif diff --git a/src/CPPExt/CPPExt_Alias.cxx b/src/CPPExt/CPPExt_Alias.cxx new file mode 100755 index 0000000..e04fe62 --- /dev/null +++ b/src/CPPExt/CPPExt_Alias.cxx @@ -0,0 +1,78 @@ +// CLE +// +// 11/1995 +// +#include + +#include + +#include +#include +#include +#include +#include + +#include + +// Extraction of a transient class (inst or std) +// +void CPP_Alias(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Alias)& anAlias, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile) +{ + if (anAlias.IsNull()) return; + + Handle(TCollection_HAsciiString) aFileName, + realType; + Standard_Integer i; + Handle(MS_Type) theType,tmpType; + + api->AddVariable(VClass,anAlias->FullName()->ToCString()); + + realType = anAlias->Type(); + Handle(MS_Alias) alias = anAlias; + + while (aMeta->GetType(realType)->IsKind(STANDARD_TYPE(MS_Alias))) { + tmpType = aMeta->GetType(realType); + alias = *((Handle(MS_Alias)*)&tmpType); + realType = alias->Type(); + } + + theType = aMeta->GetType(realType); + + if (theType->IsKind(STANDARD_TYPE(MS_Class))) { + Handle(MS_Class) aclass = *((Handle(MS_Class)*)&theType); + + if (aclass->IsPersistent() || aclass->IsTransient()) { + Handle(TCollection_HAsciiString) str = new TCollection_HAsciiString("typedef "); + + str->AssignCat("Handle_"); + str->AssignCat(aclass->FullName()); + str->AssignCat(" Handle_"); + str->AssignCat(anAlias->FullName()); + str->AssignCat(";"); + + api->AddVariable("%HandleTypedef",str->ToCString()); + } + else { + api->AddVariable("%HandleTypedef",""); + } + } + else { + api->AddVariable("%HandleTypedef",""); + } + + api->AddVariable(VInherits,realType->ToCString()); + + api->Apply(VoutClass,"AliasHXX"); + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFileName->AssignCat(anAlias->FullName()); + aFileName->AssignCat(".hxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + outfile->Append(aFileName); +} + diff --git a/src/CPPExt/CPPExt_Define.hxx b/src/CPPExt/CPPExt_Define.hxx new file mode 100755 index 0000000..1c0eb68 --- /dev/null +++ b/src/CPPExt/CPPExt_Define.hxx @@ -0,0 +1,101 @@ +#ifndef _CPPExt_Define_HeaderFile +#define _CPPExt_Define_HeaderFile + +extern Standard_CString VClass, + VTICIncludes, + VInherits, + VTICPublicmets, + VTICPublicfriends, + VTICProtectedmets, + VTICProtectedfields, + VTICPrivatemets, + VTICPrivatefriends, + VTICDefines, + VTICInlineIncludes, + VTICUndefines, + VTICPrivatefields, + VTICSuppMethod, + VRetSpec, + VVirtual, + VReturn, + VAnd, + VMethodName, + VArgument, + VMetSpec, + VMethod, + VMBody, + VDName, + VDValue, + VIsInline, + VIsCreateMethod, + VIClass, + VSuffix, + VCxxFile, + VLxxFile, + VInlineMethod, + VoutClass, + VNb, + VValues, + VSupplement, + VTypeMgt, + VMethods, + VAncestors, + VFullPath, + VMethodHeader, + VConstructorHeader; + +Standard_Boolean CPP_SetFriendMethod(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(TColStd_HSequenceOfHAsciiString)& FriendMets, + const Handle(TCollection_HAsciiString)& publics); + + + +void CPP_WriteFile(const Handle(EDL_API)& api, + const Handle(TCollection_HAsciiString)& aFileName, + const Standard_CString var); + +void CPP_UsedTypes(const Handle(MS_MetaSchema)& aMeta, + const Handle(MS_Common)& aCommon, + const Handle(TColStd_HSequenceOfHAsciiString)& List, + const Handle(TColStd_HSequenceOfHAsciiString)& Incp); + +Handle(TCollection_HAsciiString) CPP_BuildType(const Handle(MS_MetaSchema)& aMeta, + const Handle(TCollection_HAsciiString)& aTypeName); + +Handle(TCollection_HAsciiString) CPP_BuildField(const Handle(MS_MetaSchema)& aMeta, + const Handle(MS_Field)& aField); + +class Handle(MS_HArray1OfParam); +Handle(TCollection_HAsciiString) CPP_BuildParameterList(const Handle(MS_MetaSchema)& aMeta, + const Handle(MS_HArray1OfParam)& aSeq, + const Standard_Boolean withDefaultValue); + +void CPP_BuildMethod(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Method)& m, + const Handle(TCollection_HAsciiString)& methodName, + const Standard_Boolean forDeclaration = Standard_True); + +Handle(TCollection_HAsciiString) CPP_BuildAliasMethod(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_MemberMet)& method); + +void CPP_GenericDefine(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_InstClass)& aCreator, + const Standard_CString VARDefine, + const Standard_CString VARUndefine, + const Standard_Boolean handleUsed); + +void CPP_PersistentHandleOBJY(const Handle(EDL_API)& api, + const Handle(TCollection_HAsciiString)& aClass, + const Handle(TCollection_HAsciiString)& aMother, + const Handle(TCollection_HAsciiString)& aFileName); + +void CPP_ClassTypeMgt(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Standard_CString var); + +#endif diff --git a/src/CPPExt/CPPExt_Enum.cxx b/src/CPPExt/CPPExt_Enum.cxx new file mode 100755 index 0000000..28c8c8e --- /dev/null +++ b/src/CPPExt/CPPExt_Enum.cxx @@ -0,0 +1,92 @@ +// CLE +// +// 11/1995 +// +#include + +#include + +#include +#include +#include +#include +#include + +#include + +// Extraction of a transient class (inst or std) +// +void CPP_Enum(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Enum)& anEnum, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile) +{ + if (anEnum.IsNull()) return; + + Handle(TColStd_HSequenceOfHAsciiString) EnumVal = anEnum->Enums(); + Handle(TCollection_HAsciiString) result, + aFileName; + Standard_Integer i; + + result = new TCollection_HAsciiString(EnumVal->Length()); + + api->AddVariable(VNb,result->ToCString()); + api->AddVariable(VClass,anEnum->FullName()->ToCString()); + + result->Clear(); + + i = 1; + + for (; i < EnumVal->Length(); i++) { + result->AssignCat(EnumVal->Value(i)); + result->AssignCat(",\n"); + } + + if (EnumVal->Length() > 0) { + result->AssignCat(EnumVal->Value(i)); + } + + api->AddVariable(VValues,result->ToCString()); + + api->Apply(VoutClass,"EnumHXX"); + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFileName->AssignCat(anEnum->FullName()); + aFileName->AssignCat(".hxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + outfile->Append(aFileName); +/* + result->Clear(); + + i = 1; + + for (; i < EnumVal->Length(); i++) { + result->AssignCat("\""); + result->AssignCat(EnumVal->Value(i)); + result->AssignCat("\",\n"); + } + + if (EnumVal->Length() > 0) { + result->AssignCat("\""); + result->AssignCat(EnumVal->Value(i)); + result->AssignCat("\""); + } + + api->AddVariable(VValues,result->ToCString()); + + api->Apply(VoutClass,"EnumCXX"); + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFileName->AssignCat(anEnum->FullName()); + aFileName->AssignCat("_0.cxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + outfile->Append(aFileName); +*/ +} + + + diff --git a/src/CPPExt/CPPExt_Exception.cxx b/src/CPPExt/CPPExt_Exception.cxx new file mode 100755 index 0000000..e1172e1 --- /dev/null +++ b/src/CPPExt/CPPExt_Exception.cxx @@ -0,0 +1,148 @@ +// CLE +// +// 10/1995 +// +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include +#include + +// Extraction of a transient .ixx .jxx and _0.cxx +// the supplement variable is used for non inline methods generated +// by the extractor like destructor (added to .ixx ans _0.cxx +// +void CPP_ExceptionDerivated(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile, + const Handle(TColStd_HSequenceOfHAsciiString)& inclist, + const Handle(TColStd_HSequenceOfHAsciiString)& supplement) +{ + Standard_Integer i; + Handle(TCollection_HAsciiString) aFileName = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + + api->AddVariable(VClass,aClass->FullName()->ToCString()); + api->Apply(VSupplement,"ExceptionMethod"); + + supplement->Append(api->GetVariableValue(VSupplement)); + + api->AddVariable(VClass,aClass->FullName()->ToCString()); + + api->AddVariable(VSuffix,"hxx"); + + CPP_ClassTypeMgt(aMeta,api,aClass,VTypeMgt); + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + + aFileName->AssignCat("_0.cxx"); + + // Supplement + // + for (i = 1; i <= supplement->Length(); i++) { + result->AssignCat(supplement->Value(i)); + } + + api->AddVariable(VSupplement,result->ToCString()); + + // Methods + // + result->Clear(); + + api->AddVariable(VIClass,MS::GetTransientRootName()->ToCString()); + api->Apply(VMethods,"DownCast"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->Apply(VMethods,"DynamicType"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->AddVariable(VIClass,aClass->GetInheritsNames()->Value(1)->ToCString()); + api->Apply(VMethods,"IsKind"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->Apply(VMethods,"FullEmptyHandleDestructorTemplate"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->AddVariable(VSuffix,"hxx"); + + api->AddVariable(VMethods,result->ToCString()); + api->Apply(VoutClass,"TransientIxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + + outfile->Append(aFileName); +} + + +// Extraction of a transient class (inst or std) +// +void CPP_ExceptionClass(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile) +{ + Handle(MS_Error) theClass = Handle(MS_Error)::DownCast(aClass); + + if (!theClass.IsNull()) { + Handle(TColStd_HSequenceOfHAsciiString) Supplement = new TColStd_HSequenceOfHAsciiString; + Handle(TColStd_HSequenceOfHAsciiString) FullList = new TColStd_HSequenceOfHAsciiString; + + api->AddVariable(VClass,aClass->FullName()->ToCString()); + api->AddVariable(VInherits,aClass->GetInheritsNames()->Value(1)->ToCString()); + + api->Apply(VoutClass,"ExceptionHXX"); + + // we write the .hxx of this class + // + Handle(TCollection_HAsciiString) aFile = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFile->AssignCat(theClass->FullName()); + aFile->AssignCat(".hxx"); + + CPP_WriteFile(api,aFile,VoutClass); + + outfile->Append(aFile); + + CPP_ExceptionDerivated(aMeta,api,aClass,outfile,FullList,Supplement); + } + else { + ErrorMsg << "CPPExt" << "CPP_TransientClass - the class is NULL..." << endm; + Standard_NoSuchObject::Raise(); + } +} + diff --git a/src/CPPExt/CPPExt_MPV.cxx b/src/CPPExt/CPPExt_MPV.cxx new file mode 100755 index 0000000..ad49379 --- /dev/null +++ b/src/CPPExt/CPPExt_MPV.cxx @@ -0,0 +1,395 @@ +// CLE +// +// 10/1995 +// +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include +#include + +// Extraction of a transient .ixx .jxx and _0.cxx +// the supplement variable is used for non inline methods generated +// by the extractor like destructor (added to .ixx ans _0.cxx +// +void CPP_MPVDerivated(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile, + const Handle(TColStd_HSequenceOfHAsciiString)& inclist, + const Handle(TColStd_HSequenceOfHAsciiString)& supplement) +{ + Standard_Integer i; + Handle(TCollection_HAsciiString) aFileName = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + // we do this only on standard classes (not on inst classes) + // + if (theClass.IsNull()) return; + + api->AddVariable(VClass,aClass->FullName()->ToCString()); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= inclist->Length(); i++) { + api->AddVariable(VIClass,inclist->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + } + + + if (theClass->GetMyCreator().IsNull()) { + // include hxx of me + // + api->AddVariable(VIClass,aClass->FullName()->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + + api->AddVariable(VoutClass,result->ToCString()); + + aFileName->AssignCat(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + aFileName->AssignCat(".jxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + result->Clear(); + outfile->Append(aFileName); + } + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + + if (theClass->GetMyCreator().IsNull()) { + aFileName->AssignCat(".ixx"); + } + else { + aFileName->AssignCat("_0.cxx"); + } + + // Supplement + // + if (theClass->GetMyCreator().IsNull()) { + result->Clear(); + } + + for (i = 1; i <= supplement->Length(); i++) { + result->AssignCat(supplement->Value(i)); + } + + api->AddVariable(VSupplement,result->ToCString()); + + // Methods + // + result->Clear(); + + if (!theClass->GetMyCreator().IsNull()) { + CPP_GenericDefine(aMeta,api,theClass->GetMyCreator(),VTICDefines,VTICUndefines,Standard_False); + result->AssignCat(api->GetVariableValue(VTICDefines)); + api->AddVariable(VSuffix,"gxx"); + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,theClass->GetMyCreator()->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + api->Apply(VMethods,"IncludeNoSafe"); + result->AssignCat(api->GetVariableValue(VMethods)); + } + + api->AddVariable(VMethods,result->ToCString()); + + if (theClass->GetMyCreator().IsNull()) { + api->AddVariable(VSuffix,"jxx"); + } + else { + api->AddVariable(VSuffix,"hxx"); + } + + api->AddVariable(VClass,aClass->FullName()->ToCString()); + + api->Apply(VoutClass,"MPVIxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + + outfile->Append(aFileName); +} + + +// Extraction of a transient class (inst or std) +// +void CPP_MPVClass(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile) +{ + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + if (!theClass.IsNull()) { + Standard_Integer i; + + Handle(MS_HSequenceOfMemberMet) methods = theClass->GetMethods(); + Handle(TCollection_HAsciiString) publics = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) protecteds = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) privates = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) SuppMethod = new TCollection_HAsciiString; + + Handle(TColStd_HSequenceOfHAsciiString) Supplement = new TColStd_HSequenceOfHAsciiString; + + Standard_Boolean HasInlineMethod = Standard_False, + HasDestructor = Standard_False; + + + api->AddVariable(VTICIncludes,""); + api->AddVariable(VTICPublicfriends,""); + api->AddVariable(VTICProtectedfields,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICDefines,""); + api->AddVariable(VTICInlineIncludes,""); + api->AddVariable(VTICUndefines,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICPrivatefields,""); + api->AddVariable(VSuffix,""); + api->AddVariable(VTICSuppMethod,""); + + if (theClass->GetInheritsNames()->Length() > 0) { + publics->AssignCat(" : public "); + publics->AssignCat(theClass->GetInheritsNames()->Value(1)); + api->AddVariable(VInherits,publics->ToCString()); + publics->Clear(); + } + else { + api->AddVariable(VInherits,""); + } + + api->AddVariable(VClass,theClass->FullName()->ToCString()); + + for (i = 1; i <= theClass->GetFriendsNames()->Length(); i++) { + publics->AssignCat("friend "); + api->AddVariable(VIClass,theClass->GetFriendsNames()->Value(i)->ToCString()); + api->Apply(VTICPublicfriends,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICPublicfriends)); + } + + if (!CPP_SetFriendMethod(aMeta,api,theClass->GetFriendMets(),publics)) { + ErrorMsg << "CPPExt" << "a friend method was not found..." << endm; + Standard_NoSuchObject::Raise(); + } + + api->AddVariable(VTICPublicfriends,publics->ToCString()); + + publics->Clear(); + + // extraction of the methods + // + Handle(TCollection_HAsciiString) aliasMethod; + + for (i = 1; i <= methods->Length(); i++) { + aliasMethod.Nullify(); + + if (methods->Value(i)->IsInline()) { + HasInlineMethod = Standard_True; + } + + // if the class has no destructor we give it + // + if (methods->Value(i)->IsDestructor()) { + HasDestructor = Standard_True; + } + + if (!methods->Value(i)->IsAlias().IsNull() || methods->Value(i)->IsDestructor()) { + aliasMethod = CPP_BuildAliasMethod(aMeta,api,methods->Value(i)); + } + + // Function Call c++ comment : + // it s must be in the _0.cxx or ixx file + // so we add it in the supplement sequence + // + if (methods->Value(i)->IsFunctionCall()) { + SuppMethod->AssignCat(CPP_BuildAliasMethod(aMeta,api,methods->Value(i))); + } + + CPP_BuildMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + +#ifdef WNT + if ( !methods -> Value ( i ) -> IsInline () ) +#endif // WNT + api->Apply(VMethod,"MethodTemplateDec"); +#ifdef WNT + else + api->Apply(VMethod,"MethodTemplateDecInlineWNT" ); +#endif // WNT + + if (methods->Value(i)->Private()) { + privates->AssignCat(api->GetVariableValue(VMethod)); + if (!aliasMethod.IsNull()) { + privates->AssignCat(aliasMethod); + } + } + else if ((theClass->Deferred() && methods->Value(i)->IsKind(STANDARD_TYPE(MS_Construc))) || + methods->Value(i)->IsProtected()) { + protecteds->AssignCat(api->GetVariableValue(VMethod)); + if (!aliasMethod.IsNull()) { + protecteds->AssignCat(aliasMethod); + } + } + else { + publics->AssignCat(api->GetVariableValue(VMethod)); + if (!aliasMethod.IsNull()) { + publics->AssignCat(aliasMethod); + } + } + } + + api->AddVariable(VTICPublicmets,publics->ToCString()); + api->AddVariable(VTICPrivatemets,privates->ToCString()); + api->AddVariable(VTICProtectedmets,protecteds->ToCString()); + + publics->Clear(); + privates->Clear(); + protecteds->Clear(); + + // extraction of fields + // + Handle(MS_HSequenceOfField) fields = theClass->GetFields(); + + for (i = 1; i <= fields->Length(); i++) { + if (fields->Value(i)->Protected()) { + protecteds->AssignCat(CPP_BuildField(aMeta,fields->Value(i))); + } + else { + privates->AssignCat(CPP_BuildField(aMeta,fields->Value(i))); + } + } + + api->AddVariable(VTICPrivatefields,privates->ToCString()); + api->AddVariable(VTICProtectedfields,protecteds->ToCString()); + + publics->Clear(); + privates->Clear(); + protecteds->Clear(); + + // others inline methods and functions (ex. function call) + // + api->AddVariable(VTICSuppMethod,SuppMethod->ToCString()); + + // include the lxx if the class have inline methods + // + if (HasInlineMethod) { + Handle(MS_InstClass) aCreator = theClass->GetMyCreator(); + + if (aCreator.IsNull()) { + api->AddVariable(VIClass,theClass->FullName()->ToCString()); + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeNoSafe"); + } + // this part is for class created by instantiations + // + else { + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,aCreator->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeNoSafe"); + + CPP_GenericDefine(aMeta,api,aCreator,VTICDefines,VTICUndefines,Standard_False); + } + } + + Handle(TColStd_HSequenceOfHAsciiString) List = new TColStd_HSequenceOfHAsciiString; + Handle(TColStd_HSequenceOfHAsciiString) incp = new TColStd_HSequenceOfHAsciiString; + + CPP_UsedTypes(aMeta,theClass,List,incp); + + publics->Clear(); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= List->Length(); i++) { + if (!List->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,List->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VTICIncludes,"IncludeNoSafe"); +#else + api->Apply(VTICIncludes,"Include"); +#endif + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + + for (i = 1; i <= incp->Length(); i++) { + if (!incp->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,incp->Value(i)->ToCString()); + api->Apply(VTICIncludes,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + api->AddVariable(VTICIncludes,publics->ToCString()); + + api->Apply(VoutClass,"MPVClass"); + + // we write the .hxx of this class + // + Handle(TCollection_HAsciiString) aFile = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFile->AssignCat(theClass->FullName()); + aFile->AssignCat(".hxx"); + + CPP_WriteFile(api,aFile,VoutClass); + + outfile->Append(aFile); + + CPP_MPVDerivated(aMeta,api,aClass,outfile,incp,Supplement); + } + else { + ErrorMsg << "CPPExt" << "CPP_MPVClass - the class is NULL..." << endm; + Standard_NoSuchObject::Raise(); + } +} + diff --git a/src/CPPExt/CPPExt_Package.cxx b/src/CPPExt/CPPExt_Package.cxx new file mode 100755 index 0000000..1cad02e --- /dev/null +++ b/src/CPPExt/CPPExt_Package.cxx @@ -0,0 +1,286 @@ +// CLE +// +// 10/1995 +// +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include +#include + +// Extraction of a transient .ixx .jxx and _0.cxx +// the supplement variable is used for non inline methods generated +// by the extractor like destructor (added to .ixx ans _0.cxx +// +void CPP_PackageDerivated(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Package)& aPackage, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile, + const Handle(TColStd_HSequenceOfHAsciiString)& inclist, + const Handle(TColStd_HSequenceOfHAsciiString)& supplement) +{ + Standard_Integer i; + Handle(TCollection_HAsciiString) aFileName = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + + api->AddVariable(VClass,aPackage->Name()->ToCString()); + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= inclist->Length(); i++) { + api->AddVariable(VIClass,inclist->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + } + + + // include hxx of me + // + api->AddVariable(VIClass,aPackage->Name()->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + + api->AddVariable(VoutClass,result->ToCString()); + + aFileName->AssignCat(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aPackage->Name()); + aFileName->AssignCat(".jxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + + outfile->Append(aFileName); + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aPackage->Name()); + aFileName->AssignCat(".ixx"); + + // Supplement + // + result->Clear(); + + for (i = 1; i <= supplement->Length(); i++) { + result->AssignCat(supplement->Value(i)); + } + + api->AddVariable(VSupplement,result->ToCString()); + + // Methods + // + result->Clear(); + + api->AddVariable(VSuffix,"jxx"); + + api->AddVariable(VClass,aPackage->Name()->ToCString()); + + api->Apply(VoutClass,"MPVIxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + + outfile->Append(aFileName); +} + + +// Extraction of a transient class (inst or std) +// +void CPP_Package(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Package)& aPackage, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile) +{ + if (!aPackage.IsNull()) { + Standard_Integer i; + + Handle(MS_HSequenceOfExternMet) methods = aPackage->Methods(); + + Handle(TCollection_HAsciiString) publics = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) privates = new TCollection_HAsciiString; + + Handle(TColStd_HSequenceOfHAsciiString) Supplement = new TColStd_HSequenceOfHAsciiString; + Handle(TColStd_HSequenceOfHAsciiString) packClass = aPackage->Classes(); + Standard_Boolean HasInlineMethod = Standard_False; + + Handle(TColStd_HSequenceOfHAsciiString) List = new TColStd_HSequenceOfHAsciiString; + Handle(TColStd_HSequenceOfHAsciiString) incp = new TColStd_HSequenceOfHAsciiString; + + + api->AddVariable(VTICIncludes,""); + api->AddVariable(VTICPublicfriends,""); + api->AddVariable(VTICProtectedfields,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICDefines,""); + api->AddVariable(VTICInlineIncludes,""); + api->AddVariable(VTICUndefines,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICPrivatefields,""); + api->AddVariable(VSuffix,""); + api->AddVariable(VInherits,""); + api->AddVariable(VTICProtectedmets,""); + api->AddVariable(VTICPrivatemets,""); + api->AddVariable(VMethods,""); + api->AddVariable(VClass,aPackage->FullName()->ToCString()); + api->AddVariable(VTICSuppMethod,""); + + // extraction of the methods + // + Handle(TCollection_HAsciiString) aliasMethod; + + for (i = 1; i <= methods->Length(); i++) { + aliasMethod.Nullify(); + + if (methods->Value(i)->IsInline()) { + HasInlineMethod = Standard_True; + } + + if (!methods->Value(i)->IsAlias().IsNull()) { + if (methods->Value(i)->IsQuotedAlias()) { + aliasMethod = new TCollection_HAsciiString(methods->Value(i)->IsAlias()); + aliasMethod->Remove(1); + if (aliasMethod->Value(aliasMethod->Length()) == '"') { + aliasMethod->Remove(aliasMethod->Length()); + } + aliasMethod->AssignCat("\n"); + } + } + + CPP_BuildMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + +#ifdef WNT + if ( !methods -> Value ( i ) -> IsInline () ) +#endif // WNT + api->Apply(VMethod,"MethodTemplateDec"); +#ifdef WNT + else + api->Apply(VMethod,"MethodTemplateDecInlineWNT" ); +#endif // WNT + + MS::MethodUsedTypes(aMeta,methods->Value(i),List,incp); + + if (methods->Value(i)->Private()) { + privates->AssignCat(api->GetVariableValue(VMethod)); + if (!aliasMethod.IsNull()) { + privates->AssignCat(aliasMethod); + } + } + else { + publics->AssignCat(api->GetVariableValue(VMethod)); + if (!aliasMethod.IsNull()) { + publics->AssignCat(aliasMethod); + } + } + } + + api->AddVariable(VTICPublicmets,publics->ToCString()); + api->AddVariable(VTICPrivatemets,privates->ToCString()); + + publics->Clear(); + privates->Clear(); + + // include the lxx if the class have inline methods + // + if (HasInlineMethod) { + api->AddVariable(VIClass,aPackage->Name()->ToCString()); + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeNoSafe"); + } + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= List->Length(); i++) { + if (!List->Value(i)->IsSameString(aPackage->Name())) { + api->AddVariable(VIClass,List->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VTICIncludes,"IncludeNoSafe"); +#else + api->Apply(VTICIncludes,"Include"); +#endif + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + for (i = 1; i <= incp->Length(); i++) { + if (!incp->Value(i)->IsSameString(aPackage->Name())) { + api->AddVariable(VIClass,incp->Value(i)->ToCString()); + api->Apply(VTICIncludes,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + for (i = 1; i <= packClass->Length(); i++) { + // Declaration incomplete et + // + Handle(TCollection_HAsciiString) name = MS::BuildFullName(aPackage->Name(),packClass->Value(i)); + api->AddVariable(VIClass,name->ToCString()); + api->Apply(VTICIncludes,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + // ... declarations friends des classes declarees dans le package pour + // les methodes de classes privees + // + Handle(TCollection_HAsciiString) friendname = new TCollection_HAsciiString("friend class "); + friendname->AssignCat(name->ToCString()); + friendname->AssignCat(";\n"); + privates->AssignCat(friendname); + } + api->AddVariable(VTICPrivatefriends,privates->ToCString()); + api->AddVariable(VTICIncludes,publics->ToCString()); + + api->Apply(VoutClass,"MPVClass"); + + // we write the .hxx of this class + // + Handle(TCollection_HAsciiString) aFile = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFile->AssignCat(aPackage->Name()); + aFile->AssignCat(".hxx"); + + CPP_WriteFile(api,aFile,VoutClass); + + outfile->Append(aFile); + + CPP_PackageDerivated(aMeta,api,aPackage,outfile,incp,Supplement); + } + else { + ErrorMsg << "CPPExt" << "CPP_Package - the package is NULL..." << endm; + Standard_NoSuchObject::Raise(); + } +} + diff --git a/src/CPPExt/CPPExt_PersistentCSFDB.cxx b/src/CPPExt/CPPExt_PersistentCSFDB.cxx new file mode 100755 index 0000000..e52e895 --- /dev/null +++ b/src/CPPExt/CPPExt_PersistentCSFDB.cxx @@ -0,0 +1,597 @@ +// CLE +// +// 10/1995 +// +#include +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include +#include + + +// create a VArray CSFDB dependent declaration for DBC instance +// look EDL template : VArrayFieldCSFDB +// +void CPP_BuildVArrayDeclarationCSFDB(const Handle(MS_MetaSchema)&, + const Handle(EDL_API)& api, + const Handle(MS_StdClass)& aClass, + const Handle(TCollection_HAsciiString)& Result) +{ + if (!aClass->GetMyCreator().IsNull()) { + Handle(MS_InstClass) anInst = aClass->GetMyCreator(); + Handle(TCollection_HAsciiString) aGen = anInst->GenClass(); + + if (aGen->IsSameString(MS::GetVArrayRootName())) { + api->AddVariable(VDName,aClass->FullName()->ToCString()); + api->AddVariable(VDValue,anInst->InstTypes()->Value(1)->ToCString()); + api->Apply(VDValue,"VArrayDeclareCSFDB"); + Result->AssignCat(api->GetVariableValue(VDValue)); + } + } +} + +// create a VArray CSFDB dependent field for DBC instance +// look EDL template : VArrayFieldCSFDB +// +void CPP_BuildVArrayFieldCSFDB(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_StdClass)& aClass, + const Handle(TCollection_HAsciiString)& Result) +{ + if (!aClass->GetMyCreator().IsNull()) { + Handle(MS_InstClass) anInst = aClass->GetMyCreator(); + Handle(TCollection_HAsciiString) aGen = anInst->GenClass(); + + if (aGen->IsSameString(MS::GetVArrayRootName())) { + api->AddVariable(VDName,aClass->FullName()->ToCString()); + api->AddVariable(VDValue,CPP_BuildType(aMeta,anInst->InstTypes()->Value(1))->ToCString()); + api->Apply(VDValue,"VArrayFieldCSFDB"); + Result->AssignCat(api->GetVariableValue(VDValue)); + } + } +} + +// CLE: ajouter le nom de la classe dans le nom des methodes d'acces aux champs +// +void CPP_BuildAccessFieldCSFDB(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Field)& field, + const Handle(TCollection_HAsciiString)& publics) +{ + Handle(MS_Type) thetype = aMeta->GetType(field->TYpe()); + + if (field->Dimensions()->Length() > 0) { + Standard_Integer i; + Handle(TCollection_HAsciiString) sdim = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) ddim = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) vdim = new TCollection_HAsciiString; + char num[30]; + + + api->AddVariable("%CSFDBType",CPP_BuildType(aMeta,field->TYpe())->ToCString()); + api->AddVariable("%Field",field->Name()->ToCString()); + + for (i = 1; i <= field->Dimensions()->Length(); i++) { + sdim->AssignCat("["); + sprintf(num,"%d",i); + sdim->AssignCat("i"); + sdim->AssignCat(num); + sdim->AssignCat("]"); + + if (i != 1) { + vdim->AssignCat(","); + ddim->AssignCat(","); + } + vdim->AssignCat("const Standard_Integer i"); + vdim->AssignCat(num); + + ddim->AssignCat("i"); + ddim->AssignCat(num); + } + api->AddVariable("%FDim",sdim->ToCString()); + api->AddVariable("%VarDim",vdim->ToCString()); + api->AddVariable("%Dimension",ddim->ToCString()); + api->Apply("%res","DefFuncFieldArray"); + } + else { + api->AddVariable("%CSFDBType",field->TYpe()->ToCString()); + api->AddVariable("%Field",field->Name()->ToCString()); + + if (thetype->IsKind(STANDARD_TYPE(MS_StdClass))) { + Handle(MS_StdClass) aclass = *((Handle(MS_StdClass)*)&thetype); + + if (aclass->IsPersistent()) { + api->Apply("%res","DefFuncPField"); + } + else { + api->Apply("%res","DefFuncSField"); + } + } + else { + api->Apply("%res","DefFuncPrField"); + } + } + + publics->AssignCat(api->GetVariableValue("%res")); +} + +// Extraction of a Persistent handle for CSFDB +// +void CPP_PersistentHandleCSFDB(const Handle(EDL_API)& api, + const Handle(TCollection_HAsciiString)& aClass, + const Handle(TCollection_HAsciiString)& aMother, + const Handle(TCollection_HAsciiString)& aFileName) +{ + // we create the handle... + // + api->AddVariable("%HPName",aClass->ToCString()); + api->AddVariable("%HPInherits",aMother->ToCString()); + api->Apply("%HPHandle","HandlePersistentCSFDB"); + + // ...now we write the result + // + api->OpenFile("HTFile",aFileName->ToCString()); + api->WriteFile("HTFile","%HPHandle"); + api->CloseFile("HTFile"); +} + + +// Extraction of a persistent .ixx .jxx and _0.cxx +// the supplement variable is used for non inline methods generated +// by the extractor like destructor (added to .ixx ans _0.cxx +// +void CPP_PersistentDerivatedCSFDB(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile, + const Handle(TColStd_HSequenceOfHAsciiString)& inclist, + const Handle(TColStd_HSequenceOfHAsciiString)& supplement) +{ + Standard_Integer i; + Handle(TCollection_HAsciiString) aFileName = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + // we do this only on standard classes (not on inst classes) + // + if (theClass.IsNull()) return; + + api->AddVariable(VClass,aClass->FullName()->ToCString()); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= inclist->Length(); i++) { + api->AddVariable(VIClass,inclist->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + } + + if (theClass->GetMyCreator().IsNull()) { + // include the hxx of me + // + api->AddVariable(VIClass,aClass->FullName()->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + + api->AddVariable(VoutClass,result->ToCString()); + + aFileName->AssignCat(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + aFileName->AssignCat(".jxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + result->Clear(); + outfile->Append(aFileName); + } + + CPP_ClassTypeMgt(aMeta,api,aClass,VTypeMgt); + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + + if (theClass->GetMyCreator().IsNull()) { + aFileName->AssignCat(".ixx"); + } + else { + aFileName->AssignCat("_0.cxx"); + } + + // Supplement + // + if (theClass->GetMyCreator().IsNull()) { + result->Clear(); + } + + for (i = 1; i <= supplement->Length(); i++) { + result->AssignCat(supplement->Value(i)); + } + + api->AddVariable(VSupplement,result->ToCString()); + + // Methods + // + result->Clear(); + + api->AddVariable(VIClass,MS::GetPersistentRootName()->ToCString()); + api->Apply(VMethods,"DownCast"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->Apply(VMethods,"DynamicType"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->AddVariable(VIClass,aClass->GetInheritsNames()->Value(1)->ToCString()); + api->Apply(VMethods,"IsKind"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->Apply(VMethods,"FullEmptyHandleDestructorTemplate"); + result->AssignCat(api->GetVariableValue(VMethods)); + + if (!theClass->GetMyCreator().IsNull()) { + CPP_GenericDefine(aMeta,api,theClass->GetMyCreator(),VTICDefines,VTICUndefines,Standard_True); + result->AssignCat(api->GetVariableValue(VTICDefines)); + api->AddVariable(VSuffix,"gxx"); + + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,theClass->GetMyCreator()->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + + api->Apply(VMethods,"IncludeNoSafe"); + result->AssignCat(api->GetVariableValue(VMethods)); + } + + if (theClass->GetMyCreator().IsNull()) { + api->AddVariable(VSuffix,"jxx"); + } + else { + api->AddVariable(VSuffix,"hxx"); + } + + api->AddVariable(VMethods,result->ToCString()); + api->Apply(VoutClass,"PersistentCSFDBIxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + + outfile->Append(aFileName); +} + + +// Extraction of a persistent class (inst or std) +// +void CPP_PersistentClassCSFDB(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile) +{ + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + if (!theClass.IsNull()) { + Standard_Integer i; + + Handle(MS_HSequenceOfMemberMet) methods = theClass->GetMethods(); + Handle(MS_Method) friendmethod; + Handle(TCollection_HAsciiString) publics = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) protecteds = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) privates = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) protf = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) privf = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) SuppMethod = new TCollection_HAsciiString; + + Handle(TColStd_HSequenceOfHAsciiString) Supplement = new TColStd_HSequenceOfHAsciiString; + Standard_Boolean HasInlineMethod = Standard_False, + HasDestructor = Standard_False, + HasEmptyConst = Standard_False, + HasConstructor = Standard_False; + Handle(TColStd_HSequenceOfHAsciiString) List = new TColStd_HSequenceOfHAsciiString; + Handle(TColStd_HSequenceOfHAsciiString) incp = new TColStd_HSequenceOfHAsciiString; + + + api->AddVariable(VTICIncludes,""); + api->AddVariable(VTICPublicfriends,""); + api->AddVariable(VTICProtectedfields,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICDefines,""); + api->AddVariable(VTICInlineIncludes,""); + api->AddVariable(VTICUndefines,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICPrivatefields,""); + api->AddVariable(VSuffix,""); + api->AddVariable(VTICSuppMethod,""); + + api->AddVariable(VClass,theClass->FullName()->ToCString()); + api->AddVariable(VInherits,theClass->GetInheritsNames()->Value(1)->ToCString()); + + for (i = 1; i <= theClass->GetFriendsNames()->Length(); i++) { + publics->AssignCat("friend "); + api->AddVariable(VIClass,theClass->GetFriendsNames()->Value(i)->ToCString()); + api->Apply(VTICPublicfriends,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICPublicfriends)); + } + + if (!CPP_SetFriendMethod(aMeta,api,theClass->GetFriendMets(),publics)) { + ErrorMsg << "CPPExt" << "a friend method was not found..." << endm; + Standard_NoSuchObject::Raise(); + } + + api->AddVariable(VTICPublicfriends,publics->ToCString()); + + publics->Clear(); + + // extraction of the methods : BEGIN + // + Handle(TCollection_HAsciiString) aliasMethod; + + for (i = 1; i <= methods->Length(); i++) { + aliasMethod.Nullify(); + + if (methods->Value(i)->IsInline()) { + HasInlineMethod = Standard_True; + } + + // if the class has no destructor, we give it + // + if (methods->Value(i)->IsDestructor()) { + HasDestructor = Standard_True; + } + + // if the class has no empty constructor, we give it + // + if (methods->Value(i)->IsKind(STANDARD_TYPE(MS_Construc))) { + if (methods->Value(i)->Params().IsNull()) { + HasEmptyConst = Standard_True; + } + + HasConstructor = Standard_True; + } + else { + if (!methods->Value(i)->Returns().IsNull()) { + MS::DispatchUsedType(aMeta,methods->Value(i)->Returns()->Type(),List,incp,Standard_True); + } + } + + if (!methods->Value(i)->IsAlias().IsNull() || methods->Value(i)->IsDestructor()) { + aliasMethod = CPP_BuildAliasMethod(aMeta,api,methods->Value(i)); + } + + // Function Call c++ comment : + // it s must be in the _0.cxx or ixx file + // so we add it in the supplement sequence + // + if (methods->Value(i)->IsFunctionCall()) { + SuppMethod->AssignCat(CPP_BuildAliasMethod(aMeta,api,methods->Value(i))); + } + + CPP_BuildMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + +#ifdef WNT + if ( !methods -> Value ( i ) -> IsInline () ) +#endif // WNT + api->Apply(VMethod,"MethodTemplateDec"); +#ifdef WNT + else + api->Apply(VMethod,"MethodTemplateDecInlineWNT" ); +#endif // WNT + + if (methods->Value(i)->Private()) { + privates->AssignCat(api->GetVariableValue(VMethod)); + + if (!aliasMethod.IsNull()) { + privates->AssignCat(aliasMethod); + } + } + else if ((theClass->Deferred() && methods->Value(i)->IsKind(STANDARD_TYPE(MS_Construc))) || + methods->Value(i)->IsProtected()) { + protecteds->AssignCat(api->GetVariableValue(VMethod)); + + if (!aliasMethod.IsNull()) { + protecteds->AssignCat(aliasMethod); + } + } + else { + publics->AssignCat(api->GetVariableValue(VMethod)); + + if (!aliasMethod.IsNull()) { + publics->AssignCat(aliasMethod); + } + } + } // methods extraction : END + + if (!HasDestructor) { + api->Apply(VMethod,"EmptyDestructorTemplate"); + publics->AssignCat(api->GetVariableValue(VMethod)); + } + + if (!HasEmptyConst && (aClass->GetFields()->Length() > 0)) { + api->AddVariable("%Class",aClass->FullName()->ToCString()); + api->AddVariable("%Arguments"," "); + api->Apply(VMethod,"ConstructorHeader"); + api->AddVariable(VMBody,""); + api->Apply(VMethod,"MethodTemplateDef"); + publics->AssignCat(api->GetVariableValue(VMethod)); + + // WARNING: here is a trap + // + HasEmptyConst = Standard_True; + } + + // Add a special constructor for Storage package + // + Handle(MS_StdClass) aMaman = Handle(MS_StdClass)::DownCast(aMeta->GetType(theClass->GetInheritsNames()->Value(1))); + + api->AddVariable("%Class",aClass->FullName()->ToCString()); + api->Apply(VMethod,"ConstructorHeaderCallAncestor"); + api->AddVariable(VMBody,""); + api->Apply(VMethod,"MethodTemplateDef"); + publics->AssignCat(api->GetVariableValue(VMethod)); + // if the class have empty constructor we must add one. + // if a derived class of this have a constructor + // this constructor will be forced to call an empty constructor + // + if (!HasEmptyConst) { + api->AddVariable("%Class",aClass->FullName()->ToCString()); + api->AddVariable("%Arguments"," "); + api->Apply(VMethod,"ConstructorHeader"); + api->AddVariable(VMBody,""); + api->Apply(VMethod,"MethodTemplateDef"); + publics->AssignCat(api->GetVariableValue(VMethod)); + } + + // extraction of fields + // + Handle(MS_HSequenceOfField) fields = theClass->GetFields(); + + api->AddVariable("%NameField",theClass->FullName()->ToCString()); + + for (i = 1; i <= fields->Length(); i++) { + if (fields->Value(i)->Protected()) { + protf->AssignCat(CPP_BuildField(aMeta,fields->Value(i))); + } + else { + privf->AssignCat(CPP_BuildField(aMeta,fields->Value(i))); + } + CPP_BuildAccessFieldCSFDB(aMeta,api,fields->Value(i),publics); + } + + api->AddVariable(VTICPublicmets,publics->ToCString()); + api->AddVariable(VTICPrivatemets,privates->ToCString()); + api->AddVariable(VTICProtectedmets,protecteds->ToCString()); + api->AddVariable(VTICPrivatefields,privf->ToCString()); + api->AddVariable(VTICProtectedfields,protf->ToCString()); + + publics->Clear(); + privates->Clear(); + protecteds->Clear(); + privf->Clear(); + protf->Clear(); + + // others inline methods and functions (ex. function call) + // + api->AddVariable(VTICSuppMethod,SuppMethod->ToCString()); + + // include the lxx if the class have inline methods + // + if (HasInlineMethod) { + Handle(MS_InstClass) aCreator = theClass->GetMyCreator(); + + if (aCreator.IsNull()) { + api->AddVariable(VIClass,theClass->FullName()->ToCString()); + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeNoSafe"); + } + // this part is for class created by instantiations + // + else { + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,aCreator->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeNoSafe"); + + CPP_GenericDefine(aMeta,api,aCreator,VTICDefines,VTICUndefines,Standard_True); + } + } + + CPP_UsedTypes(aMeta,theClass,List,incp); + + publics->Clear(); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= List->Length(); i++) { + if (!List->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,List->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VTICIncludes,"IncludeNoSafe"); +#else + api->Apply(VTICIncludes,"Include"); +#endif + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + + for (i = 1; i <= incp->Length(); i++) { + if (!incp->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,incp->Value(i)->ToCString()); + api->Apply(VTICIncludes,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + api->AddVariable(VTICIncludes,publics->ToCString()); + + api->Apply(VoutClass,"PersistentCSFDBInstClass"); + + // we write the .hxx of this class + // + Handle(TCollection_HAsciiString) aFile = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFile->AssignCat(theClass->FullName()); + aFile->AssignCat(".hxx"); + + CPP_WriteFile(api,aFile,VoutClass); + + outfile->Append(aFile); + + // .ixx or _0.cxx + // + if (!HasDestructor) { + api->Apply(VMethod,"FullEmptyDestructorTemplate"); + Supplement->Append(new TCollection_HAsciiString(api->GetVariableValue(VMethod))); + } + + CPP_PersistentDerivatedCSFDB(aMeta,api,aClass,outfile,incp,Supplement); + } + else { + ErrorMsg << "CPPExt" << "CPP_PersistentClassCSFDB - the class is NULL..." << endm; + Standard_NoSuchObject::Raise(); + } +} + diff --git a/src/CPPExt/CPPExt_PersistentOBJS.cxx b/src/CPPExt/CPPExt_PersistentOBJS.cxx new file mode 100755 index 0000000..04cb8b1 --- /dev/null +++ b/src/CPPExt/CPPExt_PersistentOBJS.cxx @@ -0,0 +1,1024 @@ +// CLE +// +// 10/1995 +// +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include +#include + +static Standard_CString VTICOidpubMet = "%TICOidpubMet", + VTICOidproMet = "%TICOidproMet", + VTICOidpriMet = "%TICOidpriMet"; + +Handle(TCollection_HAsciiString) CPP_BuildTypeOBJS(const Handle(MS_MetaSchema)& aMeta, + const Handle(TCollection_HAsciiString)& aTypeName); + +// create the defines and the undefines that are around the include of +// a generic .lxx +// ex. : +// #define ItemHArray1 Quantity_Color +// #define ItemHArray1_hxx +// #define TheArray1 Quantity_Array1OfColor +// #define TheArray1_hxx +// #define TCollection_HArray1 Quantity_HArray1OfColor +// #define TCollection_HArray1_hxx +// #include +// #undef ItemHArray1 +// #undef ItemHArray1_hxx +// #undef TheArray1 +// #undef TheArray1_hxx +// #undef TCollection_HArray1 +// #undef TCollection_HArray1_hxx +// +void CPP_GenericMDTVDefineOBJS(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_InstClass)& aCreator, + const Standard_CString VARDefine, + const Standard_CString VARUndefine, + const Standard_Boolean handleUsed) +{ + Handle(MS_GenClass) aGenClass = Handle(MS_GenClass)::DownCast(aMeta->GetType(aCreator->GenClass())); + Handle(TColStd_HSequenceOfHAsciiString) theGenTypes = aCreator->GenTypes(); + Handle(TCollection_HAsciiString) publics = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) protecteds = new TCollection_HAsciiString; + Standard_Integer i, + itemLength; + Handle(MS_HSequenceOfGenType) realGentypes = aGenClass->GenTypes(); + + // we need this length because for item we must call + // CPP_BuildType and for nested class name we dont need. + // + itemLength = aGenClass->GenTypes()->Length(); + + for (i = 1; i <= theGenTypes->Length(); i++) { + if (!aGenClass->FullName()->IsSameString(theGenTypes->Value(i))) { + api->AddVariable(VDName,theGenTypes->Value(i)->ToCString()); + + // real name or Handle_name + // + if (i <= itemLength) { + if (!realGentypes->Value(i)->TYpeName().IsNull()) { + if (aMeta->IsDefined(realGentypes->Value(i)->TYpeName())) { + Handle(MS_Type) t = aMeta->GetType(realGentypes->Value(i)->TYpeName()); + + if (t->IsKind(STANDARD_TYPE(MS_Class))) { + Handle(MS_Class) c = *((Handle(MS_Class)*)&t); + + // if the items constraint is handled, the item is not the handle, + // like in other cases, but the type himself. + // + // ex. : the item : 'i' as transient + // will be defined as #define i class + // the item : 'i' as any + // will be defined as #define i Handle_Class + // + if (c->IsPersistent() || c->IsTransient()) { + api->AddVariable(VDValue,aCreator->InstTypes()->Value(i)->ToCString()); + api->Apply(VARDefine,"ItemMDTVConstraintHandle"); + api->Apply(VARUndefine,"ItemMDTVConstraintHandleUndef"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + else { + api->AddVariable(VDValue,CPP_BuildTypeOBJS(aMeta,aCreator->InstTypes()->Value(i))->ToCString()); + } + } + } + } + else { + api->AddVariable(VDValue,CPP_BuildTypeOBJS(aMeta,aCreator->InstTypes()->Value(i))->ToCString()); + } + api->AddVariable("%DBaseValue",aCreator->InstTypes()->Value(i)->ToCString()); + } + // real name + // + else { + api->AddVariable(VDValue,aCreator->InstTypes()->Value(i)->ToCString()); + api->AddVariable("%DBaseValue",aCreator->InstTypes()->Value(i)->ToCString()); + } + + api->Apply(VARDefine,"ItemMDTVDefine"); + api->Apply(VARUndefine,"ItemMDTVUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + } + + for (i = itemLength + 1; i <= theGenTypes->Length(); i++) { + if (!aGenClass->FullName()->IsSameString(theGenTypes->Value(i))) { + Handle(TCollection_HAsciiString) realName = CPP_BuildTypeOBJS(aMeta,aCreator->InstTypes()->Value(i)); + + if (!realName->IsSameString(aCreator->InstTypes()->Value(i))) { + api->AddVariable(VDName,theGenTypes->Value(i)->ToCString()); + api->AddVariable(VDValue,aCreator->InstTypes()->Value(i)->ToCString()); + api->Apply(VARDefine,"ItemHandleMDTVDefine"); + api->Apply(VARUndefine,"ItemHandleMDTVUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + } + } + + api->AddVariable(VDName,aGenClass->FullName()->ToCString()); + api->AddVariable(VDValue,aCreator->FullName()->ToCString()); + api->AddVariable("%DBaseValue",aCreator->FullName()->ToCString()); + + api->Apply(VARDefine,"ItemMDTVDefine"); + api->Apply(VARUndefine,"ItemMDTVUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + + + // #define TCollection_HSequence_Type_() TColStd_HSequenceOfTransient_Type_() + // #define Handle_TCollection_HSequence Handle_TColStd_HSequenceOfTransient + // + if (aGenClass->IsTransient() || aGenClass->IsPersistent()) { + api->AddVariable(VDName,aGenClass->FullName()->ToCString()); + api->AddVariable(VDValue,aCreator->FullName()->ToCString()); + api->Apply(VARDefine,"ItemHandleMDTVDefine"); + api->Apply(VARUndefine,"ItemHandleMDTVUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + + api->AddVariable(VARDefine,publics->ToCString()); + api->AddVariable(VARUndefine,protecteds->ToCString()); +} + +// create a VArray OBJS dependent declaration for DBC instance +// look EDL template : VArrayFieldOBJS +// +void CPP_BuildVArrayDeclarationOBJS(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_StdClass)& aClass, + const Handle(TCollection_HAsciiString)& Result) +{ +// if (!aClass->GetMyCreator().IsNull()) { +// Handle(MS_InstClass) anInst = aClass->GetMyCreator(); +// Handle(TCollection_HAsciiString) aGen = anInst->GenClass(); + +// if (aGen->IsSameString(MS::GetVArrayRootName())) { +// api->AddVariable(VDName,aClass->FullName()->ToCString()); +// api->AddVariable(VDValue,anInst->InstTypes()->Value(1)->ToCString()); +// api->Apply(VDValue,"VArrayDeclareOBJS"); +// Result->AssignCat(api->GetVariableValue(VDValue)); +// } +// } +} + +// create a VArray OBJS dependent field for DBC instance +// look EDL template : VArrayFieldOBJS +// +void CPP_BuildVArrayFieldOBJS(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_StdClass)& aClass, + const Handle(TCollection_HAsciiString)& Result) +{ +// if (!aClass->GetMyCreator().IsNull()) { +// Handle(MS_InstClass) anInst = aClass->GetMyCreator(); +// Handle(TCollection_HAsciiString) aGen = anInst->GenClass(); + +// if (aGen->IsSameString(MS::GetVArrayRootName())) { +// api->AddVariable(VDName,aClass->FullName()->ToCString()); +// api->AddVariable(VDValue,anInst->InstTypes()->Value(1)->ToCString()); +// api->Apply(VDValue,"VArrayFieldOBJS"); +// Result->AssignCat(api->GetVariableValue(VDValue)); +// } +// } +} + +// build a c++ declaration method +// the result is in the EDL variable VMethod +// +// template used : +// +// MethodTemplateDef +// ConstructorTemplateDef +// MethodTemplateDec +// ConstructorTemplateDec +// InlineMethodTemplateDec +// +// the EDL variables : +// VMethodHeader : must contains the name of the template used for +// methods construction +// VConstructorHeader : must contains the name of the template used for +// constructors construction +// +void CPP_BuildOidOBJSMethod(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Method)& m, + const Handle(TCollection_HAsciiString)& methodName, + const Standard_Boolean forDeclaration = Standard_True) +{ + Handle(MS_InstMet) im; + Handle(MS_ClassMet) cm; + Handle(MS_Construc) ct; + Handle(MS_Param) retType; + + Handle(TCollection_HAsciiString) MetTemplate, + ConTemplate; + + Standard_Boolean InlineMethod; + + MetTemplate = api->GetVariableValue(VMethodHeader); + ConTemplate = api->GetVariableValue(VConstructorHeader); + + // here we process all the common attributes of methods + // + api->AddVariable(VMethodName,methodName->ToCString()); + api->AddVariable(VVirtual,""); + + // it s inline method ? + // + api->AddVariable(VIsInline,"no"); + InlineMethod = Standard_False; + + api->AddVariable(VRetSpec,""); + + // it s returning & ? + // + if (m->IsRefReturn()) { + api->AddVariable(VAnd,"&"); + } + else { + api->AddVariable(VAnd,""); + } + + api->AddVariable(VArgument,CPP_BuildParameterList(aMeta,m->Params(),forDeclaration)->ToCString()); + + // it s returning a type or void + // + retType = m->Returns(); + + if (!retType.IsNull()) { + api->AddVariable(VReturn,CPP_BuildType(aMeta,retType->TypeName())->ToCString()); + } + else { + api->AddVariable(VReturn,"void"); + } + + // now the specials attributes + // + // instance methods + // + if (m->IsKind(STANDARD_TYPE(MS_InstMet))) { + im = *((Handle(MS_InstMet)*)&m); + + api->AddVariable(VIsCreateMethod,"no"); + api->AddVariable(VMetSpec,""); + api->Apply(VMethod,MetTemplate->ToCString()); + //api->Apply(VMethod,"InlineMethodTemplateDec"); + } +} + +Handle(TCollection_HAsciiString) CPP_BuildOidImmTestOBJS(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Method)& Method, + const Standard_Boolean UseMutability) +{ + Handle(TCollection_HAsciiString) body = new TCollection_HAsciiString; + Standard_Integer i; + Standard_Boolean testResult; + Handle(MS_HArray1OfParam) aSeqParam = Method->Params(); + + api->AddVariable(VMethodName,Method->Name()->ToCString()); + + if(!aSeqParam.IsNull()) { + for (i = 1; i <= aSeqParam->Length(); i++) { + if (aSeqParam->Value(i)->Type()->IsKind(STANDARD_TYPE(MS_Class))) { + Handle(MS_Type) pType = aSeqParam->Value(i)->Type(); + Handle(MS_Class) aPersClass = *((Handle_MS_Class*)&pType); + + if (UseMutability) { + testResult = aSeqParam->Value(i)->IsMutable(); + } + else { + testResult = aSeqParam->Value(i)->IsOut(); + } + + if (testResult && aPersClass->IsPersistent()) { + api->AddVariable(VDName,aSeqParam->Value(i)->Name()->ToCString()); + api->Apply(VDName,"ImmutableTestOBJS"); + body->AssignCat(api->GetVariableValue(VDName)); + } + } + } + } + return body; +} + +// Build the list of call for persistent oid methods and set the result at the end of +// publics +// +Standard_Boolean CPP_BuildOidMethodCallOBJS(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Method)& Method, + const Handle(TCollection_HAsciiString)& publics) +{ + if (publics.IsNull()) return Standard_False; + + Handle(MS_InstMet) method = Handle(MS_InstMet)::DownCast(Method); + Standard_Integer i; + Standard_Boolean result = Standard_True; + Handle(TCollection_HAsciiString) aname, + oldclass = api->GetVariableValue(VClass), + body, + immTest; + Handle(MS_HArray1OfParam) aSeqParam; + + // templates for methods extraction + // + api->AddVariable(VMethodHeader,"ExternalMethodHeader"); + api->AddVariable(VConstructorHeader,"ExternalConstructorHeader"); + + if (!method.IsNull()) { + body = new TCollection_HAsciiString; + + aSeqParam = method->Params(); + + aname = new TCollection_HAsciiString("Oid_"); + aname->AssignCat(method->Class()); + + // method header + // + api->AddVariable(VClass,aname->ToCString()); + CPP_BuildOidOBJSMethod(aMeta,api,method,method->Name(),Standard_False); + + api->AddVariable(VClass,method->Class()->ToCString()); + api->AddVariable(VMethodName,method->Name()->ToCString()); + + // parameters + // + aname = new TCollection_HAsciiString(method->Name()); + aname->AssignCat("("); + + immTest = CPP_BuildOidImmTestOBJS(aMeta,api,method,Standard_True); + + body->AssignCat(immTest); + + // method call signature + // + if (!aSeqParam.IsNull()) { + aname->AssignCat(aSeqParam->Value(1)->Name()); + + for (i = 2; i <= aSeqParam->Length(); i++) { + aname->AssignCat(","); + aname->AssignCat(aSeqParam->Value(i)->Name()); + } + } + + aname->AssignCat(")"); + + // method call + // + api->AddVariable(VMethodName,aname->ToCString()); + + if (method->IsConst()) { + api->Apply(VMethodName,"ReadAccessOBJS"); + } + else { + api->Apply(VMethodName,"UpdateAccessOBJS"); + } + + // returns value + // + if (!method->Returns().IsNull()) { + body->AssignCat(CPP_BuildType(aMeta,method->Returns()->TypeName())); + body->AssignCat(" _result = "); + body->AssignCat(api->GetVariableValue(VMethodName)); + + if (method->Returns()->Type()->IsKind(STANDARD_TYPE(MS_Class))) { + if (method->Returns()->IsMutable()) { + api->AddVariable(VDName,"_result"); + api->AddVariable(VMethodName,method->Name()->ToCString()); + api->Apply(VDName,"ImmutableTestOBJS"); + body->AssignCat(api->GetVariableValue(VDName)); + } + } + } + else { + body->AssignCat(api->GetVariableValue(VMethodName)); + } + + immTest = CPP_BuildOidImmTestOBJS(aMeta,api,method,Standard_False); + body->AssignCat(immTest); + body->AssignCat(" EndAccess();\n"); + + // return code + // + if (!method->Returns().IsNull()) { + body->AssignCat(" return _result;"); + } + + api->AddVariable(VMBody,body->ToCString()); + api->Apply(VMethod,"MethodTemplateDef"); + + publics->AssignCat(api->GetVariableValue(VMethod)); + } + else { + result = Standard_False; + } + + // templates for methods extraction + // + api->AddVariable(VMethodHeader,"MethodHeader"); + api->AddVariable(VConstructorHeader,"ConstructorHeader"); + api->AddVariable(VClass,oldclass->ToCString()); + + return result; +} + +// Extraction of a Persistent handle for OBJS +// +void CPP_PersistentHandleOBJS(const Handle(EDL_API)& api, + const Handle(TCollection_HAsciiString)& aClass, + const Handle(TCollection_HAsciiString)& aMother, + const Handle(TCollection_HAsciiString)& aFileName) +{ + // we create the handle... + // + api->AddVariable("%HPName",aClass->ToCString()); + api->AddVariable("%HPInherits",aMother->ToCString()); + api->Apply("%HPHandle","HandlePersistentOBJS"); + + // ...now we write the result + // + api->OpenFile("HTFile",aFileName->ToCString()); + api->WriteFile("HTFile","%HPHandle"); + api->CloseFile("HTFile"); +} + + +// Extraction of a persistent .ixx .jxx and _0.cxx +// the supplement variable is used for non inline methods generated +// by the extractor like destructor (added to .ixx ans _0.cxx +// +void CPP_PersistentDerivatedOBJS(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile, + const Handle(TColStd_HSequenceOfHAsciiString)& inclist, + const Handle(TColStd_HSequenceOfHAsciiString)& supplement) +{ + Standard_Integer i; + Handle(TCollection_HAsciiString) aFileName = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + // we do this only on standard classes (not on inst classes) + // + if (theClass.IsNull()) return; + + api->AddVariable(VClass,aClass->FullName()->ToCString()); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= inclist->Length(); i++) { + api->AddVariable(VIClass,inclist->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + } + + if (theClass->GetMyCreator().IsNull()) { + // include the hxx of me + // + api->AddVariable(VIClass,aClass->FullName()->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + + api->AddVariable(VoutClass,result->ToCString()); + + aFileName->AssignCat(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + aFileName->AssignCat(".jxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + result->Clear(); + outfile->Append(aFileName); + } + + CPP_ClassTypeMgt(aMeta,api,aClass,VTypeMgt); + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + + if (theClass->GetMyCreator().IsNull()) { + aFileName->AssignCat(".ixx"); + } + else { + aFileName->AssignCat("_0.cxx"); + } + + // Supplement + // + if (theClass->GetMyCreator().IsNull()) { + result->Clear(); + } + + for (i = 1; i <= supplement->Length(); i++) { + result->AssignCat(supplement->Value(i)); + } + + api->AddVariable(VSupplement,result->ToCString()); + + // Methods + // + result->Clear(); + + api->AddVariable(VIClass,MS::GetPersistentRootName()->ToCString()); + api->Apply(VMethods,"DownCast"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->Apply(VMethods,"DynamicType"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->AddVariable(VIClass,aClass->GetInheritsNames()->Value(1)->ToCString()); + api->Apply(VMethods,"IsKind"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->Apply(VMethods,"FullEmptyHandleDestructorTemplate"); + result->AssignCat(api->GetVariableValue(VMethods)); + + if (!theClass->Deferred()) { + api->Apply(VMethods,"PersistentAllocationOBJS"); + result->AssignCat(api->GetVariableValue(VMethods)); + } + else { + api->Apply(VMethods,"PersistentAllocationOBJSDeferred"); + result->AssignCat(api->GetVariableValue(VMethods)); + } + + if (!theClass->GetMyCreator().IsNull()) { + CPP_GenericDefine(aMeta,api,theClass->GetMyCreator(),VTICDefines,VTICUndefines,Standard_True); + result->AssignCat(api->GetVariableValue(VTICDefines)); + + // CLE + Handle(MS_GenClass) aGenClassCreator = Handle(MS_GenClass)::DownCast(aMeta->GetType(theClass->GetMyCreator()->GenClass())); + + api->AddVariable(VDName,aGenClassCreator->FullName()->ToCString()); + api->AddVariable(VDValue,theClass->GetMyCreator()->FullName()->ToCString()); + api->Apply(VTICDefines,"ItemMDTVptrDefine"); + result->AssignCat(api->GetVariableValue(VTICDefines)); + // ENDCLE + + api->AddVariable(VSuffix,"gxx"); + + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,theClass->GetMyCreator()->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + + api->Apply(VMethods,"IncludeNoSafe"); + result->AssignCat(api->GetVariableValue(VMethods)); + } + + if (theClass->GetMyCreator().IsNull()) { + api->AddVariable(VSuffix,"jxx"); + } + else { + api->AddVariable(VSuffix,"hxx"); + } + + api->AddVariable(VMethods,result->ToCString()); + api->Apply(VoutClass,"PersistentOBJSIxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + + outfile->Append(aFileName); +} + +// build a return, parameter or field type in c++ +// return a or a Handle_ +// +Handle(TCollection_HAsciiString) CPP_BuildTypeOBJS(const Handle(MS_MetaSchema)& aMeta, + const Handle(TCollection_HAsciiString)& aTypeName) +{ + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_Type) aType; + + if (aMeta->IsDefined(aTypeName)) { + aType = aMeta->GetType(aTypeName); + + if (aType->IsKind(STANDARD_TYPE(MS_Alias))) { + Handle(MS_Alias) analias = *((Handle(MS_Alias)*)&aType); + + aType = aMeta->GetType(analias->DeepType()); + } + + if (aType->IsKind(STANDARD_TYPE(MS_Class))) { + Handle(MS_Class) aClass; + + aClass = *((Handle(MS_Class)*)&aType); + + if (aClass->IsPersistent()) { + result->AssignCat("Handle_"); + result->AssignCat(aTypeName); + } + else if (aClass->IsTransient()) { + ErrorMsg << "CPPExt" << "type " << aType->FullName()->ToCString() << " is Transient an cannot be a field of a Persistent capable class" << endm; + Standard_NoSuchObject::Raise(); + } + else { + result->AssignCat(aTypeName); + } + } + else { + result->AssignCat(aTypeName); + } + } + else { + ErrorMsg << "CPPExt" << "type " << aType->FullName()->ToCString() << " not defined..." << endm; + Standard_NoSuchObject::Raise(); + } + + return result; +} + +// Build a c++ field +// +Handle(TCollection_HAsciiString) CPP_BuildFieldOBJS(const Handle(MS_MetaSchema)& aMeta, + const Handle(MS_Field)& aField) +{ + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_Type) aType; + Handle(TColStd_HSequenceOfInteger) dim; + Standard_Integer i; + + result->AssignCat(CPP_BuildTypeOBJS(aMeta,aField->TYpe())); + result->AssignCat(" "); + result->AssignCat(aField->Name()); + + dim = aField->Dimensions(); + + for (i = 1; i <= dim->Length(); i++) { + result->AssignCat("["); + result->AssignCat(new TCollection_HAsciiString(dim->Value(i))); + result->AssignCat("]"); + } + + result->AssignCat(";\n"); + + return result; +} + +// Extraction of a persistent class (inst or std) +// +void CPP_PersistentClassOBJS(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile) +{ + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + if (!theClass.IsNull()) { + Standard_Integer i,j; + + Handle(MS_HSequenceOfMemberMet) methods = theClass->GetMethods(); + Handle(MS_Method) friendmethod; + Handle(TCollection_HAsciiString) publics = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) protecteds = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) privates = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) SuppMethod = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) SuppOIDMethod = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) oidpubmethods = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) oidpromethods = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) oidprimethods = new TCollection_HAsciiString; + + Handle(TColStd_HSequenceOfHAsciiString) Supplement = new TColStd_HSequenceOfHAsciiString; + Standard_Boolean HasInlineMethod = Standard_False, + HasDestructor = Standard_False, + HasEmptyConst = Standard_False, + HasConstructor = Standard_False; + + Handle(TColStd_HSequenceOfHAsciiString) List = new TColStd_HSequenceOfHAsciiString; + Handle(TColStd_HSequenceOfHAsciiString) incp = new TColStd_HSequenceOfHAsciiString; + + api->AddVariable(VTICIncludes,""); + api->AddVariable(VTICPublicfriends,""); + api->AddVariable(VTICProtectedfields,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICDefines,""); + api->AddVariable(VTICInlineIncludes,""); + api->AddVariable(VTICUndefines,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICPrivatefields,""); + api->AddVariable(VSuffix,""); + api->AddVariable(VTICSuppMethod,""); + + api->AddVariable(VClass,theClass->FullName()->ToCString()); + api->AddVariable(VInherits,theClass->GetInheritsNames()->Value(1)->ToCString()); + + for (i = 1; i <= theClass->GetFriendsNames()->Length(); i++) { + publics->AssignCat("friend "); + api->AddVariable(VIClass,theClass->GetFriendsNames()->Value(i)->ToCString()); + api->Apply(VTICPublicfriends,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICPublicfriends)); + } + + if (!CPP_SetFriendMethod(aMeta,api,theClass->GetFriendMets(),publics)) { + ErrorMsg << "CPPExt" << "a friend method was not found..." << endm; + Standard_NoSuchObject::Raise(); + } + + api->AddVariable(VTICPublicfriends,publics->ToCString()); + + publics->Clear(); + + // extraction of the methods : BEGIN + // + Handle(TCollection_HAsciiString) aliasMethod; + + for (i = 1; i <= methods->Length(); i++) { + aliasMethod.Nullify(); + + if (methods->Value(i)->IsInline()) { + HasInlineMethod = Standard_True; + } + + // if the class has no destructor, we give it + // + if (methods->Value(i)->IsDestructor()) { + HasDestructor = Standard_True; + } + + if (methods->Value(i)->IsKind(STANDARD_TYPE(MS_Construc))) { + if (methods->Value(i)->Params().IsNull()) { + HasEmptyConst = Standard_True; + } + else { + Handle(MS_HArray1OfParam) aParseq = methods->Value(i)->Params(); + Standard_Boolean hasDefault = Standard_True; + Handle(MS_Param) aParam; + if(!aParseq.IsNull()) { + for(j = 1; j <= aParseq->Length() && hasDefault; j++) { + aParam = aParseq->Value(j); + + if (!aParam->IsKind(STANDARD_TYPE(MS_ParamWithValue))) { + hasDefault = Standard_False; + } + } + } + + if (hasDefault) { + HasEmptyConst = Standard_True; + } + } + + HasConstructor = Standard_True; + } + else { + if (!methods->Value(i)->Returns().IsNull()) { + MS::DispatchUsedType(aMeta,methods->Value(i)->Returns()->Type(),List,incp,Standard_True); + } + } + + if (!methods->Value(i)->IsAlias().IsNull() || methods->Value(i)->IsDestructor()) { + aliasMethod = CPP_BuildAliasMethod(aMeta,api,methods->Value(i)); + } + + // Function Call c++ comment : + // it s must be in the _0.cxx or ixx file + // so we add it in the supplement sequence + // + if (methods->Value(i)->IsFunctionCall()) { + SuppMethod->AssignCat(CPP_BuildAliasMethod(aMeta,api,methods->Value(i))); + } + + CPP_BuildMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + + api->Apply(VMethod,"MethodTemplateDec"); + + if (methods->Value(i)->Private()) { + privates->AssignCat(api->GetVariableValue(VMethod)); + + if (methods->Value(i)->IsKind(STANDARD_TYPE(MS_InstMet))) { + CPP_BuildOidOBJSMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + api->Apply(VMethod,"MethodTemplateDec"); + oidprimethods->AssignCat(api->GetVariableValue(VMethod)); + CPP_BuildOidMethodCallOBJS(aMeta,api,methods->Value(i),SuppOIDMethod); + } + + if (!aliasMethod.IsNull()) { + privates->AssignCat(aliasMethod); + } + } + else if ((theClass->Deferred() && methods->Value(i)->IsKind(STANDARD_TYPE(MS_Construc))) || + methods->Value(i)->IsProtected()) { + protecteds->AssignCat(api->GetVariableValue(VMethod)); + + if (methods->Value(i)->IsKind(STANDARD_TYPE(MS_InstMet))) { + CPP_BuildOidOBJSMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + api->Apply(VMethod,"MethodTemplateDec"); + oidpromethods->AssignCat(api->GetVariableValue(VMethod)); + CPP_BuildOidMethodCallOBJS(aMeta,api,methods->Value(i),SuppOIDMethod); + } + + if (!aliasMethod.IsNull()) { + protecteds->AssignCat(aliasMethod); + } + } + else { + publics->AssignCat(api->GetVariableValue(VMethod)); + + if (methods->Value(i)->IsKind(STANDARD_TYPE(MS_InstMet))) { + CPP_BuildOidOBJSMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + api->Apply(VMethod,"MethodTemplateDec"); + oidpubmethods->AssignCat(api->GetVariableValue(VMethod)); + CPP_BuildOidMethodCallOBJS(aMeta,api,methods->Value(i),SuppOIDMethod); + } + + if (!aliasMethod.IsNull()) { + publics->AssignCat(aliasMethod); + } + } + } // methods extraction : END + + if (!HasDestructor) { + api->Apply(VMethod,"EmptyDestructorTemplate"); + publics->AssignCat(api->GetVariableValue(VMethod)); + } + + if (!HasEmptyConst) { + api->AddVariable("%Class",aClass->FullName()->ToCString()); + api->AddVariable("%Arguments"," "); + api->Apply(VMethod,"ConstructorHeader"); + api->AddVariable(VMBody,""); + api->Apply(VMethod,"MethodTemplateDef"); + publics->AssignCat(api->GetVariableValue(VMethod)); + + // WARNING: here is a trap + // + HasEmptyConst = Standard_True; + } + + api->AddVariable(VTICPublicmets,publics->ToCString()); + api->AddVariable(VTICPrivatemets,privates->ToCString()); + api->AddVariable(VTICProtectedmets,protecteds->ToCString()); + api->AddVariable(VTICOidpubMet,oidpubmethods->ToCString()); + api->AddVariable(VTICOidproMet,oidpromethods->ToCString()); + api->AddVariable(VTICOidpriMet,oidprimethods->ToCString()); + + publics->Clear(); + privates->Clear(); + protecteds->Clear(); + oidpubmethods->Clear(); + oidpromethods->Clear(); + oidprimethods->Clear(); + + // extraction of fields + // + Handle(MS_HSequenceOfField) fields = theClass->GetFields(); + + for (i = 1; i <= fields->Length(); i++) { + if (fields->Value(i)->Protected()) { + protecteds->AssignCat(CPP_BuildFieldOBJS(aMeta,fields->Value(i))); + } + else { + privates->AssignCat(CPP_BuildFieldOBJS(aMeta,fields->Value(i))); + } + } + + api->AddVariable(VTICPrivatefields,privates->ToCString()); + api->AddVariable(VTICProtectedfields,protecteds->ToCString()); + + publics->Clear(); + privates->Clear(); + protecteds->Clear(); + + // others inline methods and functions (ex. function call) + // + // api->AddVariable(VTICSuppMethod,SuppMethod->ToCString()); + + // include the lxx if the class have inline methods + // + if (HasInlineMethod) { + Handle(MS_InstClass) aCreator = theClass->GetMyCreator(); + + if (aCreator.IsNull()) { + api->AddVariable(VIClass,theClass->FullName()->ToCString()); + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeNoSafe"); + } + // this part is for class created by instantiations + // + else { + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,aCreator->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeMDTVNoSafe"); + + CPP_GenericMDTVDefineOBJS(aMeta,api,aCreator,VTICDefines,VTICUndefines,Standard_True); + } + } + + CPP_UsedTypes(aMeta,theClass,List,incp); + + publics->Clear(); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= List->Length(); i++) { + if (!List->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,List->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VTICIncludes,"IncludeNoSafe"); +#else + api->Apply(VTICIncludes,"Include"); +#endif + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + + for (i = 1; i <= incp->Length(); i++) { + if (!incp->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,incp->Value(i)->ToCString()); + api->Apply(VTICIncludes,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + api->AddVariable(VTICIncludes,publics->ToCString()); + + api->Apply(VoutClass,"PersistentOBJSInstClass"); + + // we write the .hxx of this class + // + Handle(TCollection_HAsciiString) aFile = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFile->AssignCat(theClass->FullName()); + aFile->AssignCat(".hxx"); + + CPP_WriteFile(api,aFile,VoutClass); + + outfile->Append(aFile); + + // .ixx or _0.cxx + // + if (!HasDestructor) { + api->Apply("%Destructor","FullEmptyDestructorTemplate"); + } + else { + api->AddVariable("%Destructor"," "); + } + + api->AddVariable("%MethodOID",SuppOIDMethod->ToCString()); + CPP_PersistentDerivatedOBJS(aMeta,api,aClass,outfile,incp,Supplement); + } + else { + ErrorMsg << "CPPExt" << "CPP_PersistentClassOBJS - the class is NULL..." << endm; + Standard_NoSuchObject::Raise(); + } +} + diff --git a/src/CPPExt/CPPExt_PersistentOBJY.cxx b/src/CPPExt/CPPExt_PersistentOBJY.cxx new file mode 100755 index 0000000..d737f80 --- /dev/null +++ b/src/CPPExt/CPPExt_PersistentOBJY.cxx @@ -0,0 +1,987 @@ +// CLE +// +// 10/1995 +// +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include +#include + +static Standard_CString VTICOidpubMet = "%TICOidpubMet", + VTICOidproMet = "%TICOidproMet", + VTICOidpriMet = "%TICOidpriMet"; + +Handle(TCollection_HAsciiString) CPP_BuildTypeOBJY(const Handle(MS_MetaSchema)& aMeta, + const Handle(TCollection_HAsciiString)& aTypeName); + +// create the defines and the undefines that are around the include of +// a generic .lxx +// ex. : +// //MDTV#define ItemHArray1 Quantity_Color +// //MDTV#define ItemHArray1_hxx +// //MDTV#define TheArray1 Quantity_Array1OfColor +// //MDTV#define TheArray1_hxx +// //MDTV#define TCollection_HArray1 Quantity_HArray1OfColor +// //MDTV#define TCollection_HArray1_hxx +// //MDTV#include +// //MDTV#undef ItemHArray1 +// //MDTV#undef ItemHArray1_hxx +// //MDTV#undef TheArray1 +// //MDTV#undef TheArray1_hxx +// //MDTV#undef TCollection_HArray1 +// //MDTV#undef TCollection_HArray1_hxx +// +void CPP_GenericMDTVDefineOBJY(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_InstClass)& aCreator, + const Standard_CString VARDefine, + const Standard_CString VARUndefine, + const Standard_Boolean handleUsed) +{ +// Handle(MS_GenClass) aGenClass = Handle(MS_GenClass)::DownCast(aMeta->GetType(aCreator->GenClass())); +// Handle(TColStd_HSequenceOfHAsciiString) theGenTypes = aCreator->GenTypes(); +// Handle(TCollection_HAsciiString) publics = new TCollection_HAsciiString, +// protecteds = new TCollection_HAsciiString; +// Standard_Integer i; + + +// for (i = 1; i <= theGenTypes->Length(); i++) { +// if (!aGenClass->FullName()->IsSameString(theGenTypes->Value(i))) { +// api->AddVariable(VDName,theGenTypes->Value(i)->ToCString()); +// api->AddVariable(VDValue,CPP_BuildType(aMeta,aCreator->InstTypes()->Value(i))->ToCString()); +// api->Apply(VARDefine,"ItemMDTVDefine"); +// api->Apply(VARUndefine,"ItemMDTVUndefine"); +// publics->AssignCat(api->GetVariableValue(VARDefine)); +// protecteds->AssignCat(api->GetVariableValue(VARUndefine)); +// } +// } + +// api->AddVariable(VDName,aGenClass->FullName()->ToCString()); +// api->AddVariable(VDValue,aCreator->FullName()->ToCString()); +// api->Apply(VARDefine,"ItemMDTVDefine"); +// api->Apply(VARUndefine,"ItemMDTVUndefine"); +// publics->AssignCat(api->GetVariableValue(VARDefine)); +// protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + + // #define TCollection_HSequence_Type_() TColStd_HSequenceOfTransient_Type_() + // #define Handle_TCollection_HSequence Handle_TColStd_HSequenceOfTransient + // +// if (handleUsed) { +// api->AddVariable(VDName,aGenClass->FullName()->ToCString()); +// api->AddVariable(VDValue,aCreator->FullName()->ToCString()); +// api->Apply(VARDefine,"ItemHandleMDTVDefine"); +// api->Apply(VARUndefine,"ItemHandleMDTVUndefine"); +// publics->AssignCat(api->GetVariableValue(VARDefine)); +// protecteds->AssignCat(api->GetVariableValue(VARUndefine)); +// } + +// api->AddVariable(VARDefine,publics->ToCString()); +// api->AddVariable(VARUndefine,protecteds->ToCString()); + Handle(MS_GenClass) aGenClass = Handle(MS_GenClass)::DownCast(aMeta->GetType(aCreator->GenClass())); + Handle(TColStd_HSequenceOfHAsciiString) theGenTypes = aCreator->GenTypes(); + Handle(TCollection_HAsciiString) publics = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) protecteds = new TCollection_HAsciiString; + Standard_Integer i, + itemLength; + Handle(MS_HSequenceOfGenType) realGentypes = aGenClass->GenTypes(); + + // we need this length because for item we must call + // CPP_BuildType and for nested class name we dont need. + // + itemLength = aGenClass->GenTypes()->Length(); + + for (i = 1; i <= theGenTypes->Length(); i++) { + if (!aGenClass->FullName()->IsSameString(theGenTypes->Value(i))) { + api->AddVariable(VDName,theGenTypes->Value(i)->ToCString()); + + // real name or Handle_name + // + if (i <= itemLength) { + if (!realGentypes->Value(i)->TYpeName().IsNull()) { + if (aMeta->IsDefined(realGentypes->Value(i)->TYpeName())) { + Handle(MS_Type) t = aMeta->GetType(realGentypes->Value(i)->TYpeName()); + + if (t->IsKind(STANDARD_TYPE(MS_Class))) { + Handle(MS_Class) c = *((Handle(MS_Class)*)&t); + + // if the items constraint is handled, the item is not the handle, + // like in other cases, but the type himself. + // + // ex. : the item : 'i' as transient + // will be defined as #define i class + // the item : 'i' as any + // will be defined as #define i Handle_Class + // + if (c->IsPersistent() || c->IsTransient()) { + api->AddVariable(VDValue,aCreator->InstTypes()->Value(i)->ToCString()); + api->Apply(VARDefine,"ItemMDTVConstraintHandle"); + api->Apply(VARUndefine,"ItemMDTVConstraintHandleUndef"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + else { + api->AddVariable(VDValue,CPP_BuildTypeOBJY(aMeta,aCreator->InstTypes()->Value(i))->ToCString()); + } + } + } + } + else { + api->AddVariable(VDValue,CPP_BuildTypeOBJY(aMeta,aCreator->InstTypes()->Value(i))->ToCString()); + } + api->AddVariable("%DBaseValue",aCreator->InstTypes()->Value(i)->ToCString()); + } + // real name + // + else { + api->AddVariable(VDValue,aCreator->InstTypes()->Value(i)->ToCString()); + api->AddVariable("%DBaseValue",aCreator->InstTypes()->Value(i)->ToCString()); + } + + api->Apply(VARDefine,"ItemMDTVDefine"); + api->Apply(VARUndefine,"ItemMDTVUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + } + + for (i = itemLength + 1; i <= theGenTypes->Length(); i++) { + if (!aGenClass->FullName()->IsSameString(theGenTypes->Value(i))) { + Handle(TCollection_HAsciiString) realName = CPP_BuildTypeOBJY(aMeta,aCreator->InstTypes()->Value(i)); + + if (!realName->IsSameString(aCreator->InstTypes()->Value(i))) { + api->AddVariable(VDName,theGenTypes->Value(i)->ToCString()); + api->AddVariable(VDValue,aCreator->InstTypes()->Value(i)->ToCString()); + api->Apply(VARDefine,"ItemHandleMDTVDefine"); + api->Apply(VARUndefine,"ItemHandleMDTVUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + } + } + + api->AddVariable(VDName,aGenClass->FullName()->ToCString()); + api->AddVariable(VDValue,aCreator->FullName()->ToCString()); + api->AddVariable("%DBaseValue",aCreator->FullName()->ToCString()); + + api->Apply(VARDefine,"ItemMDTVDefine"); + api->Apply(VARUndefine,"ItemMDTVUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + + // #define TCollection_HSequence_Type_() TColStd_HSequenceOfTransient_Type_() + // #define Handle_TCollection_HSequence Handle_TColStd_HSequenceOfTransient + // + if (aGenClass->IsTransient() || aGenClass->IsPersistent()) { + api->AddVariable(VDName,aGenClass->FullName()->ToCString()); + api->AddVariable(VDValue,aCreator->FullName()->ToCString()); + api->Apply(VARDefine,"ItemHandleMDTVDefine"); + api->Apply(VARUndefine,"ItemHandleMDTVUndefine"); + publics->AssignCat(api->GetVariableValue(VARDefine)); + protecteds->AssignCat(api->GetVariableValue(VARUndefine)); + } + + api->AddVariable(VARDefine,publics->ToCString()); + api->AddVariable(VARUndefine,protecteds->ToCString()); +} + +// create a VArray OBJY dependent declaration for DBC instance +// look EDL template : VArrayFieldOBJY +// +void CPP_BuildVArrayDeclarationOBJY(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_StdClass)& aClass, + const Handle(TCollection_HAsciiString)& Result) +{ +// if (!aClass->GetMyCreator().IsNull()) { +// Handle(MS_InstClass) anInst = aClass->GetMyCreator(); +// Handle(TCollection_HAsciiString) aGen = anInst->GenClass(); +// +// if (aGen->IsSameString(MS::GetVArrayRootName())) { +// api->AddVariable(VDName,aClass->FullName()->ToCString()); +// api->AddVariable(VDValue,anInst->InstTypes()->Value(1)->ToCString()); +// api->Apply(VDValue,"VArrayDeclareOBJY"); +// Result->AssignCat(api->GetVariableValue(VDValue)); +// } +// } +} + +// create a VArray OBJY dependent field for DBC instance +// look EDL template : VArrayFieldOBJY +// +void CPP_BuildVArrayFieldOBJY(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_StdClass)& aClass, + const Handle(TCollection_HAsciiString)& Result) +{ +// if (!aClass->GetMyCreator().IsNull()) { +// Handle(MS_InstClass) anInst = aClass->GetMyCreator(); +// Handle(TCollection_HAsciiString) aGen = anInst->GenClass(); + +// if (aGen->IsSameString(MS::GetVArrayRootName())) { +// api->AddVariable(VDName,aClass->FullName()->ToCString()); +// api->AddVariable(VDValue,anInst->InstTypes()->Value(1)->ToCString()); +// api->Apply(VDValue,"VArrayFieldOBJY"); +// Result->AssignCat(api->GetVariableValue(VDValue)); +// } +// } +} + +// build a c++ declaration method +// the result is in the EDL variable VMethod +// +// template used : +// +// MethodTemplateDef +// ConstructorTemplateDef +// MethodTemplateDec +// ConstructorTemplateDec +// InlineMethodTemplateDec +// +// the EDL variables : +// VMethodHeader : must contains the name of the template used for +// methods construction +// VConstructorHeader : must contains the name of the template used for +// constructors construction +// +void CPP_BuildOidOBJYMethod(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Method)& m, + const Handle(TCollection_HAsciiString)& methodName, + const Standard_Boolean forDeclaration = Standard_True) +{ + Handle(MS_InstMet) im; + Handle(MS_ClassMet) cm; + Handle(MS_Construc) ct; + Handle(MS_Param) retType; + + Handle(TCollection_HAsciiString) MetTemplate, + ConTemplate; + + Standard_Boolean InlineMethod; + + MetTemplate = api->GetVariableValue(VMethodHeader); + ConTemplate = api->GetVariableValue(VConstructorHeader); + + // here we process all the common attributes of methods + // + api->AddVariable(VMethodName,methodName->ToCString()); + api->AddVariable(VVirtual,""); + + // it s inline method ? + // + api->AddVariable(VIsInline,"yes"); + InlineMethod = Standard_True; + + api->AddVariable(VRetSpec,""); + + // it s returning & ? + // + if (m->IsRefReturn()) { + api->AddVariable(VAnd,"&"); + } + else { + api->AddVariable(VAnd,""); + } + + api->AddVariable(VArgument,CPP_BuildParameterList(aMeta,m->Params(),forDeclaration)->ToCString()); + + // it s returning a type or void + // + retType = m->Returns(); + + if (!retType.IsNull()) { + api->AddVariable(VReturn,CPP_BuildType(aMeta,retType->TypeName())->ToCString()); + } + else { + api->AddVariable(VReturn,"void"); + } + + // now the specials attributes + // + // instance methods + // + if (m->IsKind(STANDARD_TYPE(MS_InstMet))) { + im = *((Handle(MS_InstMet)*)&m); + + api->AddVariable(VIsCreateMethod,"no"); + api->AddVariable(VMetSpec,""); + api->Apply(VMethod,MetTemplate->ToCString()); + api->Apply(VMethod,"InlineMethodTemplateDec"); + } +} + +Handle(TCollection_HAsciiString) CPP_BuildOidImmTestOBJY(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Method)& Method, + const Standard_Boolean UseMutability) +{ + Handle(TCollection_HAsciiString) body = new TCollection_HAsciiString; + Standard_Integer i; + Standard_Boolean testResult; + Handle(MS_HArray1OfParam) aSeqParam = Method->Params(); + + api->AddVariable(VMethodName,Method->Name()->ToCString()); + + if(!aSeqParam.IsNull()) { + for (i = 1; i <= aSeqParam->Length(); i++) { + if (aSeqParam->Value(i)->Type()->IsKind(STANDARD_TYPE(MS_Class))) { + Handle(MS_Type) pType = aSeqParam->Value(i)->Type(); + Handle(MS_Class) aPersClass = *((Handle_MS_Class*)&pType); + + if (UseMutability) { + testResult = aSeqParam->Value(i)->IsMutable(); + } + else { + testResult = aSeqParam->Value(i)->IsOut(); + } + + if (testResult && aPersClass->IsPersistent()) { + api->AddVariable(VDName,aSeqParam->Value(i)->Name()->ToCString()); + api->Apply(VDName,"ImmutableTestOBJY"); + body->AssignCat(api->GetVariableValue(VDName)); + } + } + } + } + return body; +} + +// Build the list of call for persistent oid methods and set the result at the end of +// publics +// +Standard_Boolean CPP_BuildOidMethodCallOBJY(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Method)& Method, + const Handle(TCollection_HAsciiString)& publics) +{ + if (publics.IsNull()) return Standard_False; + + Handle(MS_InstMet) method = Handle(MS_InstMet)::DownCast(Method); + Standard_Integer i; + Standard_Boolean result = Standard_True; + Handle(TCollection_HAsciiString) aname, + oldclass = api->GetVariableValue(VClass), + body, + immTest; + Handle(MS_HArray1OfParam) aSeqParam; + + // templates for methods extraction + // + api->AddVariable(VMethodHeader,"ExternalMethodHeader"); + api->AddVariable(VConstructorHeader,"ExternalConstructorHeader"); + + if (!method.IsNull()) { + body = new TCollection_HAsciiString; + + aSeqParam = method->Params(); + + aname = new TCollection_HAsciiString("Oid_"); + aname->AssignCat(method->Class()); + + // method header + // + api->AddVariable(VClass,aname->ToCString()); + CPP_BuildOidOBJYMethod(aMeta,api,method,method->Name(),Standard_False); + + api->AddVariable(VClass,method->Class()->ToCString()); + api->AddVariable(VMethodName,method->Name()->ToCString()); + + // parameters + // + aname = new TCollection_HAsciiString(method->Name()); + aname->AssignCat("("); + + immTest = CPP_BuildOidImmTestOBJY(aMeta,api,method,Standard_True); + + body->AssignCat(immTest); + + // method call signature + // + + if (!aSeqParam.IsNull()) { + aname->AssignCat(aSeqParam->Value(1)->Name()); + + for (i = 2; i <= aSeqParam->Length(); i++) { + aname->AssignCat(","); + aname->AssignCat(aSeqParam->Value(i)->Name()); + } + } + + aname->AssignCat(")"); + + // method call + // + api->AddVariable(VMethodName,aname->ToCString()); + + if (method->IsConst()) { + api->Apply(VMethodName,"ReadAccessOBJY"); + } + else { + api->Apply(VMethodName,"UpdateAccessOBJY"); + } + + // returns value + // + if (!method->Returns().IsNull()) { + body->AssignCat(CPP_BuildType(aMeta,method->Returns()->TypeName())); + body->AssignCat(" _result = "); + body->AssignCat(api->GetVariableValue(VMethodName)); + + if (method->Returns()->Type()->IsKind(STANDARD_TYPE(MS_Class))) { + if (method->Returns()->IsMutable()) { + api->AddVariable(VDName,"_result"); + api->AddVariable(VMethodName,method->Name()->ToCString()); + api->Apply(VDName,"ImmutableTestOBJY"); + body->AssignCat(api->GetVariableValue(VDName)); + } + } + } + else { + body->AssignCat(api->GetVariableValue(VMethodName)); + } + + immTest = CPP_BuildOidImmTestOBJY(aMeta,api,method,Standard_False); + body->AssignCat(immTest); + body->AssignCat(" EndAccess();\n"); + + // return code + // + if (!method->Returns().IsNull()) { + body->AssignCat(" return _result;"); + } + + api->AddVariable(VMBody,body->ToCString()); + api->Apply(VMethod,"MethodTemplateDef"); + + publics->AssignCat(api->GetVariableValue(VMethod)); + } + else { + result = Standard_False; + } + + // templates for methods extraction + // + api->AddVariable(VMethodHeader,"MethodHeader"); + api->AddVariable(VConstructorHeader,"ConstructorHeader"); + api->AddVariable(VClass,oldclass->ToCString()); + + return result; +} + +// Extraction of a Persistent handle for OBJY +// +void CPP_PersistentHandleOBJY(const Handle(EDL_API)& api, + const Handle(TCollection_HAsciiString)& aClass, + const Handle(TCollection_HAsciiString)& aMother, + const Handle(TCollection_HAsciiString)& aFileName) +{ + // we create the handle... + // + api->AddVariable("%HPName",aClass->ToCString()); + api->AddVariable("%HPInherits",aMother->ToCString()); + api->Apply("%HPHandle","HandlePersistentOBJY"); + + // ...now we write the result + // + api->OpenFile("HTFile",aFileName->ToCString()); + api->WriteFile("HTFile","%HPHandle"); + api->CloseFile("HTFile"); +} + + +// Extraction of a persistent .ixx .jxx and _0.cxx +// the supplement variable is used for non inline methods generated +// by the extractor like destructor (added to .ixx ans _0.cxx +// +void CPP_PersistentDerivatedOBJY(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile, + const Handle(TColStd_HSequenceOfHAsciiString)& inclist, + const Handle(TColStd_HSequenceOfHAsciiString)& supplement) +{ + Standard_Integer i; + Handle(TCollection_HAsciiString) aFileName = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + // we do this only on standard classes (not on inst classes) + // + if (theClass.IsNull()) return; + + api->AddVariable(VClass,aClass->FullName()->ToCString()); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= inclist->Length(); i++) { + api->AddVariable(VIClass,inclist->Value(i)->ToCString()); + api->Apply(VoutClass,"Include"); + result->AssignCat(api->GetVariableValue(VoutClass)); + } + + if (theClass->GetMyCreator().IsNull()) { + // include the hxx of me + // + api->AddVariable(VIClass,aClass->FullName()->ToCString()); + api->Apply(VoutClass,"Include"); + result->AssignCat(api->GetVariableValue(VoutClass)); + + api->AddVariable(VoutClass,result->ToCString()); + + aFileName->AssignCat(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + aFileName->AssignCat(".jxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + result->Clear(); + outfile->Append(aFileName); + } + + CPP_ClassTypeMgt(aMeta,api,aClass,VTypeMgt); + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + + if (theClass->GetMyCreator().IsNull()) { + aFileName->AssignCat(".ixx"); + } + else { + aFileName->AssignCat("_0.cxx"); + } + + // Supplement + // + if (theClass->GetMyCreator().IsNull()) { + result->Clear(); + } + + for (i = 1; i <= supplement->Length(); i++) { + result->AssignCat(supplement->Value(i)); + } + + api->AddVariable(VSupplement,result->ToCString()); + + // Methods + // + result->Clear(); + + api->AddVariable(VIClass,MS::GetPersistentRootName()->ToCString()); + api->Apply(VMethods,"DownCast"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->Apply(VMethods,"DynamicType"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->AddVariable(VIClass,aClass->GetInheritsNames()->Value(1)->ToCString()); + api->Apply(VMethods,"IsKind"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->Apply(VMethods,"FullEmptyHandleDestructorTemplate"); + result->AssignCat(api->GetVariableValue(VMethods)); + + if (!theClass->GetMyCreator().IsNull()) { + CPP_GenericDefine(aMeta,api,theClass->GetMyCreator(),VTICDefines,VTICUndefines,Standard_True); + result->AssignCat(api->GetVariableValue(VTICDefines)); + api->AddVariable(VSuffix,"gxx"); + + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,theClass->GetMyCreator()->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + + api->Apply(VMethods,"IncludeNoSafe"); + result->AssignCat(api->GetVariableValue(VMethods)); + } + + if (theClass->GetMyCreator().IsNull()) { + api->AddVariable(VSuffix,"jxx"); + } + else { + api->AddVariable(VSuffix,"hxx"); + } + + api->AddVariable(VMethods,result->ToCString()); + api->Apply(VoutClass,"PersistentOBJYIxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + + outfile->Append(aFileName); +} + +// build a return, parameter or field type in c++ +// return a or a Handle_ +// +Handle(TCollection_HAsciiString) CPP_BuildTypeOBJY(const Handle(MS_MetaSchema)& aMeta, + const Handle(TCollection_HAsciiString)& aTypeName) +{ + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_Type) aType; + + if (aMeta->IsDefined(aTypeName)) { + aType = aMeta->GetType(aTypeName); + + if (aType->IsKind(STANDARD_TYPE(MS_Alias))) { + Handle(MS_Alias) analias = *((Handle(MS_Alias)*)&aType); + + aType = aMeta->GetType(analias->DeepType()); + } + + if (aType->IsKind(STANDARD_TYPE(MS_Class))) { + Handle(MS_Class) aClass; + + aClass = *((Handle(MS_Class)*)&aType); + + if (aClass->IsPersistent()) { + result->AssignCat("PHandle_"); + result->AssignCat(aTypeName); + } + else if (aClass->IsTransient()) { + ErrorMsg << "CPPExt" << "type " << aType->FullName()->ToCString() << " is Transient an cannot be a field of a Persistent capable class" << endm; + Standard_NoSuchObject::Raise(); + } + else { + result->AssignCat(aTypeName); + } + } + else { + result->AssignCat(aTypeName); + } + } + else { + ErrorMsg << "CPPExt" << "type " << aType->FullName()->ToCString() << " not defined..." << endm; + Standard_NoSuchObject::Raise(); + } + + return result; +} + +// Build a c++ field +// +Handle(TCollection_HAsciiString) CPP_BuildFieldOBJY(const Handle(MS_MetaSchema)& aMeta, + const Handle(MS_Field)& aField) +{ + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_Type) aType; + Handle(TColStd_HSequenceOfInteger) dim; + Standard_Integer i; + + result->AssignCat(CPP_BuildTypeOBJY(aMeta,aField->TYpe())); + result->AssignCat(" "); + result->AssignCat(aField->Name()); + + dim = aField->Dimensions(); + + for (i = 1; i <= dim->Length(); i++) { + result->AssignCat("["); + result->AssignCat(new TCollection_HAsciiString(dim->Value(i))); + result->AssignCat("]"); + } + + result->AssignCat(";\n"); + + return result; +} + +// Extraction of a persistent class (inst or std) +// +void CPP_PersistentClassOBJY(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile) +{ + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + if (!theClass.IsNull()) { + Standard_Integer i; + + Handle(MS_HSequenceOfMemberMet) methods = theClass->GetMethods(); + Handle(MS_Method) friendmethod; + Handle(TCollection_HAsciiString) publics = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) protecteds = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) privates = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) SuppMethod = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) oidpubmethods = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) oidpromethods = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) oidprimethods = new TCollection_HAsciiString; + + Handle(TColStd_HSequenceOfHAsciiString) Supplement = new TColStd_HSequenceOfHAsciiString; + Standard_Boolean HasInlineMethod = Standard_False, + HasDestructor = Standard_False; + + Handle(TColStd_HSequenceOfHAsciiString) List = new TColStd_HSequenceOfHAsciiString; + Handle(TColStd_HSequenceOfHAsciiString) incp = new TColStd_HSequenceOfHAsciiString; + + api->AddVariable(VTICIncludes,""); + api->AddVariable(VTICPublicfriends,""); + api->AddVariable(VTICProtectedfields,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICDefines,""); + api->AddVariable(VTICInlineIncludes,""); + api->AddVariable(VTICUndefines,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICPrivatefields,""); + api->AddVariable(VSuffix,""); + api->AddVariable(VTICSuppMethod,""); + + api->AddVariable(VClass,theClass->FullName()->ToCString()); + api->AddVariable(VInherits,theClass->GetInheritsNames()->Value(1)->ToCString()); + + for (i = 1; i <= theClass->GetFriendsNames()->Length(); i++) { + publics->AssignCat("friend "); + api->AddVariable(VIClass,theClass->GetFriendsNames()->Value(i)->ToCString()); + api->Apply(VTICPublicfriends,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICPublicfriends)); + } + + if (!CPP_SetFriendMethod(aMeta,api,theClass->GetFriendMets(),publics)) { + ErrorMsg << "CPPExt" << "a friend method was not found..." << endm; + Standard_NoSuchObject::Raise(); + } + + api->AddVariable(VTICPublicfriends,publics->ToCString()); + + publics->Clear(); + + // extraction of the methods : BEGIN + // + Handle(TCollection_HAsciiString) aliasMethod; + + for (i = 1; i <= methods->Length(); i++) { + aliasMethod.Nullify(); + + if (methods->Value(i)->IsInline()) { + HasInlineMethod = Standard_True; + } + + // if the class has no destructor, we give it + // + if (methods->Value(i)->IsDestructor()) { + HasDestructor = Standard_True; + } + + if (!methods->Value(i)->IsKind(STANDARD_TYPE(MS_Construc))) { + if (!methods->Value(i)->Returns().IsNull()) { + MS::DispatchUsedType(aMeta,methods->Value(i)->Returns()->Type(),List,incp,Standard_True); + } + } + + if (!methods->Value(i)->IsAlias().IsNull() || methods->Value(i)->IsDestructor()) { + aliasMethod = CPP_BuildAliasMethod(aMeta,api,methods->Value(i)); + } + + // Function Call c++ comment : + // it s must be in the _0.cxx or ixx file + // so we add it in the supplement sequence + // + if (methods->Value(i)->IsFunctionCall()) { + SuppMethod->AssignCat(CPP_BuildAliasMethod(aMeta,api,methods->Value(i))); + } + + CPP_BuildMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + + api->Apply(VMethod,"MethodTemplateDec"); + + if (methods->Value(i)->Private()) { + privates->AssignCat(api->GetVariableValue(VMethod)); + + if (methods->Value(i)->IsKind(STANDARD_TYPE(MS_InstMet))) { + CPP_BuildOidOBJYMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + api->Apply(VMethod,"MethodTemplateDec"); + oidprimethods->AssignCat(api->GetVariableValue(VMethod)); + CPP_BuildOidMethodCallOBJY(aMeta,api,methods->Value(i),SuppMethod); + } + + if (!aliasMethod.IsNull()) { + privates->AssignCat(aliasMethod); + } + } + else if ((theClass->Deferred() && methods->Value(i)->IsKind(STANDARD_TYPE(MS_Construc))) || + methods->Value(i)->IsProtected()) { + protecteds->AssignCat(api->GetVariableValue(VMethod)); + + if (methods->Value(i)->IsKind(STANDARD_TYPE(MS_InstMet))) { + CPP_BuildOidOBJYMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + api->Apply(VMethod,"MethodTemplateDec"); + oidpromethods->AssignCat(api->GetVariableValue(VMethod)); + CPP_BuildOidMethodCallOBJY(aMeta,api,methods->Value(i),SuppMethod); + } + + if (!aliasMethod.IsNull()) { + protecteds->AssignCat(aliasMethod); + } + } + else { + publics->AssignCat(api->GetVariableValue(VMethod)); + + if (methods->Value(i)->IsKind(STANDARD_TYPE(MS_InstMet))) { + CPP_BuildOidOBJYMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + api->Apply(VMethod,"MethodTemplateDec"); + oidpubmethods->AssignCat(api->GetVariableValue(VMethod)); + CPP_BuildOidMethodCallOBJY(aMeta,api,methods->Value(i),SuppMethod); + } + + if (!aliasMethod.IsNull()) { + publics->AssignCat(aliasMethod); + } + } + } // methods extraction : END + + if (!HasDestructor) { + api->Apply(VMethod,"EmptyDestructorTemplate"); + publics->AssignCat(api->GetVariableValue(VMethod)); + } + + api->AddVariable(VTICPublicmets,publics->ToCString()); + api->AddVariable(VTICPrivatemets,privates->ToCString()); + api->AddVariable(VTICProtectedmets,protecteds->ToCString()); + api->AddVariable(VTICOidpubMet,oidpubmethods->ToCString()); + api->AddVariable(VTICOidproMet,oidpromethods->ToCString()); + api->AddVariable(VTICOidpriMet,oidprimethods->ToCString()); + + publics->Clear(); + privates->Clear(); + protecteds->Clear(); + oidpubmethods->Clear(); + oidpromethods->Clear(); + oidprimethods->Clear(); + + // extraction of fields + // + Handle(MS_HSequenceOfField) fields = theClass->GetFields(); + + for (i = 1; i <= fields->Length(); i++) { + if (fields->Value(i)->Protected()) { + protecteds->AssignCat(CPP_BuildFieldOBJY(aMeta,fields->Value(i))); + } + else { + privates->AssignCat(CPP_BuildFieldOBJY(aMeta,fields->Value(i))); + } + } + + api->AddVariable(VTICPrivatefields,privates->ToCString()); + api->AddVariable(VTICProtectedfields,protecteds->ToCString()); + + publics->Clear(); + privates->Clear(); + protecteds->Clear(); + + // others inline methods and functions (ex. function call) + // + api->AddVariable(VTICSuppMethod,SuppMethod->ToCString()); + + // include the lxx if the class have inline methods + // + if (HasInlineMethod) { + Handle(MS_InstClass) aCreator = theClass->GetMyCreator(); + + if (aCreator.IsNull()) { + api->AddVariable(VIClass,theClass->FullName()->ToCString()); + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeNoSafe"); + } + // this part is for class created by instantiations + // + else { + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,aCreator->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeMDTVNoSafe"); + + CPP_GenericMDTVDefineOBJY(aMeta,api,aCreator,VTICDefines,VTICUndefines,Standard_True); + } + } + + CPP_UsedTypes(aMeta,theClass,List,incp); + + publics->Clear(); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= List->Length(); i++) { + if (!List->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,List->Value(i)->ToCString()); + api->Apply(VTICIncludes,"Include"); + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + + for (i = 1; i <= incp->Length(); i++) { + if (!incp->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,incp->Value(i)->ToCString()); + api->Apply(VTICIncludes,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + api->AddVariable(VTICIncludes,publics->ToCString()); + + api->Apply(VoutClass,"PersistentOBJYInstClass"); + + // we write the .hxx of this class + // + Handle(TCollection_HAsciiString) aFile = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFile->AssignCat(theClass->FullName()); + aFile->AssignCat("_objy.ddl"); + + CPP_WriteFile(api,aFile,VoutClass); + + outfile->Append(aFile); + + // .ixx or _0.cxx + // + if (!HasDestructor) { + api->Apply(VMethod,"FullEmptyDestructorTemplate"); + Supplement->Append(new TCollection_HAsciiString(api->GetVariableValue(VMethod))); + } + + CPP_PersistentDerivatedOBJY(aMeta,api,aClass,outfile,incp,Supplement); + } + else { + ErrorMsg << "CPPExt" << "CPP_PersistentClassOBJY - the class is NULL..." << endm; + Standard_NoSuchObject::Raise(); + } +} + diff --git a/src/CPPExt/CPPExt_Pointer.cxx b/src/CPPExt/CPPExt_Pointer.cxx new file mode 100755 index 0000000..3cf62c2 --- /dev/null +++ b/src/CPPExt/CPPExt_Pointer.cxx @@ -0,0 +1,43 @@ +// CLE +// +// 11/1995 +// +#include + +#include + +#include +#include +#include +#include + +#include + +// Extraction of a transient class (inst or std) +// +void CPP_Pointer(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Pointer)& aPointer, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile) +{ + if (aPointer.IsNull()) return; + + Handle(TCollection_HAsciiString) aFileName; + Standard_Integer i; + + // Hxx extraction + // + api->AddVariable(VClass,aPointer->FullName()->ToCString()); + api->AddVariable(VInherits,aPointer->Type()->ToCString()); + + api->Apply(VoutClass,"PointerHXX"); + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFileName->AssignCat(aPointer->FullName()); + aFileName->AssignCat(".hxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + outfile->Append(aFileName); +} + diff --git a/src/CPPExt/CPPExt_Standard.edl b/src/CPPExt/CPPExt_Standard.edl new file mode 100755 index 0000000..e29070d --- /dev/null +++ b/src/CPPExt/CPPExt_Standard.edl @@ -0,0 +1,334 @@ +-- File: CPPExt_Standard.edl +-- Author: Kernel +-- History: Fri Dec 8 09:59:38 1995 Kernel Creation +-- Copyright: Matra Datavision 1995 + +@template HandleStandardTransient is +$#ifndef _Handle_Standard_Transient_HeaderFile +$#define _Handle_Standard_Transient_HeaderFile +$ +$#ifndef _Standard_Macro_HeaderFile +$#include +$#endif +$#ifndef _Standard_PrimitiveTypes_HeaderFile +$#include +$#endif +$#ifndef _Standard_Transient_proto_HeaderFile +$#include +$#endif +$ +$#ifndef UndefinedHandleAddress +$#ifdef DECOSF1 +$#define UndefinedHandleAddress ((Standard_Transient *)0xfefdfefdfefd0000) +$#else +$#define UndefinedHandleAddress ((Standard_Transient *)0xfefd0000) +$#endif +$#endif +$ +$class Standard_Transient; +$class Handle_Standard_Type; +$ +$Standard_Integer HashCode(const Handle(Standard_Transient)& ,const Standard_Integer); +$ +$class Handle(Standard_Transient) +$ { +$ private: +$ +$ Standard_Transient *entity; +$ +$ void RaiseNullObject(const Standard_CString S) const; +$ +$ void BeginScope() const +$ { +$ if (entity != UndefinedHandleAddress) entity->count++; +$ } +$ +$ void EndScope() +$ { +$ if (entity != UndefinedHandleAddress) +$ { +$ entity->count--; +$ if (entity->count == 0) { +$ entity->Delete(); +$ entity = UndefinedHandleAddress ; +$ } +$ } +$ } +$ +$ +$ public: +$ +$ Handle(Standard_Transient)() +$ { +$ entity = UndefinedHandleAddress ; +$ } +$ +$ Handle(Standard_Transient)(const Handle(Standard_Transient)& aTid) +$ { +$ entity = aTid.entity; +$ BeginScope(); +$ } +$ +$ Handle(Standard_Transient)(const Standard_Transient *anItem) +$ { +$ if (!anItem) +$ entity = UndefinedHandleAddress ; +$ else +$ entity = (Standard_Transient *)anItem; +$ BeginScope(); +$ } +$ void Dump(Standard_OStream& out) const; +$ ~Handle(Standard_Transient)(); +$ +$ void ShallowDump(Standard_OStream&) const; +$ +$ Standard_Boolean IsImmutable() const { +$ return(Standard_False); +$ }; +$ +$ void SetImmutable() {}; +$ +$ int operator==(const Handle(Standard_Transient)& right) const +$ { +$ return entity == right.entity; +$ } +$ +$ int operator==(const Standard_Transient *right) const +$ { +$ return entity == (Standard_Transient *)right; +$ } +$ +$ friend int operator==(const Standard_Transient *left, const Handle(Standard_Transient)& right) +$ { +$ return left == right.entity; +$ } +$ +$ int operator!=(const Handle(Standard_Transient)& right) const +$ { +$ return entity != right.entity; +$ } +$ +$ int operator!=(const Standard_Transient *right) const +$ { +$ return entity != right; +$ } +$ +$ friend int operator!=(const Standard_Transient *left, const Handle(Standard_Transient)& right) +$ { +$ return left != right.entity; +$ } +$ +$ void Nullify() +$ { +$ EndScope(); +$ entity = UndefinedHandleAddress ; +$ } +$ +$ Standard_Boolean IsNull() const +$ { +$ return entity == UndefinedHandleAddress ; +$ } +$ +$ protected: +$ +$ Standard_Transient* Access() const +$ { +$ return entity; +$ } +$ +$ Standard_Transient* ControlAccess() const +$ { +$ return entity; +$ } +$ +$ void Assign(const Standard_Transient *anItem) +$ { +$ EndScope(); +$ if (!anItem) +$ entity = UndefinedHandleAddress ; +$ else +$ entity = (Standard_Transient *)anItem; +$ entity = (Standard_Transient *)anItem; +$ BeginScope(); +$ } +$ +$ +$ public: +$ +$ operator Standard_Transient*() +$ { +$ return Access(); +$ } +$ +$ +$ Handle(Standard_Transient)& operator=(const Handle(Standard_Transient)& aHandle); +$ Handle(Standard_Transient)& operator=(const Standard_Transient* anItem); +$ +$ Standard_Transient* operator->() +$ { +$ return ControlAccess(); +$ } +$ +$ Standard_Transient* operator->() const +$ { +$ return ControlAccess(); +$ } +$ +$ Standard_Transient& operator*() +$ { +$ return *(ControlAccess()); +$ } +$ +$ const Standard_Transient& operator*() const +$ { +$ return *(ControlAccess()); +$ } +$ +$ static const Handle(Standard_Transient) DownCast(const Handle(Standard_Transient)& AnObject); +$ +$ friend void ShallowDump(const Handle_Standard_Transient&,Standard_OStream&); +$ +$ }; +$ +$#ifndef _Standard_Type_HeaderFile +$#include +$#endif +$ +$#endif +@end; + +@template StandardTransient is +$#ifndef _Standard_Transient_HeaderFile +$#define _Standard_Transient_HeaderFile +$ +$#ifndef _Handle_Standard_Transient_HeaderFile +$#include +$#endif +$#ifndef _Standard_PrimitiveTypes_HeaderFile +$#include +$#endif +$#ifndef _Standard_Transient_proto_HeaderFile +$#include +$#endif +$#ifndef _Standard_Type_HeaderFile +$#include +$#endif +$ +$#endif +@end; + +@template StandardErrorHandler is +$//============================================================================ +$//==== Titre: Standard_ErrorHandler.hxx +$//==== Role : the header file of class "Standard_ErrorHandler". +$//==== define the syntaxe "try" and "catch". +$//============================================================================ +$ +$#ifndef _Standard_ErrorHandler_HeaderFile +$#define _Standard_ErrorHandler_HeaderFile +$ +$#ifndef _Standard_Failure_HeaderFile +$#include +$#endif +$ +$#include +$#include +$ +$class Standard_ErrorHandler +${ +$ friend class Standard_Failure; // To execute the raise exception. +$ +$ public: +$ +$ Standard_ErrorHandler(); +$ ~Standard_ErrorHandler(); +$ Standard_Boolean Catches (const Handle(Standard_Type)&); +$ +$ private: +$ static void Abort(); +$ static void Error(const Handle(Standard_Failure)&); +$ static Handle(Standard_Failure) LastCaughtError(); +$ +$ //==== The fields =========================================================== +$ private: +$ Standard_ErrorHandler* Previous; +$ Handle(Standard_Failure) CaughtError; +$ +$ public: +$ jmp_buf Label; +$ +$}; +$ +$ +$#include +$ +$#endif +@end; + +@template StandardSStream is +$#ifndef _Standard_SStream_HeaderFile +$#define _Standard_SStream_HeaderFile +$ +$#include +$ +$class Handle_Standard_Type; +$ +$Handle_Standard_Type& Standard_SStream_Type_(); +$ +$class Standard_SStream : public strstreambase, public ostream { +$ +$ public: +$ Standard_SStream(); +$ Standard_SStream(ostream& ); +$ +$ ~Standard_SStream(); +$}; +$#endif +@end; + +@template StandardIStream is +$#ifndef _Standard_IStream_HeaderFile +$#define _Standard_IStream_HeaderFile +$ +$#include +$ +$ +$class Handle_Standard_Type; +$ +$Handle_Standard_Type& Standard_IStream_Type_(); +$ +$#define Standard_IStream istream +$ +$#endif +@end; + +@template StandardOStream is +$#ifndef _Standard_OStream_HeaderFile +$#define _Standard_OStream_HeaderFile +$ +$#include +$ +$ +$class Handle_Standard_Type; +$ +$Handle_Standard_Type& Standard_OStream_Type_(); +$ +$#define Standard_OStream ostream +$ +$#endif +@end; + +@template HandleStandardPersistent is +$//============================================================================ +$// +$// Title : Handle_Standard_Persistent.hxx +$// Role : This file just include +$// +$//============================================================================ +$ +$#ifndef _Handle_Standard_Persistent_HeaderFile +$#define _Handle_Standard_Persistent_HeaderFile +$#include +$ +$#endif +@end; diff --git a/src/CPPExt/CPPExt_Storable.cxx b/src/CPPExt/CPPExt_Storable.cxx new file mode 100755 index 0000000..47e6df3 --- /dev/null +++ b/src/CPPExt/CPPExt_Storable.cxx @@ -0,0 +1,569 @@ +// CLE +// +// 10/1995 +// +#include +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include + +#include + +#include + +#include +#include + +// WARNING: DB Dependent functions +// +void CPP_BuildVArrayDeclarationOBJY(const Handle(MS_MetaSchema)&,const Handle(EDL_API)&,const Handle(MS_StdClass)&,const Handle(TCollection_HAsciiString)&); +void CPP_BuildVArrayFieldOBJY(const Handle(MS_MetaSchema)&,const Handle(EDL_API)&,const Handle(MS_StdClass)&,const Handle(TCollection_HAsciiString)&); + +void CPP_BuildVArrayDeclarationCSFDB(const Handle(MS_MetaSchema)&,const Handle(EDL_API)&,const Handle(MS_StdClass)&,const Handle(TCollection_HAsciiString)&); +void CPP_BuildVArrayFieldCSFDB(const Handle(MS_MetaSchema)&,const Handle(EDL_API)&,const Handle(MS_StdClass)&,const Handle(TCollection_HAsciiString)&); + +void CPP_BuildVArrayDeclarationOBJS(const Handle(MS_MetaSchema)&,const Handle(EDL_API)&,const Handle(MS_StdClass)&,const Handle(TCollection_HAsciiString)&); +void CPP_BuildVArrayFieldOBJS(const Handle(MS_MetaSchema)&,const Handle(EDL_API)&,const Handle(MS_StdClass)&,const Handle(TCollection_HAsciiString)&); + +Handle(TCollection_HAsciiString) CPP_BuildFieldOBJY(const Handle(MS_MetaSchema)& aMeta, + const Handle(MS_Field)& aField); +// create a VArray dependent declaration for DBC instance +// +void CPP_BuildVArrayDeclaration(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_StdClass)& aClass, + const Handle(TCollection_HAsciiString)& Result) +{ + if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"OBJY")) { + CPP_BuildVArrayDeclarationOBJY(aMeta,api,aClass,Result); + } + else if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"OBJS")) { + CPP_BuildVArrayDeclarationOBJS(aMeta,api,aClass,Result); + } + else if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"CSFDB")) { + CPP_BuildVArrayDeclarationCSFDB(aMeta,api,aClass,Result); + } +} + +// create a VArray dependent field for DBC instance +// +void CPP_BuildVArrayField(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_StdClass)& aClass, + const Handle(TCollection_HAsciiString)& Result) +{ + if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"OBJY")) { + CPP_BuildVArrayFieldOBJY(aMeta,api,aClass,Result); + } + else if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"OBJS")) { + CPP_BuildVArrayFieldOBJS(aMeta,api,aClass,Result); + } + else if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"CSFDB")) { + CPP_BuildVArrayFieldCSFDB(aMeta,api,aClass,Result); + } +} + +// CSFDB extension for storable classes +// only if %CPPEXTDBMS == "CSFDB" +// +void CPP_BuildStorableAccessFieldCSFDB(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Field)& field, + const Handle(TCollection_HAsciiString)& publics) +{ + Handle(MS_Type) thetype = aMeta->GetType(field->TYpe()); + + if (field->Dimensions()->Length() > 0) { + Standard_Integer i; + Handle(TCollection_HAsciiString) sdim = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) ddim = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) vdim = new TCollection_HAsciiString; + char num[30]; + + + api->AddVariable("%CSFDBType",CPP_BuildType(aMeta,field->TYpe())->ToCString()); + api->AddVariable("%Field",field->Name()->ToCString()); + + for (i = 1; i <= field->Dimensions()->Length(); i++) { + sdim->AssignCat("["); + sprintf(num,"%d",i); + sdim->AssignCat("i"); + sdim->AssignCat(num); + sdim->AssignCat("]"); + + if (i != 1) { + vdim->AssignCat(","); + ddim->AssignCat(","); + } + vdim->AssignCat("const Standard_Integer i"); + vdim->AssignCat(num); + + ddim->AssignCat("i"); + ddim->AssignCat(num); + } + api->AddVariable("%FDim",sdim->ToCString()); + api->AddVariable("%VarDim",vdim->ToCString()); + api->AddVariable("%Dimension",ddim->ToCString()); + api->Apply("%res","DefFuncFieldArray"); + } + else { + api->AddVariable("%CSFDBType",field->TYpe()->ToCString()); + api->AddVariable("%Field",field->Name()->ToCString()); + + if (thetype->IsKind(STANDARD_TYPE(MS_StdClass))) { + Handle(MS_StdClass) aclass = *((Handle(MS_StdClass)*)&thetype); + + if (aclass->IsPersistent()) { + api->Apply("%res","DefFuncPField"); + } + else { + api->Apply("%res","DefFuncSField"); + } + } + else { + api->Apply("%res","DefFuncPrField"); + } + } + + publics->AssignCat(api->GetVariableValue("%res")); +} + +// Extraction of a transient .ixx .jxx and _0.cxx +// the supplement variable is used for non inline methods generated +// by the extractor like destructor (added to .ixx ans _0.cxx +// +void CPP_StorableDerivated(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile, + const Handle(TColStd_HSequenceOfHAsciiString)& inclist, + const Handle(TColStd_HSequenceOfHAsciiString)& supplement) +{ + Standard_Integer i; + Handle(TCollection_HAsciiString) aFileName = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + // we do this only on standard classes (not on inst classes) + // + if (theClass.IsNull()) return; + + api->AddVariable(VClass,aClass->FullName()->ToCString()); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= inclist->Length(); i++) { + api->AddVariable(VIClass,inclist->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + } + + + if (theClass->GetMyCreator().IsNull()) { + // include hxx of me + // + api->AddVariable(VIClass,aClass->FullName()->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + + api->AddVariable(VoutClass,result->ToCString()); + + aFileName->AssignCat(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + aFileName->AssignCat(".jxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + result->Clear(); + outfile->Append(aFileName); + } + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + + if (theClass->GetMyCreator().IsNull()) { + aFileName->AssignCat(".ixx"); + } + else { + aFileName->AssignCat("_0.cxx"); + } + + if (theClass->GetMyCreator().IsNull()) { + result->Clear(); + } + + // Type Management and supplement + // + for (i = 1; i <= supplement->Length(); i++) { + result->AssignCat(supplement->Value(i)); + } + + CPP_ClassTypeMgt(aMeta,api,aClass,VTypeMgt); + + result->AssignCat(api->GetVariableValue(VTypeMgt)); + + api->AddVariable(VSupplement,result->ToCString()); + + // Methods + // + result->Clear(); + + if (!theClass->GetMyCreator().IsNull()) { + CPP_GenericDefine(aMeta,api,theClass->GetMyCreator(),VTICDefines,VTICUndefines,Standard_False); + result->AssignCat(api->GetVariableValue(VTICDefines)); + api->AddVariable(VSuffix,"gxx"); + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,theClass->GetMyCreator()->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + api->Apply(VMethods,"IncludeNoSafe"); + result->AssignCat(api->GetVariableValue(VMethods)); + } + + api->AddVariable(VMethods,result->ToCString()); + + if (theClass->GetMyCreator().IsNull()) { + api->AddVariable(VSuffix,"jxx"); + } + else { + api->AddVariable(VSuffix,"hxx"); + } + + api->AddVariable(VClass,aClass->FullName()->ToCString()); + + api->Apply(VoutClass,"StorableIxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + + outfile->Append(aFileName); +} + + +// Extraction of a transient class (inst or std) +// +void CPP_StorableClass(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile) +{ + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + if (!theClass.IsNull()) { + Standard_Integer i; + + Handle(MS_HSequenceOfMemberMet) methods = theClass->GetMethods(); + Handle(MS_Method) friendmethod; + Handle(TCollection_HAsciiString) publics = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) protecteds = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) privates = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) protf = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) privf = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) SuppMethod = new TCollection_HAsciiString; + + Handle(TColStd_HSequenceOfHAsciiString) Supplement = new TColStd_HSequenceOfHAsciiString; + + Standard_Boolean HasInlineMethod = Standard_False, + HasDestructor = Standard_False, + HasEmptyConst = Standard_False, + HasConstructor = Standard_False; + + + api->AddVariable(VTICIncludes,""); + api->AddVariable(VTICPublicfriends,""); + api->AddVariable(VTICProtectedfields,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICDefines,""); + api->AddVariable(VTICInlineIncludes,""); + api->AddVariable(VTICUndefines,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICPrivatefields,""); + api->AddVariable(VSuffix,""); + api->AddVariable(VTICSuppMethod,""); + + if (theClass->GetInheritsNames()->Length() > 0) { + if (!theClass->GetInheritsNames()->Value(1)->IsSameString(MS::GetStorableRootName())) { + publics->AssignCat(" : public "); + publics->AssignCat(theClass->GetInheritsNames()->Value(1)); + api->AddVariable(VInherits,publics->ToCString()); + publics->Clear(); + } + else { + api->AddVariable(VInherits,""); + } + } + else { + api->AddVariable(VInherits,""); + } + + api->AddVariable(VClass,theClass->FullName()->ToCString()); + api->AddVariable("%NameField",theClass->FullName()->ToCString()); + + for (i = 1; i <= theClass->GetFriendsNames()->Length(); i++) { + publics->AssignCat("friend "); + api->AddVariable(VIClass,theClass->GetFriendsNames()->Value(i)->ToCString()); + api->Apply(VTICPublicfriends,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICPublicfriends)); + } + + if (!CPP_SetFriendMethod(aMeta,api,theClass->GetFriendMets(),publics)) { + ErrorMsg << "CPPExt" << "Error : a friend method was not found..." << endm; + Standard_NoSuchObject::Raise(); + } + + api->AddVariable(VTICPublicfriends,publics->ToCString()); + + publics->Clear(); + + // extraction of the methods + // + Handle(TCollection_HAsciiString) aliasMethod; + + for (i = 1; i <= methods->Length(); i++) { + aliasMethod.Nullify(); + + if (methods->Value(i)->IsInline()) { + HasInlineMethod = Standard_True; + } + + // if the class has no destructor we give it + // + if (methods->Value(i)->IsDestructor()) { + HasDestructor = Standard_True; + } + + if (!methods->Value(i)->IsAlias().IsNull() || methods->Value(i)->IsDestructor()) { + aliasMethod = CPP_BuildAliasMethod(aMeta,api,methods->Value(i)); + } + + // if the class has no empty constructor, we give it + // + if (methods->Value(i)->IsKind(STANDARD_TYPE(MS_Construc))) { + if (methods->Value(i)->Params().IsNull()) { + HasEmptyConst = Standard_True; + } + + HasConstructor = Standard_True; + } + + // Function Call c++ comment : + // it s must be in the _0.cxx or ixx file + // so we add it in the supplement sequence + // + if (methods->Value(i)->IsFunctionCall()) { + SuppMethod->AssignCat(CPP_BuildAliasMethod(aMeta,api,methods->Value(i))); + } + + CPP_BuildMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + +#ifdef WNT + if ( !methods -> Value ( i ) -> IsInline () ) +#endif // WNT + api->Apply(VMethod,"MethodTemplateDec"); +#ifdef WNT + else + api->Apply(VMethod,"MethodTemplateDecInlineWNT" ); +#endif // WNT + + if (methods->Value(i)->Private()) { + privates->AssignCat(api->GetVariableValue(VMethod)); + if (!aliasMethod.IsNull()) { + privates->AssignCat(aliasMethod); + } + } + else if ((theClass->Deferred() && methods->Value(i)->IsKind(STANDARD_TYPE(MS_Construc))) || + methods->Value(i)->IsProtected()) { + protecteds->AssignCat(api->GetVariableValue(VMethod)); + if (!aliasMethod.IsNull()) { + protecteds->AssignCat(aliasMethod); + } + } + else { + publics->AssignCat(api->GetVariableValue(VMethod)); + if (!aliasMethod.IsNull()) { + publics->AssignCat(aliasMethod); + } + } + } + + if (!HasEmptyConst && (aClass->GetFields()->Length() > 0)) { + api->AddVariable("%Class",aClass->FullName()->ToCString()); + api->AddVariable("%Arguments"," "); + api->Apply(VMethod,"ConstructorHeader"); + api->AddVariable(VMBody,""); + api->Apply(VMethod,"MethodTemplateDef"); + publics->AssignCat(api->GetVariableValue(VMethod)); + } + + // extraction of fields + // WARNING: DB dependent + // + Handle(MS_HSequenceOfField) fields = theClass->GetFields(); + + for (i = 1; i <= fields->Length(); i++) { + if (fields->Value(i)->Protected()) { + if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"OBJY")) { + protf->AssignCat(CPP_BuildFieldOBJY(aMeta,fields->Value(i))); + } + else { + protf->AssignCat(CPP_BuildField(aMeta,fields->Value(i))); + } + } + else { + if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"OBJY")) { + privf->AssignCat(CPP_BuildFieldOBJY(aMeta,fields->Value(i))); + } + else { + privf->AssignCat(CPP_BuildField(aMeta,fields->Value(i))); + } + } + if (!strcmp(api->GetVariableValue("%CPPEXTDBMS")->ToCString(),"CSFDB")) { + CPP_BuildStorableAccessFieldCSFDB(aMeta,api,fields->Value(i),publics); + } + } + + // for DBC instance + // + CPP_BuildVArrayField(aMeta,api,theClass,privates); + + api->AddVariable(VTICPrivatefields,privf->ToCString()); + api->AddVariable(VTICProtectedfields,protf->ToCString()); + api->AddVariable(VTICPublicmets,publics->ToCString()); + api->AddVariable(VTICPrivatemets,privates->ToCString()); + api->AddVariable(VTICProtectedmets,protecteds->ToCString()); + + publics->Clear(); + privates->Clear(); + protecteds->Clear(); + privf->Clear(); + protf->Clear(); + + // others inline methods and functions (ex. function call) + // + api->AddVariable(VTICSuppMethod,SuppMethod->ToCString()); + + // include the lxx if the class have inline methods + // + if (HasInlineMethod) { + Handle(MS_InstClass) aCreator = theClass->GetMyCreator(); + + if (aCreator.IsNull()) { + api->AddVariable(VIClass,theClass->FullName()->ToCString()); + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeNoSafe"); + } + // this part is for class created by instantiations + // + else { + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,aCreator->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeNoSafe"); + + CPP_GenericDefine(aMeta,api,aCreator,VTICDefines,VTICUndefines,Standard_False); + } + } + + Handle(TColStd_HSequenceOfHAsciiString) List = new TColStd_HSequenceOfHAsciiString; + Handle(TColStd_HSequenceOfHAsciiString) incp = new TColStd_HSequenceOfHAsciiString; + + CPP_UsedTypes(aMeta,theClass,List,incp); + + publics->Clear(); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= List->Length(); i++) { + if (!List->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,List->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VTICIncludes,"IncludeNoSafe"); +#else + api->Apply(VTICIncludes,"Include"); +#endif + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + // a storable class must include Standard_PrimitiveTypes.hxx + // + api->AddVariable(VIClass,"Standard_PrimitiveTypes"); + api->Apply(VTICIncludes,"Include"); + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + + for (i = 1; i <= incp->Length(); i++) { + if (!incp->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,incp->Value(i)->ToCString()); + api->Apply(VTICIncludes,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + // for DBC instance + // + CPP_BuildVArrayDeclaration(aMeta,api,theClass,publics); + + api->AddVariable(VTICIncludes,publics->ToCString()); + + api->Apply(VoutClass,"StorableClass"); + + // we write the .hxx of this class + // + Handle(TCollection_HAsciiString) aFile = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFile->AssignCat(theClass->FullName()); + aFile->AssignCat(".hxx"); + + CPP_WriteFile(api,aFile,VoutClass); + + outfile->Append(aFile); + + CPP_StorableDerivated(aMeta,api,aClass,outfile,incp,Supplement); + } + else { + ErrorMsg << "CPPExt" << "CPP_StorableClass - the class is NULL..." << endm; + Standard_NoSuchObject::Raise(); + } +} + diff --git a/src/CPPExt/CPPExt_Template.edl b/src/CPPExt/CPPExt_Template.edl new file mode 100755 index 0000000..b117c14 --- /dev/null +++ b/src/CPPExt/CPPExt_Template.edl @@ -0,0 +1,874 @@ +-- File: CPPExt_Template.edl +-- Author: Kernel (CLE) +-- History: Tue Sep 19 17:25:59 1995 Kernel Creation +-- Copyright: Matra Datavision 1995 +-- Purpose: C++ extractor + +-- ==================================== +-- for extraction of a transient handle +-- ==================================== + +@verboseoff; + +@template HandleTransient (%HTName,%HTInherits) is +$// File generated by CPPExt (Transient) +$// +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$ +$#ifndef _Handle_%HTName_HeaderFile +$#define _Handle_%HTName_HeaderFile +$ +$#ifndef _Standard_Macro_HeaderFile +$#include +$#endif +$#ifndef _Standard_HeaderFile +$#include +$#endif +$ +$#ifndef _Handle_%HTInherits_HeaderFile +$#include +$#endif +$ +$class Standard_Transient; +$class Handle_Standard_Type; +$class Handle(%HTInherits); +$class %HTName; +$Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(%HTName); +$ +$class Handle(%HTName) : public Handle(%HTInherits) { +$ public: +$ inline void* operator new(size_t,void* anAddress) +$ { +$ return anAddress; +$ } +$ inline void* operator new(size_t size) +$ { +$ return Standard::Allocate(size); +$ } +$ inline void operator delete(void *anAddress, size_t size) +$ { +$ if (anAddress) Standard::Free((Standard_Address&)anAddress,size); +$ } +$ Handle(%HTName)():Handle(%HTInherits)() {} +$ Handle(%HTName)(const Handle(%HTName)& aHandle) : Handle(%HTInherits)(aHandle) +$ { +$ } +$ +$ Handle(%HTName)(const %HTName* anItem) : Handle(%HTInherits)((%HTInherits *)anItem) +$ { +$ } +$ +$ Handle(%HTName)& operator=(const Handle(%HTName)& aHandle) +$ { +$ Assign(aHandle.Access()); +$ return *this; +$ } +$ +$ Handle(%HTName)& operator=(const %HTName* anItem) +$ { +$ Assign((Standard_Transient *)anItem); +$ return *this; +$ } +$ +$ %HTName* operator->() +$ { +$ return (%HTName *)ControlAccess(); +$ } +$ +$ %HTName* operator->() const +$ { +$ return (%HTName *)ControlAccess(); +$ } +$ +$ Standard_EXPORT ~Handle(%HTName)(); +$ +$ Standard_EXPORT static const Handle(%HTName) DownCast(const Handle(Standard_Transient)& AnObject); +$}; +$#endif +@end; + + +-- =============================== +-- extraction of a transient class +-- =============================== + +@template TransientInstClass (%Class, + %TICIncludes, + %Inherits, + %TICPublicmets, + %TICPublicfriends, + %TICProtectedmets, + %TICProtectedfields, + %TICPrivatemets, + %TICPrivatefields, + %TICPrivatefriends, + %TICDefines, + %TICInlineIncludes, + %TICUndefines, + %TICSuppMethod) is +$// File generated by CPPExt (Transient) +$// +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#ifndef _%Class_HeaderFile +$#define _%Class_HeaderFile +$ +$#ifndef _Standard_HeaderFile +$#include +$#endif +$#ifndef _Handle_%Class_HeaderFile +$#include +$#endif +$ +$%TICIncludes +$ +$class %Class : public %Inherits { +$ +$public: +$ +$ inline void* operator new(size_t,void* anAddress) +$ { +$ return anAddress; +$ } +$ inline void* operator new(size_t size) +$ { +$ return Standard::Allocate(size); +$ } +$ inline void operator delete(void *anAddress, size_t size) +$ { +$ if (anAddress) Standard::Free((Standard_Address&)anAddress,size); +$ } +$ // Methods PUBLIC +$ // +$%TICPublicmets +$ +$%TICPublicfriends +$ +$ // Type management +$ // +$ Standard_EXPORT friend Handle_Standard_Type& %Class_Type_(); +$ Standard_EXPORT const Handle(Standard_Type)& DynamicType() const; +$ Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const; +$ +$protected: +$ +$ // Methods PROTECTED +$ // +$%TICProtectedmets +$ +$ // Fields PROTECTED +$ // +$%TICProtectedfields +$ +$private: +$ +$ // Methods PRIVATE +$ // +$%TICPrivatemets +$ +$ // Fields PRIVATE +$ // +$%TICPrivatefields +$%TICPrivatefriends +$}; +$ +$%TICDefines +$%TICInlineIncludes +$%TICUndefines +$ +$// other inline functions and methods (like "C++: function call" methods) +$// +$%TICSuppMethod +$ +$#endif +@end; + +@template TransientIxx (%Class,%Suffix,%Supplement,%TypeMgt,%Methods) is +$// File generated by CPPExt (Transient) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#include <%Class.%Suffix> +$ +$#ifndef _Standard_TypeMismatch_HeaderFile +$#include +$#endif +$ +$%Supplement +$ +$%TypeMgt +$ +$%Methods +@end; + +-- ================================ +-- extraction of a normal c++ class +-- ================================ + +@template MPVClass (%Class, + %TICIncludes, + %Inherits, + %TICPublicmets, + %TICPublicfriends, + %TICProtectedmets, + %TICProtectedfields, + %TICPrivatemets, + %TICPrivatefields, + %TICPrivatefriends, + %TICDefines, + %TICInlineIncludes, + %TICUndefines, + %TICSuppMethod) is +$// File generated by CPPExt (Value) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$ +$#ifndef _%Class_HeaderFile +$#define _%Class_HeaderFile +$ +$%TICIncludes +$ +$#ifndef _Standard_HeaderFile +$#include +$#endif +$#ifndef _Standard_Macro_HeaderFile +$#include +$#endif +$ +$class %Class %Inherits { +$ +$public: +$ +$ inline void* operator new(size_t,void* anAddress) +$ { +$ return anAddress; +$ } +$ inline void* operator new(size_t size) +$ { +$ return Standard::Allocate(size); +$ } +$ inline void operator delete(void *anAddress, size_t size) +$ { +$ if (anAddress) Standard::Free((Standard_Address&)anAddress,size); +$ } +$ // Methods PUBLIC +$ // +$%TICPublicmets +$ +$%TICPublicfriends +$ +$ +$protected: +$ +$ // Methods PROTECTED +$ // +$%TICProtectedmets +$ +$ // Fields PROTECTED +$ // +$%TICProtectedfields +$ +$private: +$ +$ // Methods PRIVATE +$ // +$%TICPrivatemets +$ +$ // Fields PRIVATE +$ // +$%TICPrivatefields +$%TICPrivatefriends +$}; +$ +$%TICDefines +$%TICInlineIncludes +$%TICUndefines +$ +$// other inline functions and methods (like "C++: function call" methods) +$// +$%TICSuppMethod +$ +$#endif +@end; + +@template MPVIxx (%Class,%Suffix,%Supplement,%Methods) is +$// File generated by CPPExt (Value) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#include <%Class.%Suffix> +$ +$%Supplement +$ +$%Methods +@end; + +-- ============================== +-- extraction of a storable class +-- ============================== + +@template StorableClass(%Class, + %TICIncludes, + %Inherits, + %TICPublicmets, + %TICPublicfriends, + %TICProtectedmets, + %TICProtectedfields, + %TICPrivatemets, + %TICPrivatefields, + %TICPrivatefriends, + %TICDefines, + %TICInlineIncludes, + %TICUndefines, + %TICSuppMethod) is +$// File generated by CPPExt (Storable) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#ifndef _%Class_HeaderFile +$#define _%Class_HeaderFile +$ +$%TICIncludes +$ +$#ifndef _Standard_HeaderFile +$#include +$#endif +$#ifndef _Standard_Macro_HeaderFile +$#include +$#endif +$ +$Standard_EXPORT Handle_Standard_Type& %Class_Type_(); +$ +$class %Class %Inherits { +$ +$public: +$ inline void* operator new(size_t,void* anAddress) +$ { +$ return anAddress; +$ } +$ inline void* operator new(size_t size) +$ { +$ return Standard::Allocate(size); +$ } +$ inline void operator delete(void *anAddress, size_t size) +$ { +$ if (anAddress) Standard::Free((Standard_Address&)anAddress,size); +$ } +$ +$ // Methods PUBLIC +$ // +$%TICPublicmets +$ +$%TICPublicfriends +$ +$ // Type management +$ // +$ Standard_EXPORT friend Handle_Standard_Type& %Class_Type_(); +$ +$protected: +$ +$ // Methods PROTECTED +$ // +$%TICProtectedmets +$ +$ // Fields PROTECTED +$ // +$%TICProtectedfields +$ +$private: +$ +$ // Methods PRIVATE +$ // +$%TICPrivatemets +$ +$ // Fields PRIVATE +$ // +$%TICPrivatefields +$%TICPrivatefriends +$}; +$ +$%TICDefines +$%TICInlineIncludes +$%TICUndefines +$ +$// other inline functions and methods (like "C++: function call" methods) +$// +$%TICSuppMethod +$ +$#endif +@end; + +@template StorableIxx(%Class,%Suffix,%Supplement,%Methods) is +$// File generated by CPPExt (Storable) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#include <%Class.%Suffix> +$ +$#ifndef _Standard_Type_HeaderFile +$#include +$#endif +$#ifndef _Standard_TypeMismatch_HeaderFile +$#include +$#endif +$ +$%Supplement +$ +$%Methods +@end; + +-- =============== +-- Enum extraction +-- =============== + +@template EnumHXX(%Class,%Values) is +$// File generated by CPPExt (Enum) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#ifndef _%Class_HeaderFile +$#define _%Class_HeaderFile +$ +$enum %Class { +$ %Values +$}; +$ +$ +$#ifndef _Standard_PrimitiveTypes_HeaderFile +$#include +$#endif +$ +$#endif +@end; + +@template EnumCXX(%Class,%Values,%Nb) is +$// File generated by CPPExt (Enum) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +@end; + +-- ================ +-- Alias extraction +-- ================ +@template AliasHXX(%Class,%Inherits, %HandleTypedef) is +$// File generated by CPPExt (Alias) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#ifndef _%Class_HeaderFile +$#define _%Class_HeaderFile +$#ifndef _%Inherits_HeaderFile +$#include <%Inherits.hxx> +$#endif +$ +$typedef %Inherits %Class; +$%HandleTypedef +$ +$#define %Class_Type_() %Inherits_Type_() +$#endif +@end; + +-- ================== +-- Pointer extraction +-- ================== + +@template PointerHXX(%Class,%Inherits) is +$// File generated by CPPExt (Pointer) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#ifndef _%Class_HeaderFile +$#define _%Class_HeaderFile +$ +$class %Inherits; +$ +$typedef %Inherits* %Class; +$ +$#endif +@end; + +-- ===================== +-- Exceptions extraction +-- ===================== +@template ExceptionHXX(%Class,%Inherits) is +$// File generated by CPPExt (Exception) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#ifndef _%Class_HeaderFile +$#define _%Class_HeaderFile +$ +$#ifndef _Standard_HeaderFile +$#include +$#endif +$#ifndef _Handle_%Class_HeaderFile +$#include +$#endif +$ +$#ifndef _Standard_SStream_HeaderFile +$#include +$#endif +$ +$ +$#ifndef _%Inherits_HeaderFile +$#include <%Inherits.hxx> +$#endif +$ +$ +$#if !defined No_Exception && !defined No_%Class +$#define %Class_Raise_if(CONDITION,MESSAGE) \ +$ if (CONDITION) %Class::Raise(MESSAGE); +$#else +$#define %Class_Raise_if(CONDITION,MESSAGE) +$#endif +$ +$class %Class : public %Inherits { +$ +$ inline void* operator new(size_t,void* anAddress) +$ { +$ return anAddress; +$ } +$ inline void* operator new(size_t size) +$ { +$ return Standard::Allocate(size); +$ } +$ inline void operator delete(void *anAddress, size_t size) +$ { +$ if (anAddress) Standard::Free((Standard_Address&)anAddress,size); +$ } +$public: +$ Standard_EXPORT static void Raise(const Standard_CString aMessage = ""); +$ Standard_EXPORT static void Raise(Standard_SStream& aReason); +$#ifndef NO_CXX_EXCEPTION +$ Standard_EXPORT virtual void Throw() const ; +$#endif +$ +$ Standard_EXPORT ~%Class(); +$ +$ // Type methods +$ // +$ Standard_EXPORT friend Handle_Standard_Type& %Class_Type_(); +$ Standard_EXPORT const Handle(Standard_Type)& DynamicType() const; +$ Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const; +$}; +$ +$#endif +@end; + +@template ExceptionMethod(%Class) is +$%Class::~%Class(){} +$ +$void %Class::Raise(Standard_SStream& aReason) +${ +$ Handle(%Class) _E(new %Class); +$ _E->Reraise (aReason.rdbuf()->str()); +$} +$ +$void %Class::Raise(const Standard_CString AString) +${ +$ Handle(%Class) _E (new %Class); +$ _E->Reraise(AString); +$} +$#ifndef NO_CXX_EXCEPTION +$void %Class::Throw() const +${ +$ throw %Class() ; +$} +$#endif +@end; + +-- ============== +-- misc templates +-- ============== + +@template Include(%IClass,%Suffix) is +$#ifndef _%IClass_HeaderFile +$#include <%IClass.%Suffix> +$#endif +@end; + +@template IncludeNoSafe(%IClass,%Suffix) is +$#include <%IClass.%Suffix> +@end; + +@template Define(%DName,%DValue) is +$#define %DName %DValue +@end; + +@template ItemDefine(%DName,%DValue,%DBaseValue) is +$#define %DName %DValue +$#define %DName_hxx <%DBaseValue.hxx> +@end; + +@template ItemConstraintHandle(%DName,%DValue) is +$#define Handle_%DName Handle_%DValue +@end; + +@template ItemHandleDefine (%DName,%DValue) is +$#define Handle_%DName Handle_%DValue +$#define %DName_Type_() %DValue_Type_() +@end; + +@template Undefine(%DName) is +$#undef %DName +@end; + +@template ItemUndefine(%DName) is +$#undef %DName +$#undef %DName_hxx +@end; + +@template ItemConstraintHandleUndef(%DName) is +$#undef Handle_%DName +@end; + +@template ItemHandleUndefine(%DName) is +$#undef Handle_%DName +$#undef %DName_Type_ +@end; + +@template ShortDec(%IClass) is +$class %IClass; +@end; + +-- ============================================== +-- Methods templates +-- ============================================== + +@template ConstructorHeader(%Class,%Arguments) is +$%Class(%Arguments)\^ +@end; + +@template MethodHeader(%Virtual,%RetSpec,%Return,%And,%MethodName,%Arguments,%MetSpec) is +$%Virtual %RetSpec %Return%And %MethodName(%Arguments) %MetSpec\^ +@end; + +@template ExternalConstructorHeader(%Class,%Arguments) is +$%Class::%Class(%Arguments)\^ +@end; + +@template ExternalMethodHeader(%Class,%Virtual,%RetSpec,%Return,%And,%MethodName,%Arguments,%MetSpec) is +$%Virtual %RetSpec %Return%And %Class::%MethodName(%Arguments) %MetSpec\^ +@end; + +@template MethodTemplateDec(%Method) is +$Standard_EXPORT %Method; +@end; + +@template MethodTemplateDecInlineWNT(%Method) is +$%Method; +@end; + +@template InlineMethodTemplateDec(%Method) is +$inline %Method\^ +@end; + +@template MethodTemplateDef(%Method,%MBody) is +$%Method +${ +$ %MBody +$} +$ +@end; + +@template EmptyDestructorTemplate(%Class) is +$Standard_EXPORT ~%Class(); +@end; + +@template FullEmptyHandleDestructorTemplate(%Class) is +$Handle_%Class::~Handle_%Class() {} +@end; + +@template FullEmptyDestructorTemplate(%Class) is +$%Class::~%Class() {} +@end; + +-- =============== +-- current methods +-- =============== + +-- type management : BEGIN + +@template TypeMgtAncestorType(%Nb) is +$aType%Nb\^ +@end; + +@template TypeMgtAncestor(%Nb,%Ancestors) is +$ static Handle_Standard_Type %Nb = STANDARD_TYPE(%Ancestors); +$ if ( %Nb.IsNull()) %Nb = STANDARD_TYPE(%Ancestors); +@end; + +@template TypeMgt(%Class,%Inherits,%Ancestors) is +$ +$Standard_EXPORT Handle_Standard_Type& %Class_Type_() +${ +$ +$ %Inherits +$ +$ static Handle_Standard_Transient _Ancestors[]= {%AncestorsNULL}; +$ static Handle_Standard_Type _aType = new Standard_Type("%Class", +$ sizeof(%Class), +$ 1, +$ (Standard_Address)_Ancestors, +$ (Standard_Address)NULL); +$ +$ return _aType; +$} +@end; + +-- type management : END + +@template DownCast(%Class,%IClass) is +$// DownCast method +$// allow safe downcasting +$// +$const Handle(%Class) Handle(%Class)::DownCast(const Handle(%IClass)& AnObject) +${ +$ Handle(%Class) _anOtherObject; +$ +$ if (!AnObject.IsNull()) { +$ if (AnObject->IsKind(STANDARD_TYPE(%Class))) { +$ _anOtherObject = Handle(%Class)((Handle(%Class)&)AnObject); +$ } +$ } +$ +$ return _anOtherObject ; +$} +@end; + +@template DynamicType(%Class) is +$const Handle(Standard_Type)& %Class::DynamicType() const +${ +$ return STANDARD_TYPE(%Class) ; +$} +@end; + +@template IsKind(%Class,%IClass) is +$Standard_Boolean %Class::IsKind(const Handle(Standard_Type)& AType) const +${ +$ return (STANDARD_TYPE(%Class) == AType || %IClass::IsKind(AType)); +$} +@end; diff --git a/src/CPPExt/CPPExt_TemplateCSFDB.edl b/src/CPPExt/CPPExt_TemplateCSFDB.edl new file mode 100755 index 0000000..3b213cd --- /dev/null +++ b/src/CPPExt/CPPExt_TemplateCSFDB.edl @@ -0,0 +1,243 @@ +-- File: CPPExt_TemplateCSFDB.edl +-- Author: Kernel +-- History: Thu Dec 21 08:27:18 1995 Kernel Creation +-- Copyright: Matra Datavision 1995 + +-- ================================= +-- extraction of a persistent handle +-- ================================= + +@template HandlePersistentCSFDB(%HPName,%HPInherits) is +$#ifndef _Handle_%HPName_HeaderFile +$#define _Handle_%HPName_HeaderFile +$ +$#ifndef _Standard_Macro_HeaderFile +$#include +$#endif +$ +$#ifndef _Handle_%HPInherits_HeaderFile +$#include +$#endif +$#ifndef _Standard_HeaderFile +$#include +$#endif +$ +$class Standard_Persistent; +$class Handle_Standard_Type; +$class Handle(%HPInherits); +$class %HPName; +$Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(%HPName); +$ +$class Handle(%HPName) : public Handle(%HPInherits) { +$ public: +$ +$ inline void* operator new(size_t,void* anAddress) +$ { +$ return anAddress; +$ } +$ inline void* operator new(size_t size) +$ { +$ return StandardCSFDB_Allocate(size); +$ } +$ inline void operator delete(void *anAddress, size_t size) +$ { +$ if (anAddress) StandardCSFDB_Free((Standard_Address&)anAddress,size); +$ } +$ +$ Handle(%HPName)():Handle(%HPInherits)() {} +$ Handle(%HPName)(const Handle(%HPName)& aHandle) : Handle(%HPInherits)(aHandle) +$ { +$ } +$ +$ Handle(%HPName)(const %HPName* anItem) : Handle(%HPInherits)((%HPInherits *)anItem) +$ { +$ } +$ +$ Handle(%HPName)& operator=(const Handle(%HPName)& aHandle) +$ { +$ Assign(aHandle.Access()); +$ return *this; +$ } +$ +$ Handle(%HPName)& operator=(const %HPName* anItem) +$ { +$ Assign((Standard_Persistent *)anItem); +$ return *this; +$ } +$ +$ %HPName* operator->() +$ { +$ return (%HPName *)ControlAccess(); +$ } +$ +$ %HPName* operator->() const +$ { +$ return (%HPName *)ControlAccess(); +$ } +$ +$ Standard_EXPORT ~Handle(%HPName)(); +$ +$ Standard_EXPORT static const Handle(%HPName) DownCast(const Handle(Standard_Persistent)& AnObject); +$}; +$#endif +@end; + +@template PersistentCSFDBInstClass(%Class, + %Inherits, + %TICIncludes, + %TICPublicfriends, + %TICPublicmets, + %TICPublicfriends, + %TICProtectedmets, + %TICProtectedfields, + %TICPrivatemets, + %TICPrivatefields, + %TICPrivatefriends, + %TICDefines, + %TICInlineIncludes, + %TICUndefines, + %TICSuppMethod) is +$// File generated by CPPExt (Persistent CSFDB) +$// for CAS.CADE (copyright Matra-Datavision 1995) +$// +$#ifndef _%Class_HeaderFile +$#define _%Class_HeaderFile +$ +$#ifndef _Handle_%Class_HeaderFile +$#include +$#endif +$#ifndef _Standard_HeaderFile +$#include +$#endif +$ +$%TICIncludes +$ +$class %Class : public %Inherits { +$ +$ +$public: +$ inline void* operator new(size_t,void* anAddress) +$ { +$ return anAddress; +$ } +$ inline void* operator new(size_t size) +$ { +$ return StandardCSFDB_Allocate(size); +$ } +$ inline void operator delete(void *anAddress, size_t size) +$ { +$ if (anAddress) StandardCSFDB_Free((Standard_Address&)anAddress,size); +$ } +$ +$ // Methods PUBLIC +$ // +$%TICPublicmets +$%TICPublicfriends +$ +$ // Type management +$ // +$ Standard_EXPORT friend Handle_Standard_Type& %Class_Type_(); +$ Standard_EXPORT const Handle(Standard_Type)& DynamicType() const; +$ Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const; +$ +$protected: +$ +$ // Methods PROTECTED +$ // +$%TICProtectedmets +$ // Fields PROTECTED +$ // +$%TICProtectedfields +$ +$private: +$ +$ // Methods PRIVATE +$ // +$%TICPrivatemets +$ // Fields PRIVATE +$ // +$%TICPrivatefields +$%TICPrivatefriends +$}; +$ +$%TICDefines +$%TICInlineIncludes +$%TICUndefines +$ +$// other inline functions and methods (like "C++: function call" methods) +$// +$%TICSuppMethod +$ +$#endif +@end; + +@template PersistentCSFDBIxx(%Class,%Suffix,%Supplement,%TypeMgt,%Methods) is +$// File generated by CPPExt (Persistent CSFDB) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#include <%Class.%Suffix> +$ +$#ifndef _Standard_TypeMismatch_HeaderFile +$#include +$#endif +$ +$%Supplement +$ +$%TypeMgt +$ +$%Methods +@end; + +-- ARRAY +-- +@template DefFuncFieldArray(%CSFDBType,%Field,%NameField,%VarDim,%FDim) is +$ %CSFDBType& _CSFDB_Get%NameField%Field(%VarDim) { return %Field%FDim; } +@end; + +-- +-- ARRAY + +@template DefFuncPField(%CSFDBType,%Field,%NameField) is +$ Handle(%CSFDBType) _CSFDB_Get%NameField%Field() const { return %Field; } +$ void _CSFDB_Set%NameField%Field(const Handle(%CSFDBType)& p) { %Field = p; } +@end; + +@template DefFuncSField(%CSFDBType,%Field,%NameField) is +$ const %CSFDBType& _CSFDB_Get%NameField%Field() const { return %Field; } +@end; + +@template DefFuncPrField(%CSFDBType,%Field,%NameField) is +$ %CSFDBType _CSFDB_Get%NameField%Field() const { return %Field; } +$ void _CSFDB_Set%NameField%Field(const %CSFDBType p) { %Field = p; } +@end; + +@template VArrayDeclareCSFDB(%DName,%DValue) is +$ +@end; + +@template ConstructorHeaderCallAncestor(%Class,%Inherits) is +$%Class(const Storage_stCONSTclCOM& a) : %Inherits(a)\^ +@end; + +@template ConstructorHeaderNotCallAncestor(%Class) is +$%Class(const Storage_stCONSTclCOM&)\^ +@end; + +@template VArrayFieldCSFDB(%DValue) is +$#ifdef CSFDB +$// DBC_VArray : field +$// +$#endif +@end; + diff --git a/src/CPPExt/CPPExt_TemplateOBJS.edl b/src/CPPExt/CPPExt_TemplateOBJS.edl new file mode 100755 index 0000000..fee1dc6 --- /dev/null +++ b/src/CPPExt/CPPExt_TemplateOBJS.edl @@ -0,0 +1,426 @@ +-- File: CPPExt_TemplateOBJS.edl +-- Author: Kernel +-- History: Thu Dec 21 08:27:18 1995 Kernel Creation +-- Copyright: Matra Datavision 1995 + +-- ================================= +-- extraction of a persistent handle +-- ================================= + +@template HandlePersistentOBJS(%HPName,%HPName,%HPInherits) is +$// File generated by CPPExt (Persistent OBJS) +$// +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$ +$#ifndef Handle_%HPName_HeaderFile +$#define Handle_%HPName_HeaderFile +$#define %HPNameType %HPName_Type_() +$ +$#ifndef _%HPName_Pointer +$#define _%HPName_Pointer +$class %HPName; +$class Handle_%HPName; +$#ifdef DECOSF1 +$#pragma pointer_size save +$#pragma pointer_size short +$#endif +$typedef %HPName* %HPName_ptr; +$typedef Handle_%HPName* Handle_%HPName_ptr; +$#ifdef DECOSF1 +$#pragma pointer_size restore +$#endif +$#endif +$ +$#ifndef _Handle_%HPInherits_HeaderFile +$#include +$#endif +$ +$class Oid_%HPName; +$class %HPName; +$ +$class Handle_%HPName: public Handle_%HPInherits { +$ +$public: +$ +$ inline Handle_%HPName(); +$ inline Handle_%HPName(const Handle_%HPName& AnObject); +$ inline Handle_%HPName(const %HPName_ptr AnObject); +$ Standard_EXPORT ~Handle_%HPName(); +$ inline Handle_%HPName& operator=(const Handle_%HPName& AnObject); +$ Standard_EXPORT Handle_%HPName& operator=(const %HPName_ptr AnObject); +$ Standard_EXPORT static const Handle_%HPName DownCast(const Handle_Standard_Persistent&); +$ inline Standard_Boolean operator==(const Handle_%HPName& AnObject) const ; +$ inline Standard_Boolean operator!=(const Handle_%HPName& AnObject) const; +$ inline Oid_%HPName* operator->() const; +$}; +$ +$ +$inline Handle_%HPName::Handle_%HPName() +${ +$} +$ +$inline Handle_%HPName::Handle_%HPName(const Handle_%HPName& AnObject) +$ : Handle_%HPInherits(AnObject) +${ +$} +$ +$inline Handle_%HPName::Handle_%HPName(const %HPName_ptr AnObject) +$ : Handle_%HPInherits((const %HPInherits_ptr)AnObject) +${ +$} +$ +$inline Handle_%HPName& Handle_%HPName::operator=(const Handle_%HPName& AnObject) +${ +$ Identifier=AnObject.Identifier; return *this; +$} +$ +$inline Standard_Boolean Handle_%HPName::operator==(const Handle_%HPName& AnObject)const +${ +$ return Identifier==AnObject.Identifier; +$} +$ +$inline Standard_Boolean Handle_%HPName::operator!=(const Handle_%HPName& AnObject)const +${ +$ return Identifier!=AnObject.Identifier; +$} +$ +$inline Oid_%HPName* Handle_%HPName::operator->() const +${ +$ return (Oid_%HPName*)(void*)&(((Handle_%HPName_ptr)this)->Identifier); +$} +$ +$#endif +@end; + +@template PersistentOBJSInstClass(%Class, + %Inherits, + %TICIncludes, + %TICPublicfriends, + %TICOidpubMet, + %TICOidproMet, + %TICOidpriMet, + %TICPublicmets, + %TICPublicfriends, + %TICProtectedmets, + %TICProtectedfields, + %TICPrivatemets, + %TICPrivatefields, + %TICPrivatefriends, + %TICDefines, + %TICInlineIncludes, + %TICUndefines, + %TICSuppMethod) is +$// File generated by CPPExt (Persistent OBJS) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#ifndef _%Class_HeaderFile +$#define _%Class_HeaderFile +$ +$#ifndef _%Class_Pointer +$#define _%Class_Pointer +$class %Class; +$class Handle_%Class; +$#ifdef DECOSF1 +$#pragma pointer_size save +$#pragma pointer_size short +$#endif +$typedef %Class* %Class_ptr; +$typedef Handle_%Class* Handle_%Class_ptr; +$#ifdef DECOSF1 +$#pragma pointer_size restore +$#endif +$#endif +$ +$#ifndef _Handle_%Class_HeaderFile +$#include +$#endif +$ +$%TICIncludes +$#ifndef _Standard_ImmutableObject_HeaderFile +$#include +$#endif +$ +$class Oid_%Class : public Oid_%Inherits { +$ +$friend class %Class; +$%TICPublicfriends +$ +$public: +$ +$%TICOidpubMet +$Oid_%Class() {}; +$~Oid_%Class() {}; +$ +$protected: +$ +$%TICOidproMet +$ +$private: +$ +$%TICOidpriMet +$}; +$ +$#ifdef OBJS +$Standard_EXPORT Handle_%Class_ptr Standard_PersistentAllocation(const Handle_%Class&, Standard_Integer size = 1); +$#endif +$ +$class %Class : public %Inherits { +$ +$friend class Oid_%Class; +$ +$public: +$ +$ // Methods PUBLIC +$ // +$%TICPublicmets +$ +$%TICPublicfriends +$ +$ // Type management +$ // +$ Standard_EXPORT friend Handle_Standard_Type& %Class_Type_(); +$ Standard_EXPORT friend Handle_%Class_ptr Standard_PersistentAllocation(const Handle_%Class&, Standard_Integer size); +$ Standard_EXPORT const Handle(Standard_Type)& DynamicType() const; +$ Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const; +$ +$#ifdef OBJS +$Standard_EXPORT void* operator new (size_t) ; +$Standard_EXPORT void* operator new (size_t, Standard_DBHandle); +$Standard_EXPORT void* operator new (size_t, Standard_Container); +$Standard_EXPORT void* operator new (size_t, Handle(Standard_Persistent)); +$Standard_EXPORT void operator delete (void*); +$Standard_EXPORT static os_typespec* get_mdtv_typespec() +$ { +$ static os_typespec* mytypespec = NULL; +$ if (mytypespec == NULL) +$ mytypespec = new os_typespec("%Class"); +$ return mytypespec; +$ } +$Standard_EXPORT virtual Standard_Persistent_ptr allocate_emptyObject(Standard_Integer size = 1) const; +$#endif +$ +$protected: +$ +$ // Methods PROTECTED +$ // +$%TICProtectedmets +$ +$ // Fields PROTECTED +$ // +$%TICProtectedfields +$ +$private: +$ +$ // Methods PRIVATE +$ // +$%TICPrivatemets +$ +$ // Fields PRIVATE +$ // +$%TICPrivatefields +$%TICPrivatefriends +$}; +$ +$%TICDefines +$%TICInlineIncludes +$%TICUndefines +$ +$// other inline functions and methods (like "C++: function call or Oid methods" methods) +$// +$%TICSuppMethod +$ +$#endif +@end; + +@template PersistentOBJSIxx(%Class,%Suffix,%Supplement,%TypeMgt,%Methods,%Destructor,%MethodOID) is +$// File generated by CPPExt (Persistent OBJS) +$// Copyright (C) 1991,1995 by +$// +$// MATRA DATAVISION, FRANCE +$// +$// This software is furnished in accordance with the terms and conditions +$// of the contract and with the inclusion of the above copyright notice. +$// This software or any other copy thereof may not be provided or otherwise +$// be made available to any other person. No title to an ownership of the +$// software is hereby transferred. +$// +$// At the termination of the contract, the software and all copies of this +$// software must be deleted. +$// +$#ifndef _Standard_TypeMismatch_HeaderFile +$#include +$#endif +$ +$%Supplement +$ +$#include <%Class.%Suffix> +$ +$%Destructor +$ +$%TypeMgt +$ +$ Handle_%Class& Handle_%Class::operator=(const %Class_ptr AnObject) +$ { +$ Identifier = AnObject; +$ return *this; +$ } +$ +$ void* %Class::operator new (size_t ASize) { +$ return new (Standard_Persistent::PreNew(),%Class::get_mdtv_typespec()) char[(long) ASize] ; +$ } +$ +$ // DELETE +$ void %Class::operator delete (void* _AnAddress) { +$ ::delete _AnAddress; +$ } +$ // DELETEEND +$ +$ void* %Class::operator new (size_t ASize, Standard_DBHandle db) { +$ return new (db,%Class::get_mdtv_typespec()) char[(long) ASize] ; +$ } +$ +$ void* %Class::operator new (size_t ASize, Standard_Container cont) { +$ return new (cont,%Class::get_mdtv_typespec()) char[(long) ASize] ; +$ } +$ +$ void* %Class::operator new (size_t ASize, Handle(Standard_Persistent) hd) { +$ return new (os_segment::of(hd->GetOId()),%Class::get_mdtv_typespec()) char[(long) ASize] ; +$ } +$ +$%MethodOID +$%Methods +@end; + +@template ImmutableTestOBJS(%DName,%MethodName) is +$ if (%DName.IsImmutable()) Standard_ImmutableObject::Raise("Immutable object handle in %MethodName"); +@end; + +@template UpdateAccessOBJS(%Class,%MethodName) is +$ ((%Class_ptr)UpdateAccess())->%MethodName; +@end; + +@template ReadAccessOBJS(%Class,%MethodName) is +$ ((%Class_ptr)ReadAccess())->%MethodName; +@end; + + +@template ItemMDTVDefine(%DName,%DValue) is +$#define %DName %DValue +$#define %DName_hxx <%DValue.hxx> +@end; + +@template ItemMDTVptrDefine(%DName,%DValue) is +$#define %DName_ptr %DValue_ptr +@end; + +@template ItemMDTVptrUndef(%DName) is +$#undef %DName_ptr +@end; + +@template ItemMDTVConstraintHandle(%DName,%DValue) is +$#define Handle_%DName Handle_%DValue +@end; + +@template ItemMDTVConstraintHandleUndef(%DName) is +$#undef Handle_%DName +@end; + +@template ItemHandleMDTVDefine(%DName,%DValue) is +$#define Handle_%DName Handle_%DValue +$#define %DName_Type_() %DValue_Type_() +$#define %DName_ptr %DValue_ptr +@end; + +@template ItemMDTVUndefine(%DName) is +$#undef %DName +$#undef %DName_hxx +@end; + +@template ItemHandleMDTVUndefine(%DName) is +$#undef Handle_%DName +$#undef %DName_Type_ +@end; + +@template IncludeMDTVNoSafe(%IClass,%Suffix) is +$#include <%IClass.%Suffix> +@end; + +@template VArrayFieldOBJS(%DName,%DValue) is +$#ifdef OBJS +$DBC_PCLASS_OBJS *myData; +$#endif +@end; + +@template VArrayDeclareOBJS(%DName,%DValue) is +$#ifdef OBJS +$#include +$#include +$typedef %DValue %DName_%DValue; +$ +$class P_%DName { +$public: +$ static os_typespec* get_mdtv_typespec(); +$ +$ %DValue myValue; +$}; +$#define P_%DName_use_DBC +$#ifdef DBC_PCLASS_OBJS +$#undef DBC_PCLASS_OBJS +$#endif +$#define DBC_PCLASS_OBJS P_%DName +$#endif +@end; + +@template PersistentAllocationOBJS (%Class) is +$Standard_Persistent_ptr %Class::allocate_emptyObject(Standard_Integer size) const { +$ if (size == 1 ) +$ return new %Class; +$ else +$ return new(Standard_Persistent::PreNew(), %Class::get_mdtv_typespec(), size) %Class[size]; +$} +$ +$Standard_EXPORT Handle_%Class_ptr Standard_PersistentAllocation(const Handle_%Class& Value, Standard_Integer size) { +$Handle_%Class_ptr hd; +$ if (size == 1 ) { +$ hd = new(Standard_Persistent::PreNew(),Handle_%Class::get_mdtv_typespec()) Handle_%Class(Value); +$ } else { +$ hd = new(Standard_Persistent::PreNew(),Handle_%Class::get_mdtv_typespec(), size) Handle_%Class[size]; +$} return hd; +$} +$ +@end; + +@template PersistentAllocationOBJSDeferred (%Class) is +$Standard_Persistent_ptr %Class::allocate_emptyObject(Standard_Integer size) const { +$ Standard_Persistent_ptr dummy = 0L; +$ return dummy; +$} +$ +$Standard_EXPORT Handle_%Class_ptr Standard_PersistentAllocation(const Handle_%Class& Value, Standard_Integer size) { +$ Handle_%Class_ptr hd = 0L; +$ return hd; +$} +$ +@end; diff --git a/src/CPPExt/CPPExt_TemplateOBJY.edl b/src/CPPExt/CPPExt_TemplateOBJY.edl new file mode 100755 index 0000000..9d99bf6 --- /dev/null +++ b/src/CPPExt/CPPExt_TemplateOBJY.edl @@ -0,0 +1,287 @@ +-- File: CPPExt_TemplateOBJY.edl +-- Author: Kernel +-- History: Thu Dec 21 08:27:18 1995 Kernel Creation +-- Copyright: Matra Datavision 1995 + +-- ================================= +-- extraction of a persistent handle +-- ================================= + +@template HandlePersistentOBJY(%HPName,%HPName,%HPInherits) is +$// File generated by CPPExt (Persistent OBJY) +$// for CAS.CADE (copyright Matra-Datavision 1995) +$// +$#ifndef Handle_%HPName_HeaderFile +$#define Handle_%HPName_HeaderFile +$#define %HPNameType %HPName_Type_() +$ +$#ifndef _Handle_%HPInherits_HeaderFile +$#include +$#endif +$ +$class Oid_%HPName; +$class %HPName; +$class PHandle_%HPName; +$ +$class Handle_%HPName: public Handle_%HPInherits { +$ +$public: +$ +$ Handle_%HPName(const PHandle_Standard_Persistent& AnObject) : Handle_%HPInherits(AnObject) {} +$ inline Handle_%HPName(); +$ inline Handle_%HPName(const Handle_%HPName& AnObject); +$ inline Handle_%HPName(const %HPName* AnObject); +$ ~Handle_%HPName(); +$ inline Handle_%HPName& operator=(const Handle_%HPName& AnObject); +$ Handle_%HPName& operator=(const %HPName* AnObject); +$ static const Handle_%HPName DownCast(const Handle_Standard_Persistent&); +$ inline Standard_Boolean operator==(const Handle_%HPName& AnObject) const ; +$ inline Standard_Boolean operator!=(const Handle_%HPName& AnObject) const; +$ inline Oid_%HPName* operator->() const; +$}; +$ +$class PHandle_%HPName : public PHandle_%HPInherits { +$ public: +$ PHandle_%HPName(){} +$ PHandle_%HPName (const Handle_%HPName& aHandle) : PHandle_%HPInherits(aHandle){} +$ Handle(%HPName) operator->(){Handle(%HPName) p(*this);return p;} +$ Handle(%HPName) operator->() const {Handle(%HPName) p(*this);return p;} +$}; +$ +$inline Handle_%HPName::Handle_%HPName() +${ +$} +$ +$inline Handle_%HPName::Handle_%HPName(const Handle_%HPName& AnObject) +$ : Handle_%HPInherits(AnObject) +${ +$} +$ +$inline Handle_%HPName::Handle_%HPName(const %HPName* AnObject) +$ : Handle_%HPInherits((const %HPInherits*)AnObject) +${ +$} +$ +$inline Handle_%HPName& Handle_%HPName::operator=(const Handle_%HPName& AnObject) +${ +$ Identifier=AnObject.Identifier; return *this; +$} +$ +$inline Standard_Boolean Handle_%HPName::operator==(const Handle_%HPName& AnObject)const +${ +$ return Identifier==AnObject.Identifier; +$} +$ +$inline Standard_Boolean Handle_%HPName::operator!=(const Handle_%HPName& AnObject)const +${ +$ return Identifier!=AnObject.Identifier; +$} +$ +$inline Oid_%HPName* Handle_%HPName::operator->() const +${ +$ return (Oid_%HPName*)(void*)&(((Handle_%HPName *)this)->Identifier); +$} +$ +$#endif +@end; + +@template PersistentOBJYInstClass(%Class, + %Inherits, + %TICIncludes, + %TICPublicfriends, + %TICOidpubMet, + %TICOidproMet, + %TICOidpriMet, + %TICPublicmets, + %TICPublicfriends, + %TICProtectedmets, + %TICProtectedfields, + %TICPrivatemets, + %TICPrivatefields, + %TICPrivatefriends, + %TICDefines, + %TICInlineIncludes, + %TICUndefines, + %TICSuppMethod) is +$// File generated by CPPExt (Persistent OBJY) +$// for CAS.CADE (copyright Matra-Datavision 1995) +$// +$#ifndef _%Class_HeaderFile +$#define _%Class_HeaderFile +$ +$#ifndef _Handle_%Class_HeaderFile +$#include +$#endif +$ +$%TICIncludes +$#ifndef _Standard_ImmutableObject_HeaderFile +$#include +$#endif +$ +$class Oid_%Class : public Oid_%Inherits { +$ +$friend class %Class; +$%TICPublicfriends +$ +$public: +$ +$%TICOidpubMet +$Oid_%Class() {}; +$~Oid_%Class() {}; +$ +$protected: +$ +$%TICOidproMet +$ +$private: +$ +$%TICOidpriMet +$}; +$ +$class %Class : public %Inherits { +$ +$friend class Oid_%Class; +$ +$public: +$ +$ // Methods PUBLIC +$ // +$%TICPublicmets +$ +$%TICPublicfriends +$ +$ // Type management +$ // +$ friend Handle_Standard_Type& %Class_Type_(); +$ const Handle(Standard_Type)& DynamicType() const; +$ Standard_Boolean IsKind(const Handle(Standard_Type)&) const; +$ void* operator new(size_t); +$ +$protected: +$ +$ // Methods PROTECTED +$ // +$%TICProtectedmets +$ +$ // Fields PROTECTED +$ // +$%TICProtectedfields +$ +$private: +$ +$ // Methods PRIVATE +$ // +$%TICPrivatemets +$ +$ // Fields PRIVATE +$ // +$%TICPrivatefields +$%TICPrivatefriends +$}; +$ +$%TICDefines +$%TICInlineIncludes +$%TICUndefines +$ +$// other inline functions and methods (like "C++: function call or Oid methods" methods) +$// +$%TICSuppMethod +$ +$#endif +@end; + +@template PersistentOBJYIxx(%Class,%Suffix,%Supplement,%TypeMgt,%Methods) is +$// File generated by CPPExt (Persistent OBJY) +$// for CAS.CADE (copyright Matra-Datavision 1995) +$// +$#include <%Class.%Suffix> +$ +$#ifndef _Standard_TypeMismatch_HeaderFile +$#include +$#endif +$ +$%Supplement +$ +$%TypeMgt +$ +$ // new operator +$ // +$ void* %Class::operator new (size_t ASize) +$ { +$ Standard_Container _aContainer = PreNew(); +$ return (opiNewObj(ASize,ooTypeN(%Class),_aContainer)); +$ } +$ +$ Handle_%Class& Handle_%Class::operator=(const %Class* AnObject) +$ { +$ Identifier = AnObject; +$ return *this; +$ } +$ +$%Methods +@end; + +@template ImmutableTestOBJY(%DName,%MethodName) is +$ if (%DName.IsImmutable()) Standard_ImmutableObject::Raise("Immutable object handle in %MethodName"); +@end; + +@template UpdateAccessOBJY(%Class,%MethodName) is +$ ((%Class *)UpdateAccess())->%MethodName; +@end; + +@template ReadAccessOBJY(%Class,%MethodName) is +$ ((%Class *)ReadAccess())->%MethodName; +@end; + + +@template ItemMDTVDefine(%DName,%DValue) is +$//MDTV#define %DName %DValue +$//MDTV#define %DName_hxx <%DValue.hxx> +@end; + +@template ItemMDTVConstraintHandle(%DName,%DValue) is +$//MDTV#define Handle_%DName Handle_%DValue +@end; + +@template ItemMDTVConstraintHandleUndef(%DName) is +$//MDTV#undef Handle_%DName +@end; + +@template ItemHandleMDTVDefine(%DName,%DValue) is +$//MDTV#define Handle_%DName Handle_%DValue +$//MDTV#define %DName_Type_() %DValue_Type_() +@end; + +@template ItemMDTVUndefine(%DName) is +$//MDTV#undef %DName +$//MDTV#undef %DName_hxx +@end; + +@template ItemHandleMDTVUndefine(%DName) is +$//MDTV#undef Handle_%DName +$//MDTV#undef %DName_Type_ +@end; + +@template IncludeMDTVNoSafe(%IClass,%Suffix) is +$//MDTV#include <%IClass.%Suffix> +@end; + +@template VArrayDeclareOBJY(%DName,%DValue) is +$#ifdef OBJY +$ +$#include +$#include +$ +$typedef %DValue %DName_%DValue; +$declare(ooVArray,%DName_%DValue) +$ +$#endif +@end; + +@template VArrayFieldOBJY(%DName,%DValue) is +$#ifdef OBJY +$ +$ooVArray(%DName_%DValue) myData; +$ +$#endif +@end; diff --git a/src/CPPExt/CPPExt_Transient.cxx b/src/CPPExt/CPPExt_Transient.cxx new file mode 100755 index 0000000..bccc55a --- /dev/null +++ b/src/CPPExt/CPPExt_Transient.cxx @@ -0,0 +1,431 @@ +// CLE +// +// 10/1995 +// +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include +#include + +// Extraction of a transient handle +// +void CPP_TransientHandle(const Handle(EDL_API)& api, + const Handle(TCollection_HAsciiString)& aClass, + const Handle(TCollection_HAsciiString)& aMother, + const Handle(TCollection_HAsciiString)& aFileName) +{ + // we create the handle... + // + api->AddVariable("%HTName",aClass->ToCString()); + api->AddVariable("%HTInherits",aMother->ToCString()); + api->Apply("%HTHandle","HandleTransient"); + + // ...now we write the result + // + api->OpenFile("HTFile",aFileName->ToCString()); + api->WriteFile("HTFile","%HTHandle"); + api->CloseFile("HTFile"); +} + +// Extraction of a transient .ixx .jxx and _0.cxx +// the supplement variable is used for non inline methods generated +// by the extractor like destructor (added to .ixx ans _0.cxx +// +void CPP_TransientDerivated(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile, + const Handle(TColStd_HSequenceOfHAsciiString)& inclist, + const Handle(TColStd_HSequenceOfHAsciiString)& supplement) +{ + Standard_Integer i; + Handle(TCollection_HAsciiString) aFileName = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) result = new TCollection_HAsciiString; + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + // we do this only on standard classes (not on inst classes) + // + if (theClass.IsNull()) return; + + api->AddVariable(VClass,aClass->FullName()->ToCString()); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= inclist->Length(); i++) { + api->AddVariable(VIClass,inclist->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + } + + if (theClass->GetMyCreator().IsNull()) { + // include the hxx of me + // + api->AddVariable(VIClass,aClass->FullName()->ToCString()); +#ifdef WNT + api->Apply(VoutClass,"IncludeNoSafe"); +#else + api->Apply(VoutClass,"Include"); +#endif + result->AssignCat(api->GetVariableValue(VoutClass)); + + api->AddVariable(VoutClass,result->ToCString()); + + aFileName->AssignCat(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + aFileName->AssignCat(".jxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + result->Clear(); + outfile->Append(aFileName); + } + + CPP_ClassTypeMgt(aMeta,api,aClass,VTypeMgt); + + aFileName = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + aFileName->AssignCat(aClass->FullName()); + + if (theClass->GetMyCreator().IsNull()) { + aFileName->AssignCat(".ixx"); + } + else { + aFileName->AssignCat("_0.cxx"); + } + + // Supplement + // + if (theClass->GetMyCreator().IsNull()) { + result->Clear(); + } + + for (i = 1; i <= supplement->Length(); i++) { + result->AssignCat(supplement->Value(i)); + } + + api->AddVariable(VSupplement,result->ToCString()); + + // Methods + // + result->Clear(); + + api->AddVariable(VIClass,MS::GetTransientRootName()->ToCString()); + api->Apply(VMethods,"DownCast"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->Apply(VMethods,"DynamicType"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->AddVariable(VIClass,aClass->GetInheritsNames()->Value(1)->ToCString()); + api->Apply(VMethods,"IsKind"); + result->AssignCat(api->GetVariableValue(VMethods)); + + api->Apply(VMethods,"FullEmptyHandleDestructorTemplate"); + result->AssignCat(api->GetVariableValue(VMethods)); + + if (!theClass->GetMyCreator().IsNull()) { + CPP_GenericDefine(aMeta,api,theClass->GetMyCreator(),VTICDefines,VTICUndefines,Standard_True); + result->AssignCat(api->GetVariableValue(VTICDefines)); + api->AddVariable(VSuffix,"gxx"); + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,theClass->GetMyCreator()->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + api->Apply(VMethods,"IncludeNoSafe"); + result->AssignCat(api->GetVariableValue(VMethods)); + } + + if (theClass->GetMyCreator().IsNull()) { + api->AddVariable(VSuffix,"jxx"); + } + else { + api->AddVariable(VSuffix,"hxx"); + } + + api->AddVariable(VMethods,result->ToCString()); + api->Apply(VoutClass,"TransientIxx"); + + CPP_WriteFile(api,aFileName,VoutClass); + + outfile->Append(aFileName); +} + + +// Extraction of a transient class (inst or std) +// +void CPP_TransientClass(const Handle(MS_MetaSchema)& aMeta, + const Handle(EDL_API)& api, + const Handle(MS_Class)& aClass, + const Handle(TColStd_HSequenceOfHAsciiString)& outfile) +{ + Handle(MS_StdClass) theClass = Handle(MS_StdClass)::DownCast(aClass); + + if (!theClass.IsNull()) { + Standard_Integer i; + + Handle(MS_HSequenceOfMemberMet) methods = theClass->GetMethods(); + Handle(MS_Method) friendmethod; + Handle(TCollection_HAsciiString) publics = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) protecteds = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) privates = new TCollection_HAsciiString; + Handle(TCollection_HAsciiString) SuppMethod = new TCollection_HAsciiString; + + Handle(TColStd_HSequenceOfHAsciiString) Supplement = new TColStd_HSequenceOfHAsciiString; + + Standard_Boolean HasInlineMethod = Standard_False, + HasDestructor = Standard_False; + + + api->AddVariable(VTICIncludes,""); + api->AddVariable(VTICPublicfriends,""); + api->AddVariable(VTICProtectedfields,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICDefines,""); + api->AddVariable(VTICInlineIncludes,""); + api->AddVariable(VTICUndefines,""); + api->AddVariable(VTICPrivatefriends,""); + api->AddVariable(VTICPrivatefields,""); + api->AddVariable(VSuffix,""); + api->AddVariable(VTICSuppMethod,""); + + api->AddVariable(VClass,theClass->FullName()->ToCString()); + api->AddVariable(VInherits,theClass->GetInheritsNames()->Value(1)->ToCString()); + + for (i = 1; i <= theClass->GetFriendsNames()->Length(); i++) { + publics->AssignCat("friend "); + api->AddVariable(VIClass,theClass->GetFriendsNames()->Value(i)->ToCString()); + api->Apply(VTICPublicfriends,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICPublicfriends)); + } + + if (!CPP_SetFriendMethod(aMeta,api,theClass->GetFriendMets(),publics)) { + ErrorMsg << "CPPExt" << "a friend method was not found..." << endm; + Standard_NoSuchObject::Raise(); + } + + api->AddVariable(VTICPublicfriends,publics->ToCString()); + + publics->Clear(); + + // extraction of the methods + // + Handle(TCollection_HAsciiString) aliasMethod; + + for (i = 1; i <= methods->Length(); i++) { + aliasMethod.Nullify(); + + if (methods->Value(i)->IsInline()) { + HasInlineMethod = Standard_True; + } + + // if the class has no destructor we give it + // + if (methods->Value(i)->IsDestructor()) { + HasDestructor = Standard_True; + } + + if (!methods->Value(i)->IsAlias().IsNull() || methods->Value(i)->IsDestructor()) { + aliasMethod = CPP_BuildAliasMethod(aMeta,api,methods->Value(i)); + } + + // Function Call c++ comment : + // it s must be in the _0.cxx or ixx file + // so we add it in the supplement sequence + // + if (methods->Value(i)->IsFunctionCall()) { + SuppMethod->AssignCat(CPP_BuildAliasMethod(aMeta,api,methods->Value(i))); + } + + CPP_BuildMethod(aMeta,api,methods->Value(i),methods->Value(i)->Name()); + +#ifdef WNT + if ( !methods -> Value ( i ) -> IsInline () ) +#endif // WNT + api->Apply(VMethod,"MethodTemplateDec"); +#ifdef WNT + else + api->Apply(VMethod,"MethodTemplateDecInlineWNT" ); +#endif // WNT + + if (methods->Value(i)->Private()) { + privates->AssignCat(api->GetVariableValue(VMethod)); + if (!aliasMethod.IsNull()) { + privates->AssignCat(aliasMethod); + } + } + else if ((theClass->Deferred() && methods->Value(i)->IsKind(STANDARD_TYPE(MS_Construc))) || + methods->Value(i)->IsProtected()) { + protecteds->AssignCat(api->GetVariableValue(VMethod)); + if (!aliasMethod.IsNull()) { + protecteds->AssignCat(aliasMethod); + } + } + else { + publics->AssignCat(api->GetVariableValue(VMethod)); + if (!aliasMethod.IsNull()) { + publics->AssignCat(aliasMethod); + } + } + } + + if (!HasDestructor) { + api->Apply(VMethod,"EmptyDestructorTemplate"); + publics->AssignCat(api->GetVariableValue(VMethod)); + } + + api->AddVariable(VTICPublicmets,publics->ToCString()); + api->AddVariable(VTICPrivatemets,privates->ToCString()); + api->AddVariable(VTICProtectedmets,protecteds->ToCString()); + + publics->Clear(); + privates->Clear(); + protecteds->Clear(); + + // extraction of fields + // + Handle(MS_HSequenceOfField) fields = theClass->GetFields(); + + for (i = 1; i <= fields->Length(); i++) { + if (fields->Value(i)->Protected()) { + protecteds->AssignCat(CPP_BuildField(aMeta,fields->Value(i))); + } + else { + privates->AssignCat(CPP_BuildField(aMeta,fields->Value(i))); + } + } + + api->AddVariable(VTICPrivatefields,privates->ToCString()); + api->AddVariable(VTICProtectedfields,protecteds->ToCString()); + + publics->Clear(); + privates->Clear(); + protecteds->Clear(); + + // others inline methods and functions (ex. function call) + // + api->AddVariable(VTICSuppMethod,SuppMethod->ToCString()); + + // include the lxx if the class have inline methods + // + if (HasInlineMethod) { + Handle(MS_InstClass) aCreator = theClass->GetMyCreator(); + + if (aCreator.IsNull()) { + api->AddVariable(VIClass,theClass->FullName()->ToCString()); + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeNoSafe"); + } + // this part is for class created by instantiations + // + else { + if (theClass->GetMother().IsNull()) { + api->AddVariable(VIClass,aCreator->GenClass()->ToCString()); + } + else { + api->AddVariable(VIClass,theClass->GetMother()->ToCString()); + } + api->AddVariable(VSuffix,"lxx"); + api->Apply(VTICInlineIncludes,"IncludeNoSafe"); + + CPP_GenericDefine(aMeta,api,aCreator,VTICDefines,VTICUndefines,Standard_True); + } + } + + Handle(TColStd_HSequenceOfHAsciiString) List = new TColStd_HSequenceOfHAsciiString; + Handle(TColStd_HSequenceOfHAsciiString) incp = new TColStd_HSequenceOfHAsciiString; + + CPP_UsedTypes(aMeta,theClass,List,incp); + + publics->Clear(); + + api->AddVariable(VSuffix,"hxx"); + + for (i = 1; i <= List->Length(); i++) { + if (!List->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,List->Value(i)->ToCString()); +#ifdef WNT + api->Apply(VTICIncludes,"IncludeNoSafe"); +#else + api->Apply(VTICIncludes,"Include"); +#endif + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + + for (i = 1; i <= incp->Length(); i++) { + if (!incp->Value(i)->IsSameString(theClass->FullName())) { + api->AddVariable(VIClass,incp->Value(i)->ToCString()); + api->Apply(VTICIncludes,"ShortDec"); + publics->AssignCat(api->GetVariableValue(VTICIncludes)); + } + } + + api->AddVariable(VTICIncludes,publics->ToCString()); + + api->Apply(VoutClass,"TransientInstClass"); + + // we write the .hxx of this class + // + Handle(TCollection_HAsciiString) aFile = new TCollection_HAsciiString(api->GetVariableValue(VFullPath)); + + aFile->AssignCat(theClass->FullName()); + aFile->AssignCat(".hxx"); + + CPP_WriteFile(api,aFile,VoutClass); + + outfile->Append(aFile); + + // .ixx or _0.cxx + // + if (!HasDestructor) { + api->Apply(VMethod,"FullEmptyDestructorTemplate"); + Supplement->Append(new TCollection_HAsciiString(api->GetVariableValue(VMethod))); + } + + CPP_TransientDerivated(aMeta,api,aClass,outfile,incp,Supplement); + } + else { + ErrorMsg << "CPPExt" << "CPP_TransientClass - the class is NULL..." << endm; + Standard_NoSuchObject::Raise(); + } +} + diff --git a/src/CPPExt/FILES b/src/CPPExt/FILES new file mode 100755 index 0000000..fc5b85a --- /dev/null +++ b/src/CPPExt/FILES @@ -0,0 +1,20 @@ +CPPExt.cxx +CPPExt_Transient.cxx +CPPExt_PersistentOBJY.cxx +CPPExt_PersistentCSFDB.cxx +CPPExt_PersistentOBJS.cxx +CPPExt_Exception.cxx +CPPExt_Storable.cxx +CPPExt_Package.cxx +CPPExt_MPV.cxx +CPPExt_Enum.cxx +CPPExt_Alias.cxx +CPPExt_Pointer.cxx +CPPExt_TemplateOBJY.edl +CPPExt_TemplateCSFDB.edl +CPPExt_TemplateOBJS.edl +CPPExt_Template.edl +CPPExt.hxx +CPPExt_Define.hxx +FILES +CPPExt_Standard.edl -- 2.39.5