Initial commit to the PapyrusRT repository.
This is the initial commit as submitted to CQ 9646.
The repository contains two top-level folders:
- codegen: the code-generator
- rts: the run-time system
Also-by: Andrew Eidsness, Zeligsoft contractor, andrewe@jfront.com,
Barry Maher, Zeligsoft contractor, bmaher@gpinc.ca, Ernesto Posse,
Zeligsoft, eposse@zeligsoft.com, Tim McGuire, Zeligsoft,
tmcguire@zeligsoft.com, Young-Soo Roh, Zeligsoft, ysroh@zeligsoft.com,
Toby McClean, Zeligsoft, toby@zeligsoft.com, Charles Rivet, Zeligsoft,
charles@zeligsoft.com, Andreas Henriksson, Ericsson,
andreas.henriksson@ericsson.com, Akos Horvath, IncQuery Labs,
akos.horvath@incquerylabs.com, Gabor Batori, Ericsson,
Gabor.Batori@ericsson.com, Abel Hegedus, IncQuery Labs,
abel.hegedus@incquerylabs.com, Denes Harmath, IncQuery Labs,
harmathdenes@gmail.com
Signed-off-by: Ernesto Posse <eposse@gmail.com>
diff --git a/rts/umlrt/umlrtframeprotocol.cc b/rts/umlrt/umlrtframeprotocol.cc
new file mode 100644
index 0000000..771b8cd
--- /dev/null
+++ b/rts/umlrt/umlrtframeprotocol.cc
@@ -0,0 +1,372 @@
+// umlrtframeprotocol.cc
+
+/*******************************************************************************
+* Copyright (c) 2014-2015 Zeligsoft (2009) Limited and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*******************************************************************************/
+
+#include "umlrtcapsule.hh"
+#include "umlrtcapsuleid.hh"
+#include "umlrtcapsulepart.hh"
+#include "umlrtcommsport.hh"
+#include "umlrtcontroller.hh"
+#include "umlrtframeprotocol.hh"
+#include "umlrtframeservice.hh"
+#include "basefatal.hh"
+
+// Return true if a subClass is a sub-class of baseClass.
+bool UMLRTFrameProtocol::OutSignals::classIsKindOf( const UMLRTCommsPort * srcPort, const UMLRTCapsuleClass & subClass, const UMLRTCapsuleClass & baseClass )
+{
+ bool isKindOf = false;
+ const UMLRTCapsuleClass * parentClass = &subClass;
+
+ while ((parentClass != NULL) && !isKindOf)
+ {
+ if (parentClass == &baseClass)
+ {
+ isKindOf = true;
+ }
+ parentClass = parentClass->super;
+ }
+ return isKindOf;
+}
+
+// Return the name of a capsule class.
+const char * UMLRTFrameProtocol::OutSignals::className( const UMLRTCommsPort * srcPort, const UMLRTCapsuleClass & capsuleClass )
+{
+ return capsuleClass.name;
+}
+
+// Return the capsule class of a capsule instance.
+const UMLRTCapsuleClass & UMLRTFrameProtocol::OutSignals::classOf( const UMLRTCommsPort * srcPort, const UMLRTCapsuleId id )
+{
+ return *id.getCapsule()->getClass();
+}
+
+
+bool UMLRTFrameProtocol::OutSignals::deport( const UMLRTCommsPort * srcPort, const UMLRTCapsuleId id, const UMLRTCapsulePart * part )
+{
+ bool ok = false;
+
+ // Initialize error code to E_NONE, in case anybody looks at it after success.
+ srcPort->slot->controller->setError(UMLRTController::E_OK);
+
+ if (!id.isValid())
+ {
+ srcPort->slot->controller->setError(UMLRTController::E_DEPORT_INVLD);
+ }
+ else if (!part->role()->plugin)
+ {
+ srcPort->slot->controller->setError(UMLRTController::E_DEPORT_NONPLUG);
+ }
+ else
+ {
+ UMLRTCapsule * capsule = id.getCapsule();
+
+ // Only specified the the capsule id within the part - we must find the slot being deported.
+ for (size_t i = 0; (i < part->role()->multiplicityUpper) && !ok; ++i)
+ {
+ if (part->slots[i]->capsule == capsule)
+ {
+ ok = true;
+ UMLRTFrameService::requestControllerDeport(part->slots[i], false/*lockAcquired*/);
+ }
+ }
+ if (!ok)
+ {
+ srcPort->slot->controller->setError(UMLRTController::E_DEPORT_NOINST);
+ }
+ }
+ return ok;
+}
+
+bool UMLRTFrameProtocol::OutSignals::destroy( const UMLRTCommsPort * srcPort, const UMLRTCapsuleId id )
+{
+ bool ok = false;
+ UMLRTCapsule * capsule = id.getCapsule();
+
+ // Initialize error code to E_NONE, in case anybody looks at it after success.
+ srcPort->slot->controller->setError(UMLRTController::E_OK);
+
+ if (capsule == NULL)
+ {
+ srcPort->slot->controller->setError(UMLRTController::E_DESTR_INVALID);
+ }
+ else if (capsule->getSlot()->role() == NULL)
+ {
+ FATAL("Destroying capsule without a role. Destroying Top?");
+ }
+ else if (capsule->getSlot()->role()->optional)
+ {
+ srcPort->slot->controller->setError(UMLRTController::E_DESTR_NONOPT);
+ }
+ else
+ {
+ // Either we destroy the capsule in this context or we send a DESTROY Controller Command to execute the destroy.
+ UMLRTFrameService::requestControllerDestroy(capsule->getSlot(), true/*isTopSlot*/, false/*lockAcquired*/);
+ ok = true;
+ }
+ return ok;
+}
+
+bool UMLRTFrameProtocol::OutSignals::destroy( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part )
+{
+ bool ok = false;
+
+ // Initialize error code to E_NONE, in case anybody looks at it after success.
+ srcPort->slot->controller->setError(UMLRTController::E_OK);
+
+ if (part->role() == NULL)
+ {
+ FATAL("Destroying part without a role. Destroying Top?");
+ }
+ if (!part->role()->optional)
+ {
+ srcPort->slot->controller->setError(UMLRTController::E_DESTR_NONOPT);
+ }
+ else
+ {
+ ok = true; // Assume ok from this point.
+
+ for (size_t i = part->role()->multiplicityLower; i < part->numSlot; ++i)
+ {
+ if (part->slots[i]->capsule != NULL)
+ {
+ // Either we destroy the capsule in this context or we send a DESTROY Controller Command to execute the destroy.
+ // This is a destroy of multiple slots and each is the 'top slot' of its associated sub-structure.
+ UMLRTFrameService::requestControllerDestroy(part->slots[i], true/*isTopSlot*/, false/*lockAcquired*/);
+ ok = true;
+ }
+ }
+ }
+ return ok;
+}
+
+bool UMLRTFrameProtocol::OutSignals::import( const UMLRTCommsPort * srcPort, const UMLRTCapsuleId id, const UMLRTCapsulePart * destPart, int index )
+{
+ bool ok = false;
+
+ if (!id.isValid())
+ {
+ srcPort->slot->controller->setError(UMLRTController::E_IMPORT_NOINST);
+ }
+ else
+ {
+ ok = UMLRTFrameService::importCapsule(srcPort, id.getCapsule(), destPart, index);
+ }
+ return ok;
+}
+
+bool UMLRTFrameProtocol::OutSignals::import( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * srcPart, const UMLRTCapsulePart * dest, int index )
+{
+ bool ok = false;
+
+ if ((srcPart->numSlot > 1) && index == -1)
+ {
+ srcPort->slot->controller->setError(UMLRTController::E_IMPORT_PARTREPL);
+ }
+ else if (srcPart->slots[0]->capsule == NULL)
+ {
+ srcPort->slot->controller->setError(UMLRTController::E_IMPORT_NOINST);
+ }
+ else
+ {
+ ok = UMLRTFrameService::importCapsule(srcPort, srcPart->slots[0]->capsule, dest, index);
+ }
+ return ok;
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, const char * logThread, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part, // part
+ NULL, // capsuleClass
+ NULL, // userData
+ NULL, // type
+ logThread,
+ NULL, // controller
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, UMLRTController * controller, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part,
+ NULL, // capsuleClass
+ NULL, // userData
+ NULL, // type
+ NULL, // logThread
+ controller,
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, const UMLRTCapsuleClass & capsuleClass, const char * logThread, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part,
+ &capsuleClass,
+ NULL, // userData
+ NULL, // type
+ logThread,
+ NULL, // controller
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, const UMLRTCapsuleClass & capsuleClass, UMLRTController * controller, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part,
+ &capsuleClass,
+ NULL, // userData
+ NULL, // type
+ NULL, // logThread
+ controller,
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, const void * userData, const UMLRTObject_class * type, const char * logThread, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part,
+ NULL, // capsuleClass
+ userData,
+ type,
+ logThread,
+ NULL, // controller
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, const void * userData, const UMLRTObject_class * type, UMLRTController * controller, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part,
+ NULL, // capsuleClass
+ userData,
+ type,
+ NULL, // logThread
+ controller,
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, const UMLRTCapsuleClass & capsuleClass, const void * userData, const UMLRTObject_class * type, const char * logThread, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part,
+ &capsuleClass,
+ userData,
+ type,
+ logThread,
+ NULL, // controller
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, const UMLRTCapsuleClass & capsuleClass, const void * userData, const UMLRTObject_class * type, UMLRTController * controller, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part,
+ &capsuleClass,
+ userData,
+ type,
+ NULL, // logThread
+ controller,
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, const UMLRTTypedValue * value, const char * logThread, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part,
+ NULL, // capsuleClass
+ value->data, // userData
+ value->type, // type
+ logThread,
+ NULL, // controller
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, const UMLRTTypedValue * value, UMLRTController * controller, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part,
+ NULL, // capsuleClass
+ value->data, // userData
+ value->type, // type
+ NULL, // logThread
+ controller,
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, const UMLRTCapsuleClass & capsuleClass, const UMLRTTypedValue * value, const char * logThread, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part,
+ &capsuleClass,
+ value->data, // userData
+ value->type, // type
+ logThread,
+ NULL, // controller
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnate( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, const UMLRTCapsuleClass & capsuleClass, const UMLRTTypedValue * value, UMLRTController * controller, int index ) const
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part,
+ &capsuleClass,
+ value->data, // userData
+ value->type, // type
+ NULL, // logThread
+ controller,
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::incarnateAt( const UMLRTCommsPort * srcPort, const UMLRTCapsulePart * part, int index )
+{
+ return UMLRTFrameService::incarnateCapsule(
+ srcPort,
+ part, // part
+ NULL, // capsuleClass
+ NULL, // userData
+ NULL, // type
+ NULL, // logThread
+ NULL, // controller
+ index
+ );
+}
+
+const UMLRTCapsuleId UMLRTFrameProtocol::OutSignals::me( const UMLRTCommsPort * srcPort )
+{
+ return UMLRTCapsuleId(srcPort->slot->capsule);
+}
+
+const UMLRTCapsuleClass & myClass( const UMLRTCommsPort * srcPort )
+{
+ return *srcPort->slot->capsule->getClass();
+}