bug#1034: 23.0.60; The attached mail crashes Emacs when viewed with Gnus

bug#1034: 23.0.60; The attached mail crashes Emacs when viewed with Gnus

[Tassilo Horn]

[-- Attachment #1: Type: text/plain, Size: 316 bytes --]

Hi,

the attached mail crashes emacs when trying to read it with Gnus.

I select it with RET in the *Summary* buffer and it is displayed.  Now
hitting RET again will scroll it a bit, and after I scrolled some lines
it completely crashes my emacs process.

My emacs version is from this morning (CET).

Bye,
Tassilo


[-- Attachment #2: Type: message/rfc822, Size: 127404 bytes --]

[-- Attachment #2.1.1: Type: text/plain, Size: 1069 bytes --]

Hi!

Irgendein fieser Fehler steckt in JGraLab. Äußert sich in Kanten, die  
weder in der eSeq noch in der Freiliste sind.

Man kann dies so provozieren:

RSLEditor starten und den Graph aus dem Anhang laden.
Requirement r1 wählen
ModalSVO-Satz doppelklicken
im Sentence-Dialog "Save" drücken
Satz nochmal doppelklicken
im Sentence-Dialog 2x Parse, 1x Save

danach kracht das "selectedSentence.delete()" in Zeile 292 von

   gui/requirementsview/SentenceTablePanel.java

Evtl. wird auch irgendein Knoten vorher doppelt gelöscht, aber das  
_müsste_ eine RuntimeException schmeißen (der Parser-Dialog ist noch  
buggy, darf aber nicht JGraLab aus dem Tritt bringen.

-- 
Viele Grüße: Volker Riediger
________________________________________________________________________

Dr. Volker Riediger                  E-Mail: riediger@uni-koblenz.de
University of Koblenz-Landau,        Voice:  +49 261 287 2706
Institute for Software Technology    Fax:    +49 261 287 2721
PF 201602, D-56016 Koblenz, Germany  http://www.uni-koblenz.de/~riediger

[-- Attachment #2.1.2: my-simple-example.scl.tg --]
[-- Type: application/octet-stream, Size: 92082 bytes --]

Schema eu.redseeds.scl.SCLSchema;
GraphClass SCLGraph { uid: String };
Package ea;
VertexClass Attribute: ClassifiedObject { allowDuplicates: Boolean,  defaultValue: String,  isConst: Boolean,  isDerived: Boolean,  isOrdered: Boolean,  isStatic: Boolean,  lowerBound: String,  upperBound: String,  visibility: String };
abstract VertexClass ClassifiedObject: TaggedObject;
VertexClass Connector: TaggedObject { direction: String,  sequenceNo: Integer,  subtype: String,  transitionGuard: String };
VertexClass ConnectorEnd: TaggedObject { aggregation: Integer,  allowDuplicates: String,  cardinality: String,  constraint: String,  derived: Boolean,  derivedUnion: Boolean,  isChangable: Boolean,  isNavigable: Boolean,  navigable: String,  ordering: Integer,  qualifier: String,  roleType: String,  visibility: String };
abstract VertexClass EAObject { guid: String,  name: String };
VertexClass Element: ClassifiedObject { genType: String,  isAbstract: Boolean,  isLeaf: Boolean,  subtype: Integer,  tag: String,  visibility: String };
VertexClass Method: ClassifiedObject { isAbstract: Boolean,  isStatic: Boolean,  throwsException: String,  visibility: String };
VertexClass Model: 'Package;
VertexClass 'Package: EAObject;
VertexClass Parameter: ClassifiedObject { defaultValue: String,  kind: String,  position: Integer };
abstract VertexClass TaggedObject: EAObject { stereotype: String,  type: String };
VertexClass TaggedValue: EAObject { value: String };
CompositionClass AttributesIsPartOfElement from Attribute (0,*) role attributes to Element (1,1) role element aggregate to;
EdgeClass ClassifierLinksToClassifiedObject from Element (0,1) role classifier to ClassifiedObject (0,*) role classifiedObject;
CompositionClass ClientEndIsPartOfConn_cl from ConnectorEnd (1,1) role clientEnd to Connector (0,1) role conn_cl aggregate to;
EdgeClass ClientLinksToConn_cl from Element (1,1) role client to Connector (0,*) role conn_cl;
CompositionClass Conn_suContainsSupplierEnd from Connector (0,1) role conn_su to ConnectorEnd (1,1) role supplierEnd aggregate from;
CompositionClass ConnectorsIsPartOfPackage from Connector (0,*) role connectors to 'Package (0,1) role package aggregate to;
CompositionClass ElementsIsPartOfPackage from Element (0,*) role elements to 'Package (0,1) role package aggregate to;
CompositionClass MethodsIsPartOfElement from Method (0,*) role methods to Element (1,1) role element aggregate to;
CompositionClass PackagesIsPartOfParent from 'Package (0,*) role packages to 'Package (0,1) role parent aggregate to;
CompositionClass ParametersIsPartOfMethod from Parameter (0,*) role parameters to Method (1,1) role method aggregate to;
CompositionClass ParentContainsElements from Element (0,1) role parent to Element (0,*) role elements aggregate from;
EdgeClass ReferenceLinksToReferencedObj from TaggedValue (0,*) role reference to TaggedObject (0,1) role referencedObj;
EdgeClass SupplierLinksToConn_su from Element (1,1) role supplier to Connector (0,*) role conn_su;
CompositionClass TaggedValuesIsPartOfObject from TaggedValue (0,*) role taggedValues to TaggedObject (1,1) role object aggregate to;
Package java5;
Package mapping;
VertexClass Mapping;
VertexClass MappingInformation;
VertexClass MappingTable;
VertexClass SimilarityValue { similarity: Double };
CompositionClass CurrentSoftwareCaseIsPartOfMappingInformation from sclkernel.SoftwareCase (1,1) role currentSoftwareCase to MappingInformation (1,1) aggregate to;
CompositionClass MappingIsPartOfMappingTable from Mapping (1,1) to MappingTable (1,1) aggregate to;
EdgeClass MappingLinksToCurrentElement from Mapping (0,1) to rsl.rslkernel.elements.RepresentableElement (1,1) role currentElement;
EdgeClass MappingLinksToPastElement from Mapping (0,1) to rsl.rslkernel.elements.RepresentableElement (1,1) role pastElement;
CompositionClass MappingTableIsPartOfMappingInformation from MappingTable (1,1) to MappingInformation (1,1) aggregate to;
CompositionClass PastSoftwareCaseIsPartOfMappingInformation from sclkernel.SoftwareCase (1,1) role pastSoftwareCase to MappingInformation (1,1) aggregate to;
CompositionClass SimilarityIsPartOfMapping from SimilarityValue (1,1) role similarity to Mapping (1,1) aggregate to;
Package rsl;
Package sclkernel;
VertexClass ArchitecturalModel: SoftwareArtifact;
VertexClass Clipboard: SCLElement { name: String };
VertexClass DetailedDesignModel: SoftwareArtifact;
VertexClass Implements: TraceabilityLink;
VertexClass IsAllocatedTo: TraceabilityLink;
VertexClass IsDependentOn: TraceabilityLink;
abstract VertexClass SCLElement { uid: String };
abstract VertexClass SCLElementsPackage: SCLElement { name: String };
abstract VertexClass SCLRelationship { uid: String };
VertexClass Satisfies: TraceabilityLink;
abstract VertexClass SoftwareArtifact: SCLElementsPackage;
VertexClass SoftwareCase: SCLElementsPackage;
VertexClass SourceCode: SoftwareArtifact;
VertexClass TraceabilityLink: SCLRelationship { isGenerated: Boolean };
VertexClass Transformations: SoftwareArtifact;
EdgeClass AllocationToRSLLinksToAllocationTarget: SCLRelationshipLinksToTarget from IsAllocatedTo (0,*) role allocationToRSL to uml.classes.kernel.NamedElement (1,1) role allocationTarget;
EdgeClass AllocationToUMLLinksToAllocationSource: SCLRelationshipLinksToSource from IsAllocatedTo (0,*) role allocationToUML to SCLElement (1,1) role allocationSource;
CompositionClass ArtifactContainsOwnedTrace from SoftwareArtifact (1,1) role artifact to TraceabilityLink (0,*) role ownedTrace aggregate from;
CompositionClass ArtifactContainsUmlModel from SoftwareArtifact (0,1) role artifact to uml.auxiliaryconstructs.models.Model (0,*) role umlModel aggregate from;
EdgeClass ClientDependentOnLinksToDependencySource: SCLRelationshipLinksToSource from IsDependentOn (0,*) role clientDependentOn to uml.classes.kernel.NamedElement (1,1) role dependencySource;
EdgeClass ClipboardMemberLinksToParentClipboard from SCLElement (0,*) role clipboardMember to Clipboard (0,*) role parentClipboard;
CompositionClass ContainedClipboardIsPartOfParentSoftwareCase from Clipboard (0,*) role containedClipboard to SoftwareCase (1,1) role parentSoftwareCase aggregate to;
EdgeClass EaObjectLinksToSclElement from ea.EAObject (0,*) role eaObject to SCLElement (0,*) role sclElement;
EdgeClass ImplementsLinksToImplementationSource: SCLRelationshipLinksToSource from Implements (0,*) to SCLElement (1,1) role implementationSource;
EdgeClass ImplementsLinksToImplementationTarget: SCLRelationshipLinksToTarget from Implements (0,*) to SCLElement (1,1) role implementationTarget;
abstract CompositionClass SCLElementsPackageContainsElement from SCLElementsPackage (0,*) to SCLElement (0,*) role element aggregate from;
abstract CompositionClass SCLElementsPackageContainsNestedPackage: SCLElementsPackageContainsElement from SCLElementsPackage (0,1) to SCLElementsPackage (0,*) role nestedPackage aggregate from;
CompositionClass SCLElementsPackageContainsRelation from SCLElementsPackage (0,*) to SCLRelationship (0,*) role relation aggregate from;
abstract EdgeClass SCLRelationshipLinksToSource from SCLRelationship (0,*) to SCLElement (1,1) role source;
abstract EdgeClass SCLRelationshipLinksToTarget from SCLRelationship (0,*) to SCLElement (1,1) role target;
EdgeClass SatisfiesLinksToSatisfactionSource: SCLRelationshipLinksToSource from Satisfies (0,*) to uml.classes.kernel.NamedElement (1,1) role satisfactionSource;
EdgeClass SatisfiesLinksToSatisfactionTarget: SCLRelationshipLinksToTarget from Satisfies (0,*) to SCLElement (1,1) role satisfactionTarget;
CompositionClass SoftwareCaseContainsArtifact: SCLElementsPackageContainsElement from SoftwareCase (0,1) to SoftwareArtifact (0,*) role artifact aggregate from;
CompositionClass SoftwareCaseContainsTrace from SoftwareCase (1,1) to TraceabilityLink (0,*) role trace aggregate from;
EdgeClass SupplierDependentOnLinksToDependencyTarget: SCLRelationshipLinksToTarget from IsDependentOn (0,*) role supplierDependentOn to uml.classes.kernel.NamedElement (1,1) role dependencyTarget;
Package uml;
Package java5.annotations;
VertexClass Annotation: sclkernel.SCLElement { name: String };
EdgeClass IsAnnotationArgumentOf from java5.expressions.Expression (0,*) to Annotation (1,1) role fullannotation;
EdgeClass IsAnnotationNameOf from java5.basiclanguageelements.Identifier (1,1) to Annotation (1,1) role annotation;
EdgeClass IsAnnotationOfEnumConstant from Annotation (1,1) to java5.members.EnumConstant (1,1) role enumconstant;
EdgeClass IsAnnotationOfMember from Annotation (0,*) to java5.members.Member (1,1) role member;
EdgeClass IsAnnotationOfPackage from Annotation (0,*) to java5.programs.JavaPackage (1,1) role package;
EdgeClass IsAnnotationOfType from Annotation (0,*) to java5.types.Type (1,1) role type;
EdgeClass IsAnnotationOfVariable from Annotation (0,*) to java5.statements.Declaration (1,1) role declaration;
EdgeClass IsMetaAnnotationOf from Annotation (0,*) to java5.types.AnnotationDefinition (1,1) role annotationdefinition;
Package java5.basiclanguageelements;
VertexClass Block: sclkernel.SCLElement;
VertexClass Identifier: sclkernel.SCLElement { name: String };
VertexClass JavaModifier: sclkernel.SCLElement { type: Integer };
VertexClass ParameterDeclaration: sclkernel.SCLElement;
VertexClass QualifiedName: QualifiedType;
VertexClass QualifiedType: java5.typespecifications.TypeSpecification;
VertexClass VariableLengthDeclaration: ParameterDeclaration;
EdgeClass IsAnnotationBlockOf from Block (1,1) to java5.types.AnnotationDefinition (1,1) role annotationdefinition;
EdgeClass IsAnnotationDefinitionNameOf from Identifier (1,1) to java5.types.AnnotationDefinition (1,1) role annotationdefinition;
EdgeClass IsBreakTargetOf from Identifier (0,1) to java5.statements.Break (1,1) role breakstatement;
EdgeClass IsCaughtExceptionOf from ParameterDeclaration (1,1) to java5.statements.Catch (1,1) role catchstatement;
EdgeClass IsClassBlockOf from Block (1,1) to java5.types.ClassDefinition (1,1) role classdefinition;
EdgeClass IsClassNameOf from Identifier (1,1) to java5.types.ClassDefinition (1,1) role classdefinition;
EdgeClass IsContinueTargetOf from Identifier (0,1) to java5.statements.Continue (1,1) role continuestatement;
EdgeClass IsEnumBlockOf from Block (1,1) to java5.types.EnumDefinition (1,1) role enumdefinition;
EdgeClass IsEnumConstantBlockOf from Block (1,1) to java5.members.EnumConstant (0,*);
EdgeClass IsEnumConstantNameOf from Identifier (1,1) to java5.members.EnumConstant (1,1) role enumconstant;
EdgeClass IsEnumNameOf from Identifier (1,1) to java5.types.EnumDefinition (1,1) role enumdefinition;
EdgeClass IsFieldNameOf from Identifier (1,1) to java5.expressions.FieldAccess (1,1) role fieldaccess;
EdgeClass IsImportDefinitionOf from QualifiedName (1,1) to java5.programs.Import (1,1) role translationunit;
EdgeClass IsInterfaceBlockOf from Block (1,1) to java5.types.InterfaceDefinition (1,1) role interfacedefinition;
EdgeClass IsInterfaceNameOf from Identifier (1,1) to java5.types.InterfaceDefinition (1,1) role interfacedefinition;
EdgeClass IsLabelNameOf from Identifier (1,1) to java5.statements.Label (1,1) role labelattachedstatement;
EdgeClass IsMemberOf from java5.members.Member (0,*) to Block (1,1);
EdgeClass IsModifierOfAnnotation from JavaModifier (0,*) to java5.types.AnnotationDefinition (1,1) role annotationdefinition;
EdgeClass IsModifierOfClass from JavaModifier (0,*) to java5.types.ClassDefinition (1,1) role classdefinition;
EdgeClass IsModifierOfConstructor from JavaModifier (0,*) to java5.members.ConstructorDefinition (1,1) role constructordeclaration;
EdgeClass IsModifierOfEnum from JavaModifier (0,*) to java5.types.EnumDefinition (1,1) role enumdefinition;
EdgeClass IsModifierOfInterface from JavaModifier (0,2) to java5.types.InterfaceDefinition (1,1) role interfacedefinition;
EdgeClass IsModifierOfMethod from JavaModifier (0,*) to java5.members.MethodDeclaration (1,1) role methoddeclaration;
EdgeClass IsModifierOfParameter from JavaModifier (0,1) to ParameterDeclaration (1,1);
EdgeClass IsModifierOfVariable from JavaModifier (0,*) to java5.statements.Declaration (1,1) role declaration;
EdgeClass IsNameOfConstructor from Identifier (1,1) to java5.members.ConstructorDefinition (1,1) role constructordeclaration;
EdgeClass IsNameOfInvocatedMethod from Identifier (1,1) to java5.expressions.MethodInvocation (1,1) role methodinvocation;
EdgeClass IsNameOfMethod from Identifier (1,1) to java5.members.MethodDeclaration (1,1) role methoddeclaration;
EdgeClass IsParameterNameOf from Identifier (1,1) to ParameterDeclaration (1,1);
EdgeClass IsParameterOfConstructor from ParameterDeclaration (0,*) to java5.members.ConstructorDefinition (1,1) role constructordeclaration;
EdgeClass IsParameterOfForEachClause from ParameterDeclaration (1,1) to java5.statements.ForEachClause (1,1) role foreachclause;
EdgeClass IsParameterOfMethod from ParameterDeclaration (0,*) to java5.members.MethodDeclaration (1,1) role methoddeclaration;
EdgeClass IsQualifiedTypeOf from QualifiedType (0,1) to QualifiedType (1,1);
EdgeClass IsTypeNameOf from Identifier (1,1) to QualifiedType (1,1);
EdgeClass IsTypeOfParameter from java5.typespecifications.TypeSpecification (1,1) to ParameterDeclaration (1,1) role parameterdeclaration;
EdgeClass IsTypeParameterDeclarationNameOf from Identifier (1,1) to java5.typespecifications.TypeParameterDeclaration (1,1);
EdgeClass IsTypeParameterUsageNameOf from Identifier (1,1) to java5.typespecifications.TypeParameterUsage (1,1);
EdgeClass IsVariableNameOf from Identifier (1,*) to java5.statements.Declaration (1,1) role declaration;
Package java5.comments;
abstract VertexClass Comment: sclkernel.SCLElement;
VertexClass JavaDocComment: Comment;
VertexClass MultiLineComment: Comment;
VertexClass SingleLineComment: Comment;
EdgeClass IsCommentIn from Comment (0,*) to java5.programs.SourceFile (1,1);
Package java5.constants;
EnumDomain BuiltInTypes ( BOOLEAN, CHAR, BYTE, SHORT, INT, LONG, FLOAT, DOUBLE );
EnumDomain InfixOperators ( ASSIGN, PLUS_ASSIGN, MINUS_ASSIGN, DIV_ASSIGN, MUL_ASSIGN, MOD_ASSIGN, B_AND_ASSIGN, B_OR_ASSIGN, B_XOR_ASSIGN, B_NOT_ASSIGN, SHL_ASSIGN, SHR_ASSIGN, UNSIGNED_SHR_ASSIGN, PLUS, MINUS, MUL, DIV, MOD, B_AND, B_OR, B_XOR, L_AND, L_OR, EQ, NEQ, GT, GEQ, LT, LEQ, SHL, SHR, UNSIGNED_SHR, INSTANCEOF );
EnumDomain MethodInvocationTypes ( METHOD, SUPERMETHOD, CONSTRUCTOR, SUPERCONSTRUCTOR, EXPLICITCONSTRUCTOR );
EnumDomain PostfixOperators ( INCR, DECR );
EnumDomain PrefixOperators ( MINUS, PLUS, INCR, DECR, L_NOT, B_NOT );
Package java5.expressions;
VertexClass ArrayCreation: Expression;
VertexClass ArrayInitializer: Expression;
VertexClass BooleanConstant: Constant { value: Boolean };
VertexClass BuiltInCast: Expression;
VertexClass CharConstant: Constant { value: String };
VertexClass ClassCast: Expression;
VertexClass ClassInstanceCreation: Expression;
VertexClass ConditionalExpression: Expression;
abstract VertexClass Constant: Expression { literal: String };
VertexClass DoubleConstant: Constant { value: Double };
abstract VertexClass Expression: java5.statements.Statement;
VertexClass FieldAccess: Expression;
VertexClass FloatConstant: Constant { value: Double };
VertexClass InfixExpression: Expression { operator: java5.constants.InfixOperators };
VertexClass IntegerConstant: Constant { value: Integer };
VertexClass LongConstant: Constant { value: Long };
VertexClass MethodInvocation: Expression { methodInvocationType: java5.constants.MethodInvocationTypes };
VertexClass NullExpression: Expression;
VertexClass PostfixExpression: Expression { operator: java5.constants.PostfixOperators };
VertexClass PrefixExpression: Expression { operator: java5.constants.PrefixOperators };
VertexClass StringConstant: Constant;
VertexClass VariableInitializer: Expression;
EdgeClass IsArgumentOfEnumConstant from Expression (0,*) to java5.members.EnumConstant (1,1) role enumconstant;
EdgeClass IsArgumentOfMethodInvocation from Expression (0,*) to MethodInvocation (1,1);
EdgeClass IsArrayElementIndexOf from Expression (0,*) to FieldAccess (1,1);
EdgeClass IsCaseConditionOf from Expression (1,1) to java5.statements.Case (1,1) role casestatement;
EdgeClass IsCastedBuiltInTypeOf from java5.typespecifications.BuiltInType (1,1) to BuiltInCast (1,1) role builtincast;
EdgeClass IsCastedObjectOf from Expression (1,1) to ClassCast (1,1);
EdgeClass IsCastedTypeOf from java5.typespecifications.TypeSpecification (1,1) to ClassCast (1,1) role classcast;
EdgeClass IsCastedValueOf from Expression (1,1) to BuiltInCast (1,1);
EdgeClass IsConditionOfAssert from Expression (1,1) to java5.statements.Assert (1,1) role assert;
EdgeClass IsConditionOfDoWhile from Expression (1,1) to java5.statements.DoWhile (1,1) role dowhilestatement;
EdgeClass IsConditionOfExpression from Expression (1,1) to ConditionalExpression (1,1);
EdgeClass IsConditionOfIf from Expression (1,1) to java5.statements.If (1,1) role ifstatement;
EdgeClass IsConditionOfWhile from Expression (1,1) to java5.statements.While (1,1) role whilestatement;
EdgeClass IsConstructorInvocationOf from MethodInvocation (1,1) to ClassInstanceCreation (1,1);
EdgeClass IsContentOf from Expression (0,*) to ArrayInitializer (1,1) role arrayinitializer2;
EdgeClass IsDimensionInitializerOf from ArrayInitializer (1,*) to ArrayCreation (1,1);
EdgeClass IsEnumeratableOf from Expression (1,1) to java5.statements.ForEachClause (1,1) role foreachclause;
EdgeClass IsFieldContainerOf from Expression (0,1) to FieldAccess (1,1);
EdgeClass IsForConditionOf from Expression (0,1) to java5.statements.TraditionalForClause (1,1) role traditionalforclause;
EdgeClass IsInitializerOf from Expression (1,1) to VariableInitializer (1,1);
EdgeClass IsInitializerOfVariable from Expression (0,1) to java5.statements.Declaration (1,1) role declaration;
EdgeClass IsIteratorOf from Expression (0,*) to java5.statements.TraditionalForClause (1,1) role traditionalforclause2;
EdgeClass IsLeftHandSideOfInfixExpression from Expression (1,1) to InfixExpression (1,1);
EdgeClass IsLeftHandSideOfPostFixExpression from Expression (1,1) to PostfixExpression (1,1);
EdgeClass IsMatchOf from Expression (1,1) to ConditionalExpression (1,1);
EdgeClass IsMessageOf from Expression (0,1) to java5.statements.Assert (1,1) role assert2;
EdgeClass IsMethodContainerOf from Expression (0,1) to MethodInvocation (1,1);
EdgeClass IsMismatchOf from Expression (1,1) to ConditionalExpression (1,1);
EdgeClass IsMonitorOf from Expression (1,1) to java5.statements.Synchronized (1,1) role synchronizestatement;
EdgeClass IsReturnedBy from Expression (0,1) to java5.statements.Return (1,1) role returnstatement;
EdgeClass IsRightHandSideOfInfixExpression from Expression (1,1) to InfixExpression (1,1);
EdgeClass IsRightHandSideOfPrefixExpression from Expression (1,1) to PrefixExpression (1,1);
EdgeClass IsSizeOf from Expression (0,0) to ArrayInitializer (1,1) role arrayinitializer;
EdgeClass IsSwitchArgumentOf from Expression (1,1) to java5.statements.Switch (1,1) role switchcasestatement;
EdgeClass IsThrownExceptionOf from Expression (1,1) to java5.statements.Throw (1,1) role throwstatement;
EdgeClass IsTypeArgumentOfArrayCreation from java5.typespecifications.TypeArgument (0,1) to ArrayCreation (1,1) role argumentArraycreation;
EdgeClass IsTypeArgumentOfMethodInvocation from java5.typespecifications.TypeArgument (0,1) to MethodInvocation (1,1) role classinstancecreation;
EdgeClass IsTypeOfCreatedArray from java5.typespecifications.TypeSpecification (0,1) to ArrayCreation (1,1) role arraycreation;
Package java5.members;
VertexClass ConstructorDefinition: Member;
VertexClass EnumConstant: Member;
VertexClass Field: Member;
abstract VertexClass Member: sclkernel.SCLElement;
VertexClass MethodDeclaration: Member;
VertexClass MethodDefinition: MethodDeclaration;
VertexClass StaticConstructor: Member;
VertexClass StaticInitializer: Member;
EdgeClass IsBodyOfConstructor from java5.statements.Compound (1,1) to ConstructorDefinition (1,1) role constructordeclaration;
EdgeClass IsBodyOfMethod from java5.statements.Compound (1,1) to MethodDefinition (1,1) role methoddeclaration;
EdgeClass IsBodyOfStaticConstructor from java5.statements.Compound (1,1) to StaticConstructor (1,1) role staticconstructor;
EdgeClass IsBodyOfStaticInitializer from java5.statements.Compound (1,1) to StaticInitializer (1,1) role classinitializer;
EdgeClass IsExceptionThrownByConstructor from java5.typespecifications.TypeSpecification (0,*) to ConstructorDefinition (1,1) role constructordeclaration;
EdgeClass IsExceptionThrownByMethod from java5.typespecifications.TypeSpecification (0,*) to MethodDeclaration (1,1) role throwsclause;
EdgeClass IsFieldCreationOf from java5.statements.Statement (1,1) to Field (1,1) role field;
EdgeClass IsReturnTypeOf from java5.typespecifications.TypeSpecification (1,1) to MethodDeclaration (1,1) role methoddeclaration;
EdgeClass IsTypeParameterOfConstructor from java5.typespecifications.TypeSpecification (0,*) to ConstructorDefinition (1,1) role constructordefinition;
EdgeClass IsTypeParameterOfMethod from java5.typespecifications.TypeSpecification (0,*) to MethodDeclaration (1,1) role methoddeclaration2;
Package java5.programs;
abstract VertexClass ExternalDeclaration: sclkernel.SCLElement;
VertexClass Import: ExternalDeclaration;
VertexClass JavaPackage: ExternalDeclaration { name: String };
VertexClass Program: sclkernel.SCLElement { name: String };
VertexClass SourceFile: sclkernel.SCLElement { name: String };
VertexClass SourceUsage: sclkernel.SCLElement;
VertexClass TranslationUnit: sclkernel.SCLElement;
EdgeClass IncludesSource from SourceUsage (0,1) to SourceUsage (0,*);
EdgeClass IsExternalDeclarationIn from ExternalDeclaration (0,*) to SourceUsage (1,1);
EdgeClass IsPackageOf from JavaPackage (1,*) to Program (1,*);
EdgeClass IsPartOf from TranslationUnit (1,*) to JavaPackage (1,1);
EdgeClass IsPrimarySourceFor from SourceFile (1,1) to TranslationUnit (1,1);
EdgeClass IsSourceFor from SourceFile (1,1) to SourceUsage (1,*);
EdgeClass IsSourceUsageIn from SourceUsage (0,*) to TranslationUnit (1,1);
EdgeClass IsSubPackageOf from JavaPackage (0,*) to JavaPackage (0,1);
EdgeClass IsTranslationUnitIn from TranslationUnit (1,*) to Program (1,1);
Package java5.statements;
VertexClass Assert: Statement;
VertexClass Break: Statement;
VertexClass Case: sclkernel.SCLElement;
VertexClass Catch: Statement;
VertexClass Compound: Statement;
VertexClass Continue: Statement;
VertexClass Declaration: Statement;
VertexClass Default: sclkernel.SCLElement;
VertexClass DoWhile: Statement;
VertexClass EmptyStatement: Statement;
VertexClass ForEachClause: ForHead;
abstract VertexClass ForHead: sclkernel.SCLElement;
VertexClass ForStatement: Statement;
VertexClass If: Statement;
VertexClass Label: Statement;
VertexClass Return: Statement;
abstract VertexClass Statement: sclkernel.SCLElement;
VertexClass Switch: Statement;
VertexClass Synchronized: Statement;
VertexClass Throw: Statement;
VertexClass TraditionalForClause: ForHead;
VertexClass Try: Statement;
VertexClass While: Statement;
EdgeClass IsAttachedTo from Statement (1,1) to Label (1,1);
EdgeClass IsCaseOf from Case (0,*) to Switch (1,1);
EdgeClass IsCatchBodyOf from Compound (1,1) to Catch (1,1);
EdgeClass IsDefaultCaseOf from Default (0,1) to Switch (1,1);
EdgeClass IsElseOf from Statement (0,1) to If (1,1);
EdgeClass IsFinallyBodyOf from Compound (0,1) to Try (1,1);
EdgeClass IsHandlerOf from Catch (0,*) to Try (1,1);
EdgeClass IsHeadOfFor from ForHead (1,1) to ForStatement (1,1);
EdgeClass IsLoopBodyOfDoWhile from Statement (1,1) to DoWhile (1,1);
EdgeClass IsLoopBodyOfFor from Statement (1,1) to ForStatement (1,1);
EdgeClass IsLoopBodyOfWhile from Statement (1,1) to While (1,1);
EdgeClass IsRunVariableInitializationOf from Statement (0,*) to TraditionalForClause (1,1);
EdgeClass IsStatementOfCase from Statement (0,*) to Case (1,1);
EdgeClass IsStatementOfCompound from Statement (0,*) to Compound (1,1);
EdgeClass IsStatementOfDefaultCase from Statement (0,*) to Default (1,1);
EdgeClass IsSynchronizedBodyOf from Compound (1,1) to Synchronized (1,1);
EdgeClass IsThenOf from Statement (1,1) to If (1,1);
EdgeClass IsTryBodyOf from Compound (1,1) to Try (1,1);
EdgeClass IsTypeArgumentOfVariable from java5.typespecifications.TypeArgument (0,*) to Declaration (1,1) role argumentDeclaration;
EdgeClass IsTypeOfVariable from java5.typespecifications.TypeSpecification (1,1) to Declaration (1,1) role declaration;
Package java5.types;
VertexClass AnnotationDefinition: Type;
VertexClass ClassDefinition: Type;
VertexClass EnumDefinition: Type;
VertexClass InterfaceDefinition: Type;
abstract VertexClass Type: java5.programs.ExternalDeclaration, java5.members.Member { name: String };
EdgeClass IsInterfaceOfClass from java5.typespecifications.TypeSpecification (0,*) role implementedInterface to ClassDefinition (1,1) role classdefinition;
EdgeClass IsInterfaceOfEnum from java5.typespecifications.TypeSpecification (0,*) to EnumDefinition (1,1) role enumdefinition;
EdgeClass IsSuperClassOfClass from java5.typespecifications.TypeSpecification (0,1) role subclass to ClassDefinition (1,1) role superclass;
EdgeClass IsSuperClassOfInterface from java5.typespecifications.TypeSpecification (0,*) to InterfaceDefinition (1,1) role interfacedefinition;
EdgeClass IsTypeParameterOfClass from java5.typespecifications.TypeParameterDeclaration (0,*) to ClassDefinition (1,1) role parameterClassdefinition;
EdgeClass IsTypeParameterOfInterface from java5.typespecifications.TypeParameterDeclaration (0,*) to InterfaceDefinition (1,1) role parameterInterfacedefinition;
Package java5.typespecifications;
VertexClass ArrayType: TypeSpecification { dimensions: Integer };
VertexClass BuiltInType: TypeSpecification { type: java5.constants.BuiltInTypes };
VertexClass SimpleArgument: sclkernel.SCLElement;
VertexClass TypeArgument: TypeSpecification;
VertexClass TypeParameterDeclaration: TypeSpecification;
VertexClass TypeParameterUsage: TypeSpecification;
abstract VertexClass TypeSpecification: sclkernel.SCLElement;
VertexClass WildcardArgument: sclkernel.SCLElement;
EdgeClass IsElementTypeOf from TypeSpecification (1,1) to ArrayType (1,1);
EdgeClass IsLowerBoundOfWildCardArgument from TypeSpecification (1,1) to WildcardArgument (1,1);
EdgeClass IsSimpleArgumentOf from SimpleArgument (0,*) to TypeArgument (1,1);
EdgeClass IsTypeArgumentOfTypeSpecification from TypeArgument (0,*) to TypeSpecification (1,1);
EdgeClass IsTypeOfSimpleArgument from TypeSpecification (1,1) to SimpleArgument (1,1);
EdgeClass IsUpperBoundOfTypeParameter from TypeSpecification (0,*) to TypeParameterDeclaration (1,1);
EdgeClass IsWildcardArgumentOf from WildcardArgument (0,*) to TypeArgument (1,1);
EdgeClass TypeSpecificationLinksToWildcardArgument from TypeSpecification (1,1) to WildcardArgument (1,1);
Package rsl.rsldomainelements;
Package rsl.rslkernel;
Package rsl.rslrequirementrepresentations;
Package rsl.rslrequirementrepresentationsentences;
Package rsl.rslrequirements;
Package uml.action;
Package uml.activities;
Package uml.auxiliaryconstructs;
Package uml.classes;
Package uml.commonbehaviors;
Package uml.components;
Package uml.compositestructures;
Package uml.interactions;
Package uml.usecases;
VertexClass Actor: uml.commonbehaviors.basicbehaviors.BehavioredClassifier;
VertexClass Extend: uml.classes.kernel.DirectedRelationship, uml.classes.kernel.NamedElement;
VertexClass ExtensionPoint: uml.classes.kernel.RedefinableElement;
VertexClass Include: uml.classes.kernel.DirectedRelationship, uml.classes.kernel.NamedElement;
VertexClass UseCase: uml.commonbehaviors.basicbehaviors.BehavioredClassifier;
CompositionClass ExtendIsPartOfExtension from Extend (0,*) role extend to UseCase (1,1) role extension aggregate to;
EdgeClass ExtenderLinksToExtendedCase from Extend (0,*) role extender to UseCase (1,1) role extendedCase;
EdgeClass ExtensionLinksToExtensionLocation from Extend (0,*) role extension to ExtensionPoint (1,*) role extensionLocation;
CompositionClass ExtensionPointIsPartOfUseCase from ExtensionPoint (0,*) role extensionPoint to UseCase (1,1) role useCase aggregate to;
CompositionClass IncludeIsPartOfIncludingCase from Include (0,*) role include to UseCase (1,1) role includingCase aggregate to;
EdgeClass IncluderLinksToAddition from Include (0,*) role includer to UseCase (1,1) role addition;
Package rsl.rsldomainelements.actors;
VertexClass Actor: rsl.rsldomainelements.domainelements.ActorOrSystemElement;
VertexClass ActorsPackage: rsl.rsldomainelements.domainelements.DomainElementsPackage;
CompositionClass NestingPackageContainsNestedPackage: rsl.rsldomainelements.domainelements.NestingPackageContainsNestedPackage from ActorsPackage (0,1) role nestingPackage to ActorsPackage (0,*) role nestedPackage aggregate from;
CompositionClass PackageContainsActor: rsl.rsldomainelements.domainelements.PackageContainsDomainElement from ActorsPackage (1,1) role package to Actor (0,*) role actor aggregate from;
Package rsl.rsldomainelements.domainelementrepresentations;
VertexClass DomainElementRepresentation: rsl.rslkernel.elements.ElementRepresentation;
Package rsl.rsldomainelements.domainelements;
abstract VertexClass ActorOrSystemElement: DomainElement;
abstract VertexClass DomainElement: rsl.rslkernel.elements.RepresentableElement;
VertexClass DomainElementRelationship: rsl.rslkernel.elements.RepresentableElementRelationship { directed: Boolean,  sourceMultiplicity: String,  targetMultiplicity: String };
abstract VertexClass DomainElementsPackage: rsl.rslkernel.elements.RepresentableElementsPackage;
VertexClass DomainSpecification: rsl.rslkernel.elements.RepresentableElementsPackage;
CompositionClass DomainElementContainsStatement from DomainElement (1,1) role domainElement to rsl.rsldomainelements.notions.DomainStatement (0,*) role statement aggregate from;
CompositionClass DomainSpecificationContainsDomainElementsPackage: sclkernel.SCLElementsPackageContainsElement from DomainSpecification (0,1) role domainSpecification to DomainElementsPackage (0,*) role domainElementsPackage aggregate from;
CompositionClass ElementContainsName: rsl.rslkernel.elements.RepresentableElementContainsName from ActorOrSystemElement (0,1) role element to rsl.rsldomainelements.phrases.NounPhrase (1,1) role name aggregate from;
CompositionClass ElementContainsRepresentation: rsl.rslkernel.elements.ElementContainsRepresentation from DomainElement (1,1) role element to rsl.rsldomainelements.domainelementrepresentations.DomainElementRepresentation (1,*) role representation aggregate from;
abstract CompositionClass NestingPackageContainsNestedPackage: rsl.rslkernel.elements.NestingPackageContainsNestedPackage from DomainElementsPackage (0,1) role nestingPackage to DomainElementsPackage (0,*) role nestedPackage aggregate from;
abstract CompositionClass PackageContainsDomainElement: rsl.rslkernel.elements.RepresentableElementsPackageContainsElement from DomainElementsPackage (1,1) role package to DomainElement (0,*) role domainElement aggregate from;
CompositionClass SpecificationContainsSystemUnderDevelopment from DomainSpecification (0,1) role specification to rsl.rsldomainelements.systemelements.SystemElement (1,1) role systemUnderDevelopment aggregate from;
EdgeClass ToSourceLinksToTarget: rsl.rslkernel.elements.InRepresentableElementRelationshipLinksToTarget from DomainElementRelationship (0,*) role toSource to DomainElement (1,1) role target;
EdgeClass ToTargetLinksToSource: rsl.rslkernel.elements.OutRepresentableElementRelationshipLinksToSource from DomainElementRelationship (0,*) role toTarget to DomainElement (1,1) role source;
Package rsl.rsldomainelements.notions;
VertexClass DomainStatement: rsl.rslkernel.elements.RepresentableElement;
VertexClass Notion: rsl.rsldomainelements.domainelements.DomainElement;
VertexClass NotionAttribute: rsl.rslkernel.attributes.Attribute;
VertexClass NotionSpecialisation: rsl.rslkernel.elements.RepresentableElementRelationship;
VertexClass NotionsPackage: rsl.rsldomainelements.domainelements.DomainElementsPackage;
EdgeClass GeneralLinksToSource: rsl.rslkernel.elements.OutRepresentableElementRelationshipLinksToSource from NotionSpecialisation (0,*) role general to Notion (1,1) role source;
CompositionClass NestingPackageContainsNestedPackage: rsl.rsldomainelements.domainelements.NestingPackageContainsNestedPackage from NotionsPackage (0,1) role nestingPackage to NotionsPackage (0,*) role nestedPackage aggregate from;
CompositionClass NotionAttributeContainsDescription from NotionAttribute (0,1) role notionAttribute to rsl.rsldomainelements.domainelementrepresentations.DomainElementRepresentation (0,1) role description aggregate from;
CompositionClass NotionContainsAttribute: rsl.rslkernel.attributes.RepresentableElementContainsAttribute from Notion (1,1) role notion to NotionAttribute (0,*) role attribute aggregate from;
CompositionClass NotionContainsName: rsl.rslkernel.elements.RepresentableElementContainsName from Notion (0,1) role notion to rsl.rsldomainelements.phrases.NounPhrase (1,1) role name aggregate from;
CompositionClass PackageContainsNotion: rsl.rsldomainelements.domainelements.PackageContainsDomainElement from NotionsPackage (1,1) role package to Notion (0,*) role notion aggregate from;
EdgeClass SpecialLinksToTarget: rsl.rslkernel.elements.InRepresentableElementRelationshipLinksToTarget from NotionSpecialisation (0,*) role special to Notion (1,1) role target;
CompositionClass StatementContainsName: rsl.rslkernel.elements.RepresentableElementContainsName from DomainStatement (1,1) role statement to rsl.rsldomainelements.phrases.Phrase (1,1) role name aggregate from;
CompositionClass StatementContainsRepresentation: rsl.rslkernel.elements.ElementContainsRepresentation from DomainStatement (1,1) role statement to rsl.rsldomainelements.domainelementrepresentations.DomainElementRepresentation (1,*) role representation aggregate from;
Package rsl.rsldomainelements.phrases;
VertexClass ComplexVerbPhrase: VerbPhrase;
VertexClass DeterminerLink: rsl.rsldomainelements.terms.TermHyperlink;
VertexClass ModifierLink: rsl.rsldomainelements.terms.TermHyperlink;
VertexClass NounLink: rsl.rsldomainelements.terms.TermHyperlink;
VertexClass NounPhrase: Phrase;
VertexClass Phrase: rsl.rslkernel.elements.SentenceOrPhrase, rsl.rslkernel.elements.TermOrPhrase;
VertexClass PhraseHyperlink: rsl.rslkernel.elements.Hyperlink;
VertexClass PhrasePrepositionLink: rsl.rsldomainelements.terms.TermHyperlink;
VertexClass PhraseVerbLink: rsl.rsldomainelements.terms.TermHyperlink;
VertexClass SimpleVerbPhrase: VerbPhrase;
abstract VertexClass VerbPhrase: Phrase;
CompositionClass ComplexVerbPhraseContainsSimpleVerbPhrase from ComplexVerbPhrase (0,1) role complexVerbPhrase to SimpleVerbPhrase (1,1) role simpleVerbPhrase aggregate from;
CompositionClass DeterminerIsPartOfSource: rsl.rslkernel.elements.HyperlinkLinksToSource from DeterminerLink (0,1) role determiner to NounPhrase (1,1) role source aggregate to;
EdgeClass DeterminerLinkLinksToTarget: rsl.rsldomainelements.terms.TermHyperlinkLinksToTarget from DeterminerLink (0,*) role determinerLink to rsl.rsldomainelements.terms.Determiner (1,1) role target;
CompositionClass ModifierIsPartOfSource: rsl.rslkernel.elements.HyperlinkLinksToSource from ModifierLink (0,1) role modifier to NounPhrase (1,1) role source aggregate to;
EdgeClass ModifierLinkLinksToTarget: rsl.rsldomainelements.terms.TermHyperlinkLinksToTarget from ModifierLink (0,*) role modifierLink to rsl.rsldomainelements.terms.Modifier (1,1) role target;
CompositionClass NounIsPartOfSource: rsl.rslkernel.elements.HyperlinkLinksToSource from NounLink (1,1) role noun to NounPhrase (1,1) role source aggregate to;
EdgeClass NounLinkLinksToTarget: rsl.rsldomainelements.terms.TermHyperlinkLinksToTarget from NounLink (0,*) role nounLink to rsl.rsldomainelements.terms.Noun (1,1) role target;
abstract EdgeClass PhraseHyperlinkLinksToTarget: rsl.rslkernel.elements.HyperlinkLinksToTarget from PhraseHyperlink (0,*) to Phrase (1,1) role target;
CompositionClass PrepositionIsPartOfSource: rsl.rslkernel.elements.HyperlinkLinksToSource from PhrasePrepositionLink (0,1) role preposition to VerbPhrase (1,1) role source aggregate to;
EdgeClass PrepositionLinkLinksToTarget: rsl.rsldomainelements.terms.TermHyperlinkLinksToTarget from PhrasePrepositionLink (0,*) role prepositionLink to rsl.rsldomainelements.terms.Preposition (1,1) role target;
CompositionClass VerbIsPartOfSource: rsl.rslkernel.elements.HyperlinkLinksToSource from PhraseVerbLink (1,1) role verb to SimpleVerbPhrase (1,1) role source aggregate to;
EdgeClass VerbLinkLinksToTarget: rsl.rsldomainelements.terms.TermHyperlinkLinksToTarget from PhraseVerbLink (0,*) role verbLink to rsl.rsldomainelements.terms.Verb (1,1) role target;
CompositionClass VerbPhraseContainsObject from VerbPhrase (0,1) role verbPhrase to NounPhrase (0,1) role object aggregate from;
Package rsl.rsldomainelements.systemelements;
VertexClass SystemElement: rsl.rsldomainelements.domainelements.ActorOrSystemElement;
VertexClass SystemElementsPackage: rsl.rsldomainelements.domainelements.DomainElementsPackage;
CompositionClass NestingPackageContainsNestedPackage: rsl.rsldomainelements.domainelements.NestingPackageContainsNestedPackage from SystemElementsPackage (0,1) role nestingPackage to SystemElementsPackage (0,*) role nestedPackage aggregate from;
CompositionClass PackageContainsSystemElement: rsl.rsldomainelements.domainelements.PackageContainsDomainElement from SystemElementsPackage (1,1) role package to SystemElement (0,*) role systemElement aggregate from;
Package rsl.rsldomainelements.terms;
VertexClass Article: Determiner;
VertexClass ConditionalConjunction: Term;
VertexClass Determiner: Term;
VertexClass Lemma: sclkernel.SCLElement;
VertexClass Lexeme: sclkernel.SCLElement { language: String };
VertexClass ModalVerb: Term;
VertexClass Modifier: Term;
VertexClass Noun: Term;
VertexClass Preposition: Term;
VertexClass Quantifier: Determiner;
abstract VertexClass Term: rsl.rslkernel.elements.TermOrPhrase { key: String,  name: String,  synonymUid: Long };
abstract VertexClass TermHyperlink: rsl.rslkernel.elements.Hyperlink { value: String };
VertexClass Terminology: rsl.rslkernel.elements.RepresentableElementsPackage;
VertexClass Verb: Term;
CompositionClass LemmaIsPartOfLexeme from Lemma (1,1) role lemma to Lexeme (1,1) aggregate to;
CompositionClass LexemeIsPartOfTerm from Lexeme (1,*) role lexeme to Term (1,1) aggregate to;
abstract EdgeClass TermHyperlinkLinksToTarget: rsl.rslkernel.elements.HyperlinkLinksToTarget from TermHyperlink (0,*) to Term (1,1) role target;
CompositionClass TerminologyContainsTerm: sclkernel.SCLElementsPackageContainsElement from Terminology (1,1) role terminology to Term (0,*) role term aggregate from;
Package rsl.rsldomainelements.uielements;
VertexClass InputOutputDevice: rsl.rsldomainelements.notions.Notion { deviceId: String };
VertexClass InputOutputType: rsl.rsldomainelements.notions.Notion { description: String };
VertexClass InputUIElement: UIElement { dataValidation: String };
VertexClass OptionUIElement: UIElement { isReSelectable: Boolean };
VertexClass PresentationOrder: sclkernel.SCLElement;
VertexClass SelectionUIElement: UIElement { maximumSelectableOptions: Integer,  sortCriterion: String,  sortOrder: String };
VertexClass TriggerUIElement: UIElement { executionTime: Integer,  isStatelessTrigger: Boolean };
VertexClass UIContainer: UIElement;
VertexClass UIElement: rsl.rsldomainelements.notions.Notion { hasAutoContent: Boolean,  isMandatory: Boolean };
VertexClass UIElementRepresentation: rsl.rslkernel.elements.ElementRepresentation;
VertexClass UIPresentationUnit: UIContainer;
EdgeClass InputOutputDeviceLinksToType from InputOutputDevice (1,*) to InputOutputType (0,*) role type;
CompositionClass SelectionUIElementContainsOption from SelectionUIElement (0,*) to OptionUIElement (0,*) role option aggregate from;
CompositionClass UIContainerContainsElement from UIContainer (1,1) to UIElement (0,*) role element aggregate from;
EdgeClass UIContainerLinksToOrder from UIContainer (0,1) to PresentationOrder (0,*) role order;
CompositionClass UIElementContainsRepresentation: rsl.rslkernel.elements.ElementContainsRepresentation from UIElement (1,1) to UIElementRepresentation (1,*) role representation aggregate from;
EdgeClass UIElementLinksToDevice from UIElement (1,*) to InputOutputDevice (0,*) role device;
EdgeClass UIElementLinksToSpatialOrder from UIElement (0,*) to PresentationOrder (0,*) role spatialOrder;
EdgeClass UIElementLinksToTemporalOrder from UIElement (0,*) to PresentationOrder (0,*) role temporalOrder;
Package rsl.rslkernel.attributes;
VertexClass Attribute: sclkernel.SCLElement { data: String };
VertexClass AttributeDefinition: sclkernel.SCLElement { name: String,  type: String };
VertexClass AttributeSet: sclkernel.SCLElement;
EdgeClass AttributeLinksToAttributeDefinition from Attribute (0,*) to AttributeDefinition (1,1);
CompositionClass AttributeSetContainsDefinition from AttributeSet (0,*) to AttributeDefinition (0,*) role definition aggregate from;
CompositionClass RepresentableElementContainsAttribute from rsl.rslkernel.elements.RepresentableElement (1,1) to Attribute (0,*) role attribute aggregate from;
EdgeClass RepresentableElementLinksToAttributeSet from rsl.rslkernel.elements.RepresentableElement (0,*) to AttributeSet (1,*) role attributeSet;
Package rsl.rslkernel.elements;
abstract VertexClass ElementRepresentation: sclkernel.SCLElement;
abstract VertexClass Hyperlink: sclkernel.SCLRelationship;
abstract VertexClass HyperlinkedSentence: SentenceOrPhrase { sentenceText: String };
abstract VertexClass RepresentableElement: sclkernel.SCLElement;
abstract VertexClass RepresentableElementRelationship: sclkernel.SCLRelationship;
abstract VertexClass RepresentableElementsPackage: sclkernel.SCLElementsPackage;
abstract VertexClass SentenceOrPhrase: sclkernel.SCLElement;
abstract VertexClass TermOrPhrase: sclkernel.SCLElement;
abstract CompositionClass ElementContainsRepresentation from RepresentableElement (1,1) role element to ElementRepresentation (1,*) role representation aggregate from;
abstract CompositionClass ElementRepresentationContainsSentence from ElementRepresentation (0,1) to HyperlinkedSentence (0,*) role sentence aggregate from;
abstract EdgeClass HyperlinkLinksToSource: sclkernel.SCLRelationshipLinksToSource from Hyperlink (0,*) role hyperlink to SentenceOrPhrase (1,1) role source;
abstract EdgeClass HyperlinkLinksToTarget: sclkernel.SCLRelationshipLinksToTarget from Hyperlink (0,*) to TermOrPhrase (1,1) role target;
abstract EdgeClass InRepresentableElementRelationshipLinksToTarget: sclkernel.SCLRelationshipLinksToTarget from RepresentableElementRelationship (0,*) role inRepresentableElementRelationship to RepresentableElement (1,1) role target;
abstract CompositionClass NestingPackageContainsNestedPackage: sclkernel.SCLElementsPackageContainsNestedPackage from RepresentableElementsPackage (0,1) role nestingPackage to RepresentableElementsPackage (0,*) role nestedPackage aggregate from;
abstract EdgeClass OutRepresentableElementRelationshipLinksToSource: sclkernel.SCLRelationshipLinksToSource from RepresentableElementRelationship (0,*) role outRepresentableElementRelationship to RepresentableElement (1,1) role source;
abstract CompositionClass RepresentableElementContainsName from RepresentableElement (0,1) role representableElement to sclkernel.SCLElement (1,1) role name aggregate from;
abstract CompositionClass RepresentableElementsPackageContainsElement: sclkernel.SCLElementsPackageContainsElement from RepresentableElementsPackage (1,1) to RepresentableElement (0,*) role element aggregate from;
abstract EdgeClass ScenarioMessageLinksToMessageText from rsl.rslrequirementrepresentationsentences.interactionsentenceconstructs.ScenarioMessage (0,*) to SentenceOrPhrase (1,1) role messageText;
CompositionClass SentenceListContainsSentence: ElementRepresentationContainsSentence from rsl.rslrequirementrepresentations.descriptiverequirementrepresentations.SentenceList (0,1) role sentenceList to HyperlinkedSentence (1,*) role sentence aggregate from;
abstract EdgeClass TermHyperlinkLinksToSource: HyperlinkLinksToSource from rsl.rsldomainelements.terms.TermHyperlink (0,*) to SentenceOrPhrase (1,1) role source;
Package rsl.rslrequirementrepresentations.activityrepresentations;
VertexClass ActivityScenario: rsl.rslrequirementrepresentations.requirementrepresentations.ModelBasedRequirementRepresentation;
CompositionClass ScenarioContainsEdge from ActivityScenario (1,1) role scenario to rsl.rslrequirementrepresentationsentences.activityrepresentation.RSLActivityEdge (0,*) role edge aggregate from;
CompositionClass ScenarioContainsNode from ActivityScenario (1,1) role scenario to rsl.rslrequirementrepresentationsentences.activityrepresentation.RSLActivityNode (0,*) role node aggregate from;
Package rsl.rslrequirementrepresentations.descriptiverequirementrepresentations;
VertexClass ConstrainedLanguageScenario: rsl.rslrequirementrepresentations.requirementrepresentations.DescriptiveRequirementRepresentation;
VertexClass SentenceList: rsl.rslrequirementrepresentations.requirementrepresentations.DescriptiveRequirementRepresentation;
CompositionClass ConstrainedLanguageScenarioContainsStoryboard from ConstrainedLanguageScenario (1,1) to rsl.rslrequirementrepresentations.uibehaviourrepresentations.UIStoryboard (0,1) role storyboard aggregate from;
CompositionClass ScenarioContainsScenarioStep from ConstrainedLanguageScenario (0,1) role scenario to rsl.rslrequirementrepresentationsentences.constrainedlanguagesentences.ConstrainedLanguageSentence (0,*) role scenarioStep aggregate from;
CompositionClass TextualSentencesIsPartOfSentenceList from rsl.rslrequirementrepresentationsentences.representationsentences.NaturalLanguageHypertextSentence (1,*) role textualSentences to SentenceList (1,1) aggregate to;
Package rsl.rslrequirementrepresentations.interactionrepresentations;
VertexClass InteractionScenario: rsl.rslrequirementrepresentations.requirementrepresentations.ModelBasedRequirementRepresentation;
CompositionClass InteractionScenarioContainsLifeline from InteractionScenario (0,*) to rsl.rslrequirementrepresentationsentences.interactionsentenceconstructs.InteractionRepresentationLifeline (1,1) role lifeline aggregate from;
CompositionClass InteractionScenarioContainsMessage from InteractionScenario (1,1) to rsl.rslrequirementrepresentationsentences.interactionsentenceconstructs.ScenarioMessage (0,*) role message aggregate from;
Package rsl.rslrequirementrepresentations.requirementrepresentations;
abstract VertexClass DescriptiveRequirementRepresentation: RequirementRepresentation;
abstract VertexClass ModelBasedRequirementRepresentation: RequirementRepresentation;
abstract VertexClass RequirementRepresentation: rsl.rslkernel.elements.ElementRepresentation { name: String };
Package rsl.rslrequirementrepresentations.uibehaviourrepresentations;
VertexClass UIScene: sclkernel.SCLElement { sceneDescription: String,  sceneNumber: Integer };
VertexClass UIStoryboard: sclkernel.SCLElement;
VertexClass UserAction: sclkernel.SCLRelationship;
CompositionClass UISceneContainsScreenshot from UIScene (0,1) to rsl.rsldomainelements.uielements.UIPresentationUnit (0,*) role screenshot aggregate from;
CompositionClass UISceneIsPartOfUIStoryboard from UIScene (1,*) to UIStoryboard (1,1) aggregate to;
EdgeClass UISceneLinksToSVOSentence from UIScene (0,1) to rsl.rslrequirementrepresentationsentences.svosentences.SVOSentence (1,1);
EdgeClass UserActionLinksToPredecessor from UserAction (1,1) to UIScene (1,1) role predecessor;
EdgeClass UserActionLinksToSVOSentence from UserAction (0,1) to rsl.rslrequirementrepresentationsentences.svosentences.SVOSentence (1,1);
EdgeClass UserActionLinksToSource: sclkernel.SCLRelationshipLinksToSource from UserAction (0,*) to rsl.rsldomainelements.uielements.UIElement (1,1) role source;
EdgeClass UserActionLinksToSuccessor from UserAction (1,1) to UIScene (1,1) role successor;
EdgeClass UserActionLinksToTarget: sclkernel.SCLRelationshipLinksToTarget from UserAction (0,*) to rsl.rsldomainelements.uielements.UIElement (1,1) role target;
Package rsl.rslrequirementrepresentationsentences.activityrepresentation;
VertexClass RSLActivityEdge: sclkernel.SCLElement;
VertexClass RSLActivityNode: sclkernel.SCLElement;
EdgeClass IncomingControlFlowLinksToTargetNode from RSLActivityEdge (0,*) role incomingControlFlow to RSLActivityNode (1,1) role targetNode;
EdgeClass OutgoingControlFlowLinksToSourceNode from RSLActivityEdge (0,*) role outgoingControlFlow to RSLActivityNode (1,1) role sourceNode;
Package rsl.rslrequirementrepresentationsentences.constrainedlanguagesentences;
abstract VertexClass ConstrainedLanguageSentence: rsl.rslkernel.elements.HyperlinkedSentence;
VertexClass RejoinSentence: ConstrainedLanguageSentence;
CompositionClass EdgeContainsRejoin from rsl.rslrequirementrepresentationsentences.activityrepresentation.RSLActivityEdge (0,1) role edge to RejoinSentence (0,1) role rejoin aggregate from;
CompositionClass NodeContainsContainedSentence from rsl.rslrequirementrepresentationsentences.activityrepresentation.RSLActivityNode (0,1) role node to ConstrainedLanguageSentence (1,1) role containedSentence aggregate from;
CompositionClass RejoinMessageContainsRejoinSentence from rsl.rslrequirementrepresentationsentences.interactionsentenceconstructs.RejoinMessage (0,1) to RejoinSentence (1,1) role rejoinSentence aggregate from;
EdgeClass RejoinedSentenceLinksToRejoin from ConstrainedLanguageSentence (1,1) role rejoinedSentence to RejoinSentence (0,*) role rejoin;
Package rsl.rslrequirementrepresentationsentences.controlsentences;
EnumDomain InclusionType ( INSERT, REQUEST );
VertexClass ConditionSentence: rsl.rslrequirementrepresentationsentences.constrainedlanguagesentences.ConstrainedLanguageSentence;
abstract VertexClass ControlSentence: rsl.rslrequirementrepresentationsentences.constrainedlanguagesentences.ConstrainedLanguageSentence;
VertexClass InvocationSentence: ControlSentence { inclusionType: InclusionType };
VertexClass PostconditionSentence: ControlSentence { isSuccess: Boolean };
VertexClass PreconditionSentence: ControlSentence { inclusionType: InclusionType };
CompositionClass EdgeContainsCondition from rsl.rslrequirementrepresentationsentences.activityrepresentation.RSLActivityEdge (0,1) role edge to ConditionSentence (0,1) role condition aggregate from;
CompositionClass InvokeMessageContainsMessageText: rsl.rslkernel.elements.ScenarioMessageLinksToMessageText from rsl.rslrequirementrepresentationsentences.interactionsentenceconstructs.InvokeMessage (0,1) to InvocationSentence (1,1) role messageText aggregate from;
CompositionClass PostconditionMessageContainsMessageText: rsl.rslkernel.elements.ScenarioMessageLinksToMessageText from rsl.rslrequirementrepresentationsentences.interactionsentenceconstructs.PostconditionMessage (0,1) to PostconditionSentence (1,1) role messageText aggregate from;
CompositionClass PreconditionMessageContainsMessageText: rsl.rslkernel.elements.ScenarioMessageLinksToMessageText from rsl.rslrequirementrepresentationsentences.interactionsentenceconstructs.PreconditionMessage (0,1) to PreconditionSentence (1,1) role messageText aggregate from;
Package rsl.rslrequirementrepresentationsentences.interactionsentenceconstructs;
VertexClass ActorLifeline: NounPhraseLifeline;
VertexClass ActorMessageEnd: ScenarioMessageEnd;
abstract VertexClass InteractionRepresentationLifeline: rsl.rslkernel.elements.ElementRepresentation;
VertexClass InvokeLifeline: InteractionRepresentationLifeline;
VertexClass InvokeMessage: ScenarioMessage;
VertexClass InvokeMessageEnd: ScenarioMessageEnd;
abstract VertexClass NounPhraseLifeline: rsl.rsldomainelements.domainelementrepresentations.DomainElementRepresentation, InteractionRepresentationLifeline;
VertexClass PostconditionMessage: ScenarioMessage;
VertexClass PreconditionMessage: ScenarioMessage;
VertexClass PredicateMessage: ScenarioMessage;
VertexClass RejoinMessage: ScenarioMessage;
abstract VertexClass ScenarioMessage: sclkernel.SCLElement;
VertexClass ScenarioMessageEnd;
VertexClass SystemElementLifeline: NounPhraseLifeline;
VertexClass SystemElementMessageEnd: ScenarioMessageEnd;
CompositionClass ActorContainsLifelineRepresentation from rsl.rsldomainelements.actors.Actor (1,1) to ActorLifeline (0,*) role lifelineRepresentation aggregate from;
CompositionClass ActorMessageEndIsPartOfCovered from ActorMessageEnd (0,*) role actorMessageEnd to ActorLifeline (1,1) role covered aggregate to;
CompositionClass CoveredContainsSystemElementMessageEnd from SystemElementLifeline (1,1) role covered to SystemElementMessageEnd (0,*) role systemElementMessageEnd aggregate from;
CompositionClass InvokeMessageEndIsPartOfCovered from InvokeMessageEnd (1,1) role invokeMessageEnd to InvokeLifeline (1,1) role covered aggregate to;
EdgeClass InvokeMessageLinksToReceiveEvent from InvokeMessage (1,1) to InvokeMessageEnd (1,1) role receiveEvent;
EdgeClass InvokeMessageLinksToSendEvent from InvokeMessage (0,1) to SystemElementMessageEnd (1,1) role sendEvent;
CompositionClass NounPhraseLifelineContainsName from NounPhraseLifeline (1,1) to rsl.rsldomainelements.phrases.NounPhrase (0,1) role name aggregate from;
EdgeClass PostconditionMessageLinksToSendEvent from PostconditionMessage (0,1) to ActorMessageEnd (1,1) role sendEvent;
EdgeClass PreconditionMessageLinksToRecieveEvent from PreconditionMessage (0,1) to ActorMessageEnd (1,1) role recieveEvent;
EdgeClass PredicateMessageLinksToRecieveEventActor from PredicateMessage (0,1) to ActorMessageEnd (0,1) role recieveEventActor;
EdgeClass PredicateMessageLinksToRecieveEventSystem from PredicateMessage (0,1) to SystemElementMessageEnd (0,1) role recieveEventSystem;
EdgeClass PredicateMessageLinksToSendEventActor from PredicateMessage (0,1) to ActorMessageEnd (0,1) role sendEventActor;
EdgeClass PredicateMessageLinksToSendEventSystem from PredicateMessage (0,1) to SystemElementMessageEnd (0,1) role sendEventSystem;
EdgeClass RejoinMessageLinksToRecieveEventActor from RejoinMessage (0,*) to ActorMessageEnd (0,1) role recieveEventActor;
EdgeClass RejoinMessageLinksToRecieveEventSystem from RejoinMessage (0,*) to SystemElementMessageEnd (0,1) role recieveEventSystem;
EdgeClass RejoinMessageLinksToSendEventActor from RejoinMessage (0,*) to ActorMessageEnd (0,1) role sendEventActor;
EdgeClass RejoinMessageLinksToSendEventSystem from RejoinMessage (0,*) to SystemElementMessageEnd (0,1) role sendEventSystem;
EdgeClass SourceLinksToMessageText: rsl.rslkernel.elements.ScenarioMessageLinksToMessageText from PredicateMessage (0,*) role source to rsl.rsldomainelements.phrases.VerbPhrase (1,1) role messageText;
CompositionClass SystemElementContainsLifelineRepresentation from rsl.rsldomainelements.systemelements.SystemElement (1,1) to SystemElementLifeline (0,*) role lifelineRepresentation aggregate from;
Package rsl.rslrequirementrepresentationsentences.representationsentences;
VertexClass NaturalLanguageHypertextSentence: rsl.rslkernel.elements.HyperlinkedSentence;
CompositionClass RepresentationContainsSentence: rsl.rslkernel.elements.ElementRepresentationContainsSentence from rsl.rsldomainelements.domainelementrepresentations.DomainElementRepresentation (0,1) role representation to NaturalLanguageHypertextSentence (0,*) role sentence aggregate from;
Package rsl.rslrequirementrepresentationsentences.svosentences;
VertexClass ConditionalConjunctionLink: rsl.rsldomainelements.terms.TermHyperlink;
VertexClass ConditionalSentence: rsl.rslrequirementrepresentationsentences.constrainedlanguagesentences.ConstrainedLanguageSentence;
VertexClass ModalSVOSentence: SVOSentence;
VertexClass ModalVerbLink: rsl.rsldomainelements.terms.TermHyperlink;
VertexClass Predicate: rsl.rsldomainelements.phrases.PhraseHyperlink;
VertexClass SVOSentence: rsl.rslrequirementrepresentationsentences.constrainedlanguagesentences.ConstrainedLanguageSentence;
VertexClass Subject: rsl.rsldomainelements.phrases.PhraseHyperlink;
CompositionClass ConditionalConjunctionIsPartOfSource: rsl.rslkernel.elements.HyperlinkLinksToSource from ConditionalConjunctionLink (0,1) role conditionalConjunction to ConditionalSentence (1,1) role source aggregate to;
CompositionClass ConditionalSentenceContainsConditionalClause from ConditionalSentence (1,1) role conditionalSentence to SVOSentence (0,1) role conditionalClause aggregate from;
CompositionClass ConjunctionLinkContainsTarget: rsl.rsldomainelements.terms.TermHyperlinkLinksToTarget from ConditionalConjunctionLink (0,*) role conjunctionLink to rsl.rsldomainelements.terms.ConditionalConjunction (1,1) role target aggregate from;
EdgeClass LinkingPredicateLinksToDomainStatement from Predicate (0,*) role linkingPredicate to rsl.rsldomainelements.notions.DomainStatement (0,1) role domainStatement;
EdgeClass LinkingSubjectLinksToDomainElement from Subject (0,*) role linkingSubject to rsl.rsldomainelements.domainelements.DomainElement (0,1) role domainElement;
CompositionClass ModalVerbIsPartOfSource: rsl.rslkernel.elements.HyperlinkLinksToSource from ModalVerbLink (1,1) role modalVerb to ModalSVOSentence (1,1) role source aggregate to;
EdgeClass ModalVerbLinkLinksToTarget: rsl.rsldomainelements.terms.TermHyperlinkLinksToTarget from ModalVerbLink (0,*) role modalVerbLink to rsl.rsldomainelements.terms.ModalVerb (1,1) role target;
EdgeClass NodeLinksToPartition from rsl.rslrequirementrepresentationsentences.activityrepresentation.RSLActivityNode (0,1) role node to Subject (0,1) role partition;
CompositionClass OwnedSentenceContainsMainClause from ConditionalSentence (0,1) role ownedSentence to ModalSVOSentence (1,1) role mainClause aggregate from;
AggregationClass PredicateContainsTarget: rsl.rsldomainelements.phrases.PhraseHyperlinkLinksToTarget from Predicate (0,*) role predicate to rsl.rsldomainelements.phrases.VerbPhrase (1,1) role target aggregate from;
CompositionClass PredicateIsPartOfSource: rsl.rslkernel.elements.HyperlinkLinksToSource from Predicate (1,1) role predicate to SVOSentence (1,1) role source aggregate to;
EdgeClass SentenceLinksToRecipient from SVOSentence (1,1) role sentence to rsl.rsldomainelements.domainelements.ActorOrSystemElement (0,1) role recipient;
AggregationClass SubjectContainsTarget: rsl.rsldomainelements.phrases.PhraseHyperlinkLinksToTarget from Subject (0,*) role subject to rsl.rsldomainelements.phrases.NounPhrase (1,1) role target aggregate from;
CompositionClass SubjectIsPartOfSource: rsl.rslkernel.elements.HyperlinkLinksToSource from Subject (1,1) role subject to SVOSentence (1,1) role source aggregate to;
Package rsl.rslrequirements.requirementrelationships;
VertexClass ConflictsWith: NonInvocationRelationship, sclkernel.TraceabilityLink;
VertexClass Constrains: NonInvocationRelationship, sclkernel.TraceabilityLink;
VertexClass DependsOn: NonInvocationRelationship, sclkernel.TraceabilityLink;
VertexClass DerivesFrom: NonInvocationRelationship, sclkernel.TraceabilityLink;
VertexClass Elaborates: NonInvocationRelationship, sclkernel.TraceabilityLink;
VertexClass Fulfils: NonInvocationRelationship, sclkernel.TraceabilityLink;
VertexClass IsSimilarTo: NonInvocationRelationship, sclkernel.TraceabilityLink;
VertexClass MakesPossible: NonInvocationRelationship, sclkernel.TraceabilityLink;
abstract VertexClass NonInvocationRelationship: RequirementRelationship;
VertexClass Operationalizes: NonInvocationRelationship, sclkernel.TraceabilityLink;
abstract VertexClass RequirementRelationship: rsl.rslkernel.elements.RepresentableElementRelationship;
VertexClass RequirementVocabularyRelationship: rsl.rslkernel.elements.RepresentableElementRelationship;
EdgeClass VocabularyLinksToTarget: rsl.rslkernel.elements.InRepresentableElementRelationshipLinksToTarget from RequirementVocabularyRelationship (0,*) role vocabulary to rsl.rsldomainelements.notions.Notion (1,1) role target;
Package rsl.rslrequirements.requirementsspecifications;
VertexClass ConstraintOnProcess: Requirement;
VertexClass ConstraintOnSystem: Requirement;
VertexClass FunctionalRequirementOnComposite: Requirement;
VertexClass FunctionalRequirementOnSystem: Requirement;
VertexClass RSLUseCase: Requirement;
VertexClass Requirement: rsl.rslkernel.elements.RepresentableElement { requirementId: String };
VertexClass RequirementsPackage: rsl.rslkernel.elements.RepresentableElementsPackage;
VertexClass RequirementsSpecification: sclkernel.SoftwareArtifact;
EdgeClass FromLinksToSource: rsl.rslkernel.elements.OutRepresentableElementRelationshipLinksToSource, rsl.rslkernel.elements.InRepresentableElementRelationshipLinksToTarget from rsl.rslrequirements.requirementrelationships.NonInvocationRelationship (0,*) role 'from to Requirement (1,1) role source;
EdgeClass InvokeLinksToSource: rsl.rslkernel.elements.OutRepresentableElementRelationshipLinksToSource from rsl.rslrequirements.usecaserelationships.InvocationRelationship (0,*) role invoke to RSLUseCase (1,1) role source;
EdgeClass InvokedLinksToTarget: rsl.rslkernel.elements.InRepresentableElementRelationshipLinksToTarget from rsl.rslrequirements.usecaserelationships.InvocationRelationship (0,*) role invoked to RSLUseCase (1,1) role target;
CompositionClass NestingPackageContainsNestedPackage: rsl.rslkernel.elements.NestingPackageContainsNestedPackage from RequirementsPackage (0,1) role nestingPackage to RequirementsPackage (0,*) role nestedPackage aggregate from;
CompositionClass PackageContainsRequirement: rsl.rslkernel.elements.RepresentableElementsPackageContainsElement from RequirementsPackage (1,1) role package to Requirement (0,*) role requirement aggregate from;
EdgeClass ParticipationLinksToTarget: rsl.rslkernel.elements.InRepresentableElementRelationshipLinksToTarget from rsl.rslrequirements.usecaserelationships.Participation (0,*) role participation to RSLUseCase (1,1) role target;
CompositionClass RSLUseCaseContainsLifelineRepresentation: rsl.rslkernel.elements.ElementContainsRepresentation from RSLUseCase (1,1) to rsl.rslrequirementrepresentationsentences.interactionsentenceconstructs.InvokeLifeline (1,*) role lifelineRepresentation aggregate from;
CompositionClass RequirementContainsInteraction: RequirementContainsRepresentation from RSLUseCase (1,1) role requirement to rsl.rslrequirementrepresentations.interactionrepresentations.InteractionScenario (1,*) role interaction aggregate from;
CompositionClass RequirementContainsName: rsl.rslkernel.elements.RepresentableElementContainsName from Requirement (0,1) role requirement to rsl.rslrequirementrepresentationsentences.representationsentences.NaturalLanguageHypertextSentence (1,1) role name aggregate from;
CompositionClass RequirementContainsRepresentation: rsl.rslkernel.elements.ElementContainsRepresentation from Requirement (1,1) role requirement to rsl.rslrequirementrepresentations.requirementrepresentations.RequirementRepresentation (1,*) role representation aggregate from;
CompositionClass RequirementsSpecificationContainsRequirementsPackage: sclkernel.SCLElementsPackageContainsElement from RequirementsSpecification (0,1) role requirementsSpecification to RequirementsPackage (0,*) role requirementsPackage aggregate from;
EdgeClass RequirementsSpecificationLinksToDomainSpecification from RequirementsSpecification (1,1) role requirementsSpecification to rsl.rsldomainelements.domainelements.DomainSpecification (1,1) role domainSpecification;
CompositionClass RslUseCaseContainsActivity: RequirementContainsRepresentation from RSLUseCase (1,1) role rslUseCase to rsl.rslrequirementrepresentations.activityrepresentations.ActivityScenario (1,1) role activity aggregate from;
EdgeClass ToLinksToTarget: rsl.rslkernel.elements.InRepresentableElementRelationshipLinksToTarget from rsl.rslrequirements.requirementrelationships.NonInvocationRelationship (0,*) role 'to to Requirement (1,1) role target;
EdgeClass UIElementLinksToTriggeredUseCase from rsl.rsldomainelements.uielements.UIElement (0,*) to RSLUseCase (0,1) role triggeredUseCase;
EdgeClass UsageLinksToTarget: rsl.rslkernel.elements.InRepresentableElementRelationshipLinksToTarget from rsl.rslrequirements.usecaserelationships.Usage (1,1) role usage to RSLUseCase (1,1) role target;
EdgeClass VocabularyLinksToSource: rsl.rslkernel.elements.OutRepresentableElementRelationshipLinksToSource from rsl.rslrequirements.requirementrelationships.RequirementVocabularyRelationship (0,*) role vocabulary to Requirement (1,1) role source;
Package rsl.rslrequirements.usecaserelationships;
VertexClass InvocationRelationship: rsl.rslrequirements.requirementrelationships.RequirementRelationship;
VertexClass Participation: rsl.rslkernel.elements.RepresentableElementRelationship;
VertexClass Usage: rsl.rslkernel.elements.RepresentableElementRelationship;
EdgeClass InvocationLinksToInvokeDescription from InvocationRelationship (1,1) role invocation to rsl.rslrequirementrepresentationsentences.controlsentences.InvocationSentence (1,1) role invokeDescription;
EdgeClass SourceParticipationLinksToSource: rsl.rslkernel.elements.OutRepresentableElementRelationshipLinksToSource from Participation (1,1) role sourceParticipation to rsl.rsldomainelements.actors.Actor (1,1) role source;
EdgeClass UsageLinksToSource: rsl.rslkernel.elements.OutRepresentableElementRelationshipLinksToSource from Usage (0,*) role usage to rsl.rsldomainelements.actors.Actor (1,1) role source;
Package uml.action.basicactions;
abstract VertexClass Action: uml.activities.basicactivities.ActivityNode;
abstract VertexClass CallAction: InvocationAction { isSynchronous: Boolean };
VertexClass CallBehaviorAction: CallAction;
abstract VertexClass InvocationAction: Action;
VertexClass OpaqueAction: Action { body: String,  language: String };
EdgeClass BehaviorLinksToCallAction from uml.commonbehaviors.basicbehaviors.Behavior (1,1) role behavior to CallBehaviorAction (0,*) role callAction;
Package uml.activities.basicactivities;
VertexClass Activity: uml.commonbehaviors.basicbehaviors.Behavior { isReadOnly: Boolean };
abstract VertexClass ActivityEdge: uml.classes.kernel.RedefinableElement;
VertexClass ActivityFinalNode: ControlNode;
abstract VertexClass ActivityGroup: uml.classes.kernel.Element;
abstract VertexClass ActivityNode: uml.classes.kernel.RedefinableElement;
VertexClass ControlFlow: ActivityEdge;
abstract VertexClass ControlNode: ActivityNode;
VertexClass InitialNode: ControlNode;
CompositionClass ActivityContainsNode from Activity (0,1) role activity to ActivityNode (0,*) role node aggregate from;
CompositionClass ActivityEdgeContainsGuard from ActivityEdge (0,1) role activityEdge to uml.classes.kernel.ValueSpecification (1,1) role guard aggregate from;
CompositionClass EdgeIsPartOfActivity from ActivityEdge (0,*) role edge to Activity (0,1) role activity aggregate to;
EdgeClass EdgeLinksToInPartition from ActivityEdge (0,*) role edge to uml.activities.intermediateactivities.ActivityPartition (0,*) role inPartition;
CompositionClass GroupIsPartOfInActivity from ActivityGroup (0,*) role group to Activity (0,1) role inActivity aggregate to;
EdgeClass InPartitionLinksToNode from uml.activities.intermediateactivities.ActivityPartition (0,*) role inPartition to ActivityNode (0,*) role node;
EdgeClass SourceLinksToOutgoing from ActivityNode (1,1) role source to ActivityEdge (0,*) role outgoing;
EdgeClass TargetLinksToIncoming from ActivityNode (1,1) role target to ActivityEdge (0,*) role incoming;
Package uml.activities.intermediateactivities;
VertexClass ActivityPartition: uml.activities.basicactivities.ActivityGroup, uml.classes.kernel.NamedElement { isDimension: Boolean,  isExternal: Boolean };
EdgeClass RepresentedByLinksToRepresents from ActivityPartition (0,*) role representedBy to uml.classes.kernel.Element (0,1) role represents;
CompositionClass SubpartitionIsPartOfSuperPartition from ActivityPartition (0,*) role subpartition to ActivityPartition (0,1) role superPartition aggregate to;
Package uml.auxiliaryconstructs.models;
VertexClass Model: uml.classes.kernel.Package { viewpoint: String };
Package uml.classes.dependencies;
VertexClass Abstraction: Dependency;
VertexClass Dependency: uml.classes.kernel.PackagableElement, uml.classes.kernel.DirectedRelationship;
VertexClass Realization: Abstraction;
VertexClass Usage: Dependency;
EdgeClass ClientDependencyLinksToClient from Dependency (0,*) role clientDependency to uml.classes.kernel.NamedElement (1,*) role client;
EdgeClass SupplierDependencyLinksToSupplier from Dependency (0,*) role supplierDependency to uml.classes.kernel.NamedElement (1,*) role supplier;
Package uml.classes.interfaces;
VertexClass Interface: uml.classes.kernel.Classifier;
VertexClass InterfaceRealization: uml.classes.dependencies.Realization;
EdgeClass BaseInterfaceLinksToRedefinedInterface from Interface (0,*) role baseInterface to Interface (0,*) role redefinedInterface;
EdgeClass ContractLinksToInterfaceRealization from Interface (1,1) role contract to InterfaceRealization (0,*) role interfaceRealization;
CompositionClass InterfaceRealizationIsPartOfImplementingClassifier from InterfaceRealization (0,*) role interfaceRealization to uml.commonbehaviors.basicbehaviors.BehavioredClassifier (1,1) role implementingClassifier aggregate to;
CompositionClass OwnedOperationIsPartOfInterface from uml.classes.kernel.Operation (0,*) role ownedOperation to Interface (0,1) role interface aggregate to;
CompositionClass OwningInterfaceContainsOwnedAttribute from Interface (0,1) role owningInterface to uml.classes.kernel.Property (0,*) role ownedAttribute aggregate from;
Package uml.classes.kernel;
EnumDomain AggregationKind ( NONE, SHARED, COMPOSITE );
EnumDomain ParameterDirectionKind ( IN, INOUT, OUT, RETURN );
EnumDomain VisibilityKind ( PUBLIC, PRIVATE, PROTECTED, PACKAGE );
VertexClass Association: Classifier, Relationship { isDerived: Boolean };
abstract VertexClass BehavioralFeature: Feature, Namespace;
VertexClass Class: uml.compositestructures.ports.EncapsulatedClassifier, Classifier, uml.commonbehaviors.basicbehaviors.BehavioredClassifier;
abstract VertexClass Classifier: Namespace, Type, RedefinableElement { isAbstract: Boolean };
VertexClass Comment: Element { body: String };
VertexClass Constraint: PackagableElement;
VertexClass DataType: Classifier;
abstract VertexClass DirectedRelationship: Relationship;
abstract VertexClass Element: sclkernel.SCLElement;
VertexClass ElementImport: DirectedRelationship { alias: String,  visibility: VisibilityKind };
VertexClass Enumeration: DataType;
VertexClass EnumerationLiteral: InstanceSpecification;
VertexClass Expression: ValueSpecification { symbol: String };
abstract VertexClass Feature: RedefinableElement { isStatic: Boolean };
VertexClass Generalization: DirectedRelationship { isSubstitutable: Boolean };
VertexClass InstanceSpecification: PackagableElement;
VertexClass InstanceValue: ValueSpecification;
VertexClass LiteralBoolean: LiteralSpecification { value: Boolean };
VertexClass LiteralInteger: LiteralSpecification { value: Integer };
VertexClass LiteralNull: LiteralSpecification;
abstract VertexClass LiteralSpecification: ValueSpecification;
VertexClass LiteralString: LiteralSpecification { value: String };
VertexClass LiteralUnlimitedNatural: LiteralSpecification { value: String };
abstract VertexClass MultiplicityElement: Element { isOrdered: Boolean,  isUnique: Boolean };
abstract VertexClass NamedElement: Element { name: String,  visibility: VisibilityKind };
abstract VertexClass Namespace: NamedElement;
VertexClass OpaqueExpression: ValueSpecification { body: String,  language: String };
VertexClass Operation: BehavioralFeature { isQuery: Boolean };
abstract VertexClass PackagableElement: NamedElement;
VertexClass 'Package: PackagableElement, Namespace;
VertexClass PackageImport: DirectedRelationship { visibility: VisibilityKind };
VertexClass Parameter: TypedElement, MultiplicityElement { direction: ParameterDirectionKind };
VertexClass PrimitiveType: DataType;
VertexClass Property: StructuralFeature, uml.compositestructures.internalstructures.ConnectableElement { aggregation: AggregationKind,  isDerived: Boolean,  isDerivedUnion: Boolean };
abstract VertexClass RedefinableElement: NamedElement { isLeaf: Boolean };
abstract VertexClass Relationship: Element;
VertexClass Stereotype: Element { keywords: String };
abstract VertexClass StructuralFeature: TypedElement, Feature, MultiplicityElement { isReadOnly: Boolean };
abstract VertexClass Type: PackagableElement;
abstract VertexClass TypedElement: NamedElement;
abstract VertexClass ValueSpecification: PackagableElement, TypedElement;
EdgeClass AnnotationLinksToAnnotatedElement from Comment (0,*) role annotation to Element (0,*) role annotatedElement;
EdgeClass BaseClassifierLinksToRedefinedClassifier from Classifier (0,*) role baseClassifier to Classifier (0,*) role redefinedClassifier;
EdgeClass BaseOperationLinksToRedefinedOperation from Operation (0,*) role baseOperation to Operation (0,*) role redefinedOperation;
EdgeClass BasePropertyLinksToRedefinedProperty from Property (0,*) role baseProperty to Property (0,*) role redefinedProperty;
CompositionClass ClassContainsOwnedAttribute from uml.compositestructures.internalstructures.StructuredClassifier (0,1) role class to Property (0,*) role ownedAttribute aggregate from;
EdgeClass ComponentRealizationLinksToRealizingClassifier from uml.components.basiccomponents.ComponentRealization (0,*) role componentRealization to Classifier (1,1) role realizingClassifier;
CompositionClass DefaultValueIsPartOfOwningParameter from ValueSpecification (0,1) role defaultValue to Parameter (0,1) role owningParameter aggregate to;
EdgeClass ElementImportLinksToImportingNamespace from ElementImport (0,*) role elementImport to Namespace (1,1) role importingNamespace;
EdgeClass ElementLinksToStereotype from Element (0,*) role element to Stereotype (0,*) role stereotype;
EdgeClass ExpressionLinksToOperand from Expression (0,*) role expression to ValueSpecification (0,*) role operand;
EdgeClass GeneralLinksToSpecialization from Classifier (1,1) role general to Generalization (0,*) role specialization;
CompositionClass GeneralizationIsPartOfSpecific from Generalization (0,*) role generalization to Classifier (1,1) role specific aggregate to;
EdgeClass ImportLinksToImportedElement from ElementImport (1,1) role import to PackagableElement (1,1) role importedElement;
EdgeClass ImportingLinksToImportedPackage from PackageImport (0,*) role importing to 'Package (1,1) role importedPackage;
CompositionClass LowerValueIsPartOfOwningLower from ValueSpecification (0,1) role lowerValue to MultiplicityElement (0,1) role owningLower aggregate to;
CompositionClass MaxintIsPartOfMaxInteractionConstraint from ValueSpecification (0,1) role maxint to uml.interactions.fragments.InteractionConstraint (0,1) role maxInteractionConstraint aggregate to;
EdgeClass MemberEndLinksToAssociation from Property (2,*) role memberEnd to Association (0,1) role association;
EdgeClass MessageLinksToGuard from uml.interactions.basicinteractions.Message (0,1) role message to ValueSpecification (0,1) role guard;
CompositionClass MinintIsPartOfMinInteractionConstraint from ValueSpecification (0,1) role minint to uml.interactions.fragments.InteractionConstraint (0,1) role minInteractionConstraint aggregate to;
CompositionClass OwnedAttributeIsPartOfDataType from Property (0,*) role ownedAttribute to DataType (0,1) role dataType aggregate to;
CompositionClass OwnedCommentIsPartOfOwningElement from Comment (0,*) role ownedComment to Element (0,1) role owningElement aggregate to;
CompositionClass OwnedEndIsPartOfOwningAssociation from Property (0,*) role ownedEnd to Association (0,1) role owningAssociation aggregate to;
CompositionClass OwnedLiteralIsPartOfEnumeration from EnumerationLiteral (0,*) role ownedLiteral to Enumeration (0,1) role enumeration aggregate to;
CompositionClass OwnedOperationIsPartOfClass from Operation (0,*) role ownedOperation to Class (0,1) role class aggregate to;
CompositionClass OwnedOperationIsPartOfDataType from Operation (0,*) role ownedOperation to DataType (0,1) role dataType aggregate to;
CompositionClass OwnedParameterIsPartOfOperation from Parameter (0,*) role ownedParameter to Operation (0,1) role operation aggregate to;
CompositionClass OwnedUseCaseIsPartOfOwningClassifier from uml.usecases.UseCase (0,*) role ownedUseCase to Classifier (0,1) role owningClassifier aggregate to;
CompositionClass OwnerContainsArgument from uml.interactions.basicinteractions.Message (0,1) role owner to ValueSpecification (0,*) role argument aggregate from;
CompositionClass OwningConstraintContainsSpecification from Constraint (0,1) role owningConstraint to ValueSpecification (1,1) role specification aggregate from;
EdgeClass OwningPropertyLinksToDefaultValue from Property (0,1) role owningProperty to ValueSpecification (0,1) role defaultValue;
EdgeClass PackageImportLinksToImportingNamespace from PackageImport (0,*) role packageImport to Namespace (1,1) role importingNamespace;
CompositionClass PackagedElementIsPartOfOwningPackage from PackagableElement (0,*) role packagedElement to 'Package (0,1) role owningPackage aggregate to;
EdgeClass RaisedExceptionLinksToOperation from Type (0,*) role raisedException to Operation (0,*) role operation;
EdgeClass ReceiveOperationEventLinksToOperation from uml.interactions.basicinteractions.ReceiveOperationEvent (0,*) role receiveOperationEvent to Operation (1,1) role operation;
CompositionClass SelectorIsPartOfLifeline from ValueSpecification (0,1) role selector to uml.interactions.basicinteractions.Lifeline (0,1) role lifeline aggregate to;
EdgeClass SendOperationEventLinksToOperation from uml.interactions.basicinteractions.SendOperationEvent (0,*) role sendOperationEvent to Operation (1,1) role operation;
CompositionClass SpecificationIsPartOfOwningInstanceSpec from ValueSpecification (0,1) role specification to InstanceSpecification (0,1) role owningInstanceSpec aggregate to;
EdgeClass SuperPropertyLinksToSubsettedProperty from Property (0,*) role superProperty to Property (0,*) role subsettedProperty;
EdgeClass TypeLinksToTyped from Type (0,1) role type to TypedElement (0,*) role typed;
CompositionClass UpperValueIsPartOfOwningUpper from ValueSpecification (0,1) role upperValue to MultiplicityElement (0,1) role owningUpper aggregate to;
EdgeClass UseCaseLinksToSubject from uml.usecases.UseCase (0,*) role useCase to Classifier (0,*) role subject;
EdgeClass ValueLinksToInstance from InstanceValue (0,*) role value to InstanceSpecification (1,1) role instance;
Package uml.commonbehaviors.basicbehaviors;
abstract VertexClass Behavior: uml.classes.kernel.Class { isReentrant: Boolean };
abstract VertexClass BehavioredClassifier: uml.classes.kernel.Classifier;
EdgeClass BehaviorExecutionLinksToBehavior from uml.interactions.basicinteractions.BehaviorExecutionSpecification (0,*) role behaviorExecution to Behavior (0,1) role behavior;
EdgeClass BehavioredClassifierLinksToClassifierBehavior from BehavioredClassifier (0,1) role behavioredClassifier to Behavior (0,1) role classifierBehavior;
CompositionClass OwningClassifierContainsOwnedBehavior from BehavioredClassifier (0,1) role owningClassifier to Behavior (0,*) role ownedBehavior aggregate from;
Package uml.commonbehaviors.communications;
abstract VertexClass Event: uml.classes.kernel.PackagableElement;
abstract VertexClass MessageEvent: Event;
EdgeClass OccuranceSpecificationLinksToEvent from uml.interactions.basicinteractions.OccurrenceSpecification (0,*) role occuranceSpecification to Event (1,1) role event;
Package uml.components.basiccomponents;
EnumDomain ConnectorKind ( ASSEMBLY, DELEGATION );
VertexClass Component: uml.classes.kernel.Class { isIndirectlyInstantiated: Boolean };
VertexClass ComponentRealization: uml.classes.dependencies.Realization;
CompositionClass RealizationIsPartOfAbstraction from ComponentRealization (0,*) role realization to Component (0,1) role abstraction aggregate to;
Package uml.compositestructures.collaborations;
VertexClass Collaboration: uml.commonbehaviors.basicbehaviors.BehavioredClassifier, uml.compositestructures.internalstructures.StructuredClassifier;
EdgeClass CollaborationLinksToCollaborationRole from Collaboration (0,*) role collaboration to uml.compositestructures.internalstructures.ConnectableElement (0,*) role collaborationRole;
Package uml.compositestructures.internalstructures;
abstract VertexClass ConnectableElement: uml.classes.kernel.TypedElement;
VertexClass Connector: uml.classes.kernel.Feature { kind: uml.components.basiccomponents.ConnectorKind };
VertexClass ConnectorEnd: uml.classes.kernel.MultiplicityElement;
abstract VertexClass StructuredClassifier: uml.classes.kernel.Classifier;
CompositionClass EndIsPartOfConnector from ConnectorEnd (2,*) role end to Connector (1,1) role connector aggregate to;
EdgeClass EndLinksToRole from ConnectorEnd (0,*) role end to ConnectableElement (1,1) role 'role;
EdgeClass LifelineLinksToRepresents from uml.interactions.basicinteractions.Lifeline (0,*) role lifeline to ConnectableElement (0,1) role represents;
EdgeClass MessageLinksToConnector from uml.interactions.basicinteractions.Message (0,*) role message to Connector (0,1) role connector;
CompositionClass OwnedConnectorIsPartOfStructuredClassifier from Connector (0,*) role ownedConnector to StructuredClassifier (0,1) role structuredClassifier aggregate to;
Package uml.compositestructures.ports;
abstract VertexClass EncapsulatedClassifier: uml.compositestructures.internalstructures.StructuredClassifier;
Package uml.interactions.basicinteractions;
EnumDomain MessageSort ( ASYNCHCALL, SYNCHCALL, ASYNCHSIGNAL, CREATEMESSAGE, DELETEMESSAGE, REPLY );
VertexClass BehaviorExecutionSpecification: ExecutionSpecification;
VertexClass CreationEvent: uml.commonbehaviors.communications.Event;
VertexClass DestructionEvent: uml.commonbehaviors.communications.Event;
abstract VertexClass ExecutionSpecification: InteractionFragment;
VertexClass Interaction: InteractionFragment, uml.commonbehaviors.basicbehaviors.Behavior;
abstract VertexClass InteractionFragment: uml.classes.kernel.NamedElement;
VertexClass Lifeline: uml.classes.kernel.NamedElement;
VertexClass Message: uml.classes.kernel.NamedElement { messageSort: MessageSort };
abstract VertexClass MessageEnd: uml.classes.kernel.NamedElement;
VertexClass MessageOccurrenceSpecification: OccurrenceSpecification, MessageEnd;
VertexClass OccurrenceSpecification: InteractionFragment;
VertexClass ReceiveOperationEvent: uml.commonbehaviors.communications.MessageEvent;
VertexClass SendOperationEvent: uml.commonbehaviors.communications.MessageEvent;
EdgeClass CoveredLinksToCoveredBy from Lifeline (0,*) role covered to InteractionFragment (0,*) role coveredBy;
CompositionClass EnclosingInteractionContainsFragment from Interaction (0,1) role enclosingInteraction to InteractionFragment (0,*) role fragment aggregate from;
CompositionClass EnclosingOperandContainsFragment from uml.interactions.fragments.InteractionOperand (0,1) role enclosingOperand to InteractionFragment (0,*) role fragment aggregate from;
EdgeClass EndedExecutionLinksToFinish from ExecutionSpecification (0,*) role endedExecution to OccurrenceSpecification (1,1) role finish;
CompositionClass LifelineIsPartOfInteraction from Lifeline (0,*) role lifeline to Interaction (1,1) role interaction aggregate to;
EdgeClass MessageEndLinksToMessage from MessageEnd (0,1) role messageEnd to Message (0,1) role message;
CompositionClass MessageIsPartOfInteraction from Message (0,*) role message to Interaction (1,1) role interaction aggregate to;
EdgeClass ReceiveMessageLinksToReceiveEvent from Message (0,1) role receiveMessage to MessageEnd (0,1) role receiveEvent;
EdgeClass SendMessageLinksToSendEvent from Message (0,1) role sendMessage to MessageEnd (0,1) role sendEvent;
EdgeClass StartedExecutionLinksToStart from ExecutionSpecification (0,*) role startedExecution to OccurrenceSpecification (1,1) role start;
Package uml.interactions.fragments;
VertexClass CombinedFragment: uml.interactions.basicinteractions.InteractionFragment;
VertexClass InteractionConstraint: uml.classes.kernel.Constraint;
VertexClass InteractionOperand: uml.classes.kernel.Namespace, uml.interactions.basicinteractions.InteractionFragment;
CompositionClass CombinedFragmentContainsOperand from CombinedFragment (0,1) role combinedFragment to InteractionOperand (1,*) role operand aggregate from;
CompositionClass InteractionOperandContainsGuard from InteractionOperand (1,1) role interactionOperand to InteractionConstraint (0,1) role guard aggregate from;

Graph "RSL Graph_4791" SCLGraph (100 201 47 58) "f6f3558e-1946685-4c2e7f44-f2b48425";
Package sclkernel;
1 SoftwareCase <1> \null "8db52599-99abd513-a4cef530-dda0d330";
Package rsl.rsldomainelements.terms;
2 Terminology <7 15 16 76 12 13> \null "66d6516a-66509a0d-fbd97fb5-886f2187";
Package rsl.rslrequirements.requirementsspecifications;
3 RequirementsSpecification <-1 2 3> "Requirements Specification" "b9d26d6b-dc6527cf-6f8daed4-9cb57ac7";
4 RequirementsPackage <-2 31> "p1" "258b0d08-c721d6e5-9baea1c0-5e9b2202";
Package rsl.rsldomainelements.domainelements;
5 DomainSpecification <-3 4 5 6> "Domain Specification" "3ae76b5e-5d9172ae-851640ae-67eca90a";
Package rsl.rsldomainelements.notions;
6 NotionsPackage <-4 11> "Notions" "9bf96b32-50376c3c-5d61bff0-24c3b7ee";
Package rsl.rsldomainelements.actors;
7 ActorsPackage <-5 24> "Actors" "325e2224-192bd77e-597ac041-46548c5";
Package rsl.rsldomainelements.systemelements;
8 SystemElementsPackage <-6 97> "System Elements" "b83f6323-ef1796a1-6e21a062-91e15ba9";
Package rsl.rsldomainelements.terms;
9 Noun <-7 -8 -50 -82> \null "beer" -9078975369499355135 "1bbefc23-6d3d57b2-fad2d3e5-272b6706";
16 Noun <-15 -22 -48> \null "man" -9078975369496954771 "3fb882e5-b9d28585-12289ed4-f20a3070";
17 Verb <-16 -52 -89> \null "drink" -9078693894529360145 "cda23868-12130155-42c0478a-7254d216";
Package rsl.rsldomainelements.phrases;
11 NounPhrase <-9 -10> "6628757d-6be9fa72-118a9c62-fc5d9141";
10 NounLink <9 8> "436fa100-f21e1fc5-671acfc5-61007745" "beer";
Package rsl.rsldomainelements.notions;
12 Notion <10 -11 19> "918dfc34-473eb02e-cba2b2ef-2529f78b";
19 DomainStatement <-19 -34> "7f098f6f-d8fd70d0-8ebf050a-f953f145";
Package rsl.rsldomainelements.phrases;
20 NounPhrase <-21 -23> "c2f6ce33-34f88120-92420f83-10e81cf";
21 NounLink <21 22> "857e3dff-8e93d8ee-9445d76-f7282550" "man";
Package rsl.rsldomainelements.actors;
22 Actor <23 -24 -35> "4bf0546c-dca34334-e8538252-ee59e22d";
Package rsl.rslrequirements.requirementsspecifications;
27 Requirement <30 -31 32> \null "b833049e-e649d8c2-b890664c-1c491c49";
Package rsl.rslrequirementrepresentationsentences.representationsentences;
28 NaturalLanguageHypertextSentence <-30> "r1" "ea2fa407-3a6e9f98-34d64988-7e8864de";
Package rsl.rslrequirementrepresentations.descriptiverequirementrepresentations;
29 SentenceList <-32 58 101> "Sentences" "4fe3ff70-b5738bee-7ca2f5ac-ba36605e";
Package rsl.rsldomainelements.phrases;
39 NounPhrase <-47 -55> "e57f8aaa-90fc2b52-a1831669-1fd8a9ad";
40 NounLink <47 48> "31f23440-75ee7b2d-21c3e8bc-1241b84e" "men";
41 NounPhrase <-49 -53> "9bdfc556-c55ec0e0-18f3ef78-50b5ed66";
42 NounLink <49 50> "aaff658-cce115f8-ff4d76d1-8c88b50b" "beer";
43 SimpleVerbPhrase <-51 53 -57> "3ed7763-a43716d1-734763fc-eac5a0b";
44 PhraseVerbLink <51 52> "2ceff03c-ab971580-97ceb84b-b062cd79" "drinks";
Package rsl.rslrequirementrepresentationsentences.svosentences;
45 SVOSentence <-54 -56 -58> "men drinks beer" "67118b83-157916f3-812cb179-9fb4e268";
46 Subject <54 55 35> "a6d58127-5d53fe57-70be1b47-c3b01f6";
47 Predicate <56 57 34> "42c8541c-4e778ab9-a4d5a647-e7ee9b8c";
Package rsl.rsldomainelements.terms;
64 Noun <-76 -91 -86> \null "system" -9078975369502864927 "f907dbf0-43d6cbe5-264bfa5a-8bf34b27";
Package rsl.rsldomainelements.phrases;
77 NounPhrase <-93 -96> "f997a9f3-500f9d08-b373de03-9cb49b47";
80 NounLink <93 91> "3d04f022-31348a06-edb662a6-54defffa" "system";
Package rsl.rsldomainelements.systemelements;
82 SystemElement <96 -97> "e7114819-1555720-b07c45d5-be18413a";
Package rsl.rsldomainelements.terms;
13 ModalVerb <-12 -98> \null "may" 4846743175251746949 "5071320e-d332c6b5-7d11efe9-b4139916";
14 Determiner <-13 -85> \null "the" 2604163755229629397 "dff4aac3-6cd275f1-3b8ca22b-4829bb71";
Package rsl.rsldomainelements.phrases;
69 NounPhrase <-87 -83 -94> "b5cc710-ec3aa017-4b08977a-23272b45";
68 DeterminerLink <87 85> "67be9aeb-5f239aad-4bcd76ac-901532ce" "the";
67 NounLink <83 86> "e9cfef6e-94fa664b-e36757af-53c0980b" "system";
66 NounPhrase <-84 -90> "e2eea0d0-5c01c260-5b633a64-6c31bc2f";
70 NounLink <84 82> "894dea8f-841f0332-242fb64-52486acb" "beer";
71 SimpleVerbPhrase <-88 90 -100> "b2a6cca5-3ad1e101-254ade57-5df73798";
72 PhraseVerbLink <88 89> "406d0ffe-72b7956b-bfece986-afb07473" "drink";
Package rsl.rslrequirementrepresentationsentences.svosentences;
73 ModalSVOSentence <-92 -95 -99 -101> "the system may drink beer." "abeb9e24-f457eb12-8255e6ad-449e03a8";
74 Subject <92 94> "97a2203b-80c1237b-44891d15-c50d8a72";
75 ModalVerbLink <95 98> "f2691934-7761d739-3cb518e2-6b0ec7c2" "may";
76 Predicate <99 100> "5f80ef3d-f5de344a-5f3d13a9-1ada133f";
Package sclkernel;
1 SoftwareCaseContainsArtifact;
Package rsl.rslrequirements.requirementsspecifications;
2 RequirementsSpecificationContainsRequirementsPackage;
3 RequirementsSpecificationLinksToDomainSpecification;
Package rsl.rsldomainelements.domainelements;
4 DomainSpecificationContainsDomainElementsPackage;
5 DomainSpecificationContainsDomainElementsPackage;
6 DomainSpecificationContainsDomainElementsPackage;
Package rsl.rsldomainelements.terms;
7 TerminologyContainsTerm;
15 TerminologyContainsTerm;
16 TerminologyContainsTerm;
Package rsl.rsldomainelements.phrases;
9 NounIsPartOfSource;
8 NounLinkLinksToTarget;
Package rsl.rsldomainelements.notions;
10 NotionContainsName;
11 PackageContainsNotion;
Package rsl.rsldomainelements.domainelements;
19 DomainElementContainsStatement;
Package rsl.rsldomainelements.phrases;
21 NounIsPartOfSource;
22 NounLinkLinksToTarget;
Package rsl.rsldomainelements.domainelements;
23 ElementContainsName;
Package rsl.rsldomainelements.actors;
24 PackageContainsActor;
Package rsl.rslrequirements.requirementsspecifications;
30 RequirementContainsName;
31 PackageContainsRequirement;
32 RequirementContainsRepresentation;
Package rsl.rslkernel.elements;
58 SentenceListContainsSentence;
Package rsl.rsldomainelements.phrases;
47 NounIsPartOfSource;
48 NounLinkLinksToTarget;
49 NounIsPartOfSource;
50 NounLinkLinksToTarget;
51 VerbIsPartOfSource;
52 VerbLinkLinksToTarget;
53 VerbPhraseContainsObject;
Package rsl.rslrequirementrepresentationsentences.svosentences;
54 SubjectIsPartOfSource;
55 SubjectContainsTarget;
56 PredicateIsPartOfSource;
57 PredicateContainsTarget;
34 LinkingPredicateLinksToDomainStatement;
35 LinkingSubjectLinksToDomainElement;
Package rsl.rsldomainelements.terms;
76 TerminologyContainsTerm;
Package rsl.rsldomainelements.phrases;
93 NounIsPartOfSource;
91 NounLinkLinksToTarget;
Package rsl.rsldomainelements.domainelements;
96 ElementContainsName;
Package rsl.rsldomainelements.systemelements;
97 PackageContainsSystemElement;
Package rsl.rsldomainelements.terms;
12 TerminologyContainsTerm;
13 TerminologyContainsTerm;
Package rsl.rslkernel.elements;
101 SentenceListContainsSentence;
Package rsl.rsldomainelements.phrases;
87 DeterminerIsPartOfSource;
85 DeterminerLinkLinksToTarget;
83 NounIsPartOfSource;
86 NounLinkLinksToTarget;
84 NounIsPartOfSource;
82 NounLinkLinksToTarget;
88 VerbIsPartOfSource;
89 VerbLinkLinksToTarget;
90 VerbPhraseContainsObject;
Package rsl.rslrequirementrepresentationsentences.svosentences;
92 SubjectIsPartOfSource;
94 SubjectContainsTarget;
95 ModalVerbIsPartOfSource;
98 ModalVerbLinkLinksToTarget;
99 PredicateIsPartOfSource;
100 PredicateContainsTarget;

bug#1034: 23.0.60; The attached mail crashes Emacs when viewed with Gnus

[Lars Magne Ingebrigtsen]

Tassilo Horn <tassilo@member.fsf.org> writes:

> the attached mail crashes emacs when trying to read it with Gnus.
>
> I select it with RET in the *Summary* buffer and it is displayed.  Now
> hitting RET again will scroll it a bit, and after I scrolled some lines
> it completely crashes my emacs process.

This doesn't seem reproducible in Emacs 24, so I'm closing the bug.

-- 
(domestic pets only, the antidote for overdose, milk.)
  larsi@gnus.org * Lars Magne Ingebrigtsen

bug#1034: 23.0.60; The attached mail crashes Emacs when viewed with Gnus

[Tassilo Horn]

Lars Magne Ingebrigtsen <larsi@gnus.org> writes:

>> the attached mail crashes emacs when trying to read it with Gnus.
>>
>> I select it with RET in the *Summary* buffer and it is displayed.
>> Now hitting RET again will scroll it a bit, and after I scrolled some
>> lines it completely crashes my emacs process.
>
> This doesn't seem reproducible in Emacs 24, so I'm closing the bug.

Confirmed, I cannot reproduce it with the current trunk, too.

Bye,
Tassilo