j.vdmj.4.6.0-P.source-code.tc-po.mappings Maven / Gradle / Ivy
The newest version!
##########################################################################################
# The class mapping definition for the VDMJ Proof Obligation Generator. See ClassMapper.
##########################################################################################
# initializers, called by ClassMapper.init()
init com.fujitsu.vdmj.po.annotations.POAnnotation.reset();
# definitions
package com.fujitsu.vdmj.tc.definitions to com.fujitsu.vdmj.po.definitions;
map TCDefinitionList{} to PODefinitionList(this);
map TCDefinitionListList{} to PODefinitionListList(this);
map TCAccessSpecifier{isStatic, isAsync, access, isPure} to POAccessSpecifier(isStatic, isAsync, access, isPure);
map TCAssignmentDefinition{ name, type, expression, expType} to POAssignmentDefinition(name, type, expression, expType);
map TCBUSClassDefinition{classtype, definitions} to POBUSClassDefinition(classtype, definitions, this);
map TCClassDefinition{annotations, name, classtype, definitions, invariant, hasConstructors} to POClassDefinition(annotations, name, classtype, definitions, invariant, hasConstructors, this);
map TCClassInvariantDefinition{name, expression, classDefinition} to POClassInvariantDefinition(name, expression, classDefinition);
map TCClassList{} to POClassList(this);
map TCCPUClassDefinition{classtype, definitions, invariant, hasConstructors} to POCPUClassDefinition(classtype, definitions, invariant, hasConstructors, this);
map TCDefinition{} to PODefinition();
map TCEqualsDefinition{location, pattern, typebind, bind, test, expType, defType, defs} to POEqualsDefinition(location, pattern, typebind, bind, test, expType, defType, defs);
map TCExplicitFunctionDefinition{annotations, name, typeParams, type, paramPatternList, body, precondition, postcondition, isUndefined, expectedResult, actualResult, predef, postdef, paramDefinitionList, recursive, measureDef, measureName} to POExplicitFunctionDefinition(annotations, name, typeParams, type, paramPatternList, body, precondition, postcondition, isUndefined, expectedResult, actualResult, predef, postdef, paramDefinitionList, recursive, measureDef, measureName);
map TCExplicitOperationDefinition{annotations, name, type, parameterPatterns, paramDefinitions, actualResult, precondition, postcondition, body, isConstructor, predef, postdef, state} to POExplicitOperationDefinition(annotations, name, type, parameterPatterns, precondition, postcondition, body, predef, postdef, paramDefinitions, state, actualResult, isConstructor);
map TCExternalDefinition{state, readOnly} to POExternalDefinition(state, readOnly);
map TCImplicitFunctionDefinition{annotations, name, typeParams, parameterPatterns, type, result, body, precondition, postcondition, predef, postdef, recursive, isUndefined, actualResult, measureDef, measureName} to POImplicitFunctionDefinition(annotations, name, typeParams, parameterPatterns, result, body, precondition, postcondition, type, predef, postdef, recursive, isUndefined, actualResult, measureDef, measureName);
map TCImplicitOperationDefinition{annotations, name, parameterPatterns, result, body, externals, precondition, postcondition, errors, type, isConstructor, predef, postdef, state, actualResult} to POImplicitOperationDefinition(annotations, name, parameterPatterns, result, body, externals, precondition, postcondition, errors, type, predef, postdef, actualResult, state, isConstructor);
map TCImportedDefinition{location, def} to POImportedDefinition(location, def);
map TCInheritedDefinition{name, superdef} to POInheritedDefinition(name, superdef);
map TCInstanceVariableDefinition{name, type, expression, expType} to POInstanceVariableDefinition(name, type, expression, expType);
map TCLocalDefinition{location, name, type} to POLocalDefinition(location, name, type);
map TCMultiBindListDefinition{location, bindings, defs} to POMultiBindListDefinition(location, bindings, defs);
map TCMutexSyncDefinition{annotations, location, operations} to POMutexSyncDefinition(annotations, location, operations);
map TCNamedTraceDefinition{annotations, location, name} to PONamedTraceDefinition(annotations, location, name);
map TCPerSyncDefinition{annotations, location, opname, guard} to POPerSyncDefinition(annotations, location, opname, guard);
map TCRenamedDefinition{name, def} to PORenamedDefinition(name, def);
map TCStateDefinition{name, fields, invPattern, invExpression, initPattern, initExpression, invdef, initdef, recordType} to POStateDefinition(name, fields, invPattern, invExpression, initPattern, initExpression, invdef, initdef, recordType);
map TCSystemDefinition{name, classtype, definitions} to POSystemDefinition(name, classtype, definitions, this);
map TCThreadDefinition{statement} to POThreadDefinition(statement);
map TCTypeDefinition{annotations, name, type, invPattern, invExpression, invdef, eqPattern1, eqPattern2, eqExpression, eqdef, ordPattern1, ordPattern2, ordExpression, orddef} to POTypeDefinition(annotations, name, type, invPattern, invExpression, invdef, eqPattern1, eqPattern2, eqExpression, eqdef, ordPattern1, ordPattern2, ordExpression, orddef);
map TCValueDefinition{annotations, pattern, type, exp, expType} to POValueDefinition(annotations, pattern, type, exp, expType);
map TCUntypedDefinition{location, name} to POUntypedDefinition(location, name);
map TCQualifiedDefinition{def, type} to POQualifiedDefinition(def, type);
# expressions
package com.fujitsu.vdmj.tc.expressions to com.fujitsu.vdmj.po.expressions;
map TCExpression{} to POExpression();
map TCExpressionList{} to POExpressionList(this);
map TCAbsoluteExpression{location, exp, exptype} to POAbsoluteExpression(location, exp) set exptype;
map TCAndExpression{left, op, right, ltype, rtype, exptype} to POAndExpression(left, op, right, ltype, rtype) set exptype;
map TCApplyExpression{root, args, type, argtypes, recursiveCycles, exptype} to POApplyExpression(root, args, type, argtypes, recursiveCycles) set exptype;
map TCBinaryExpression{} to POBinaryExpression();
map TCBooleanBinaryExpression{} to POBooleanBinaryExpression();
map TCBooleanLiteralExpression{value, exptype} to POBooleanLiteralExpression(value) set exptype;
map TCCardinalityExpression{location, exp, exptype} to POCardinalityExpression(location, exp) set exptype;
map TCCaseAlternative{cexp, pattern, result} to POCaseAlternative(cexp, pattern, result);
map TCCaseAlternativeList{} to POCaseAlternativeList(this);
map TCCasesExpression{location, exp, cases, others, expType, exptype} to POCasesExpression(location, exp, cases, others, expType) set exptype;
map TCCharLiteralExpression{value, exptype} to POCharLiteralExpression(value) set exptype;
map TCCompExpression{left, op, right, ltype, rtype, exptype} to POCompExpression(left, op, right, ltype, rtype) set exptype;
map TCDefExpression{location, localDefs, expression, exptype} to PODefExpression(location, localDefs, expression) set exptype;
map TCDistConcatExpression{location, exp, exptype} to PODistConcatExpression(location, exp) set exptype;
map TCDistIntersectExpression{location, exp, exptype} to PODistIntersectExpression(location, exp) set exptype;
map TCDistMergeExpression{location, exp, exptype} to PODistMergeExpression(location, exp) set exptype;
map TCDistUnionExpression{location, exp, exptype} to PODistUnionExpression(location, exp) set exptype;
map TCDivExpression{left, op, right, ltype, rtype, exptype} to PODivExpression(left, op, right, ltype, rtype) set exptype;
map TCDivideExpression{left, op, right, ltype, rtype, exptype} to PODivideExpression(left, op, right, ltype, rtype) set exptype;
map TCDomainResByExpression{left, op, right, ltype, rtype, exptype} to PODomainResByExpression(left, op, right, ltype, rtype) set exptype;
map TCDomainResToExpression{left, op, right, ltype, rtype, exptype} to PODomainResToExpression(left, op, right, ltype, rtype) set exptype;
map TCElementsExpression{location, exp, exptype} to POElementsExpression(location, exp) set exptype;
map TCElseIfExpression{location, elseIfExp, thenExp, exptype} to POElseIfExpression(location, elseIfExp, thenExp) set exptype;
map TCElseIfExpressionList{} to POElseIfExpressionList(this);
map TCEqualsExpression{left, op, right, ltype, rtype, exptype} to POEqualsExpression(left, op, right, ltype, rtype) set exptype;
map TCEquivalentExpression{left, op, right, ltype, rtype, exptype} to POEquivalentExpression(left, op, right, ltype, rtype) set exptype;
map TCExists1Expression{location, bind, predicate, exptype} to POExists1Expression(location, bind, predicate) set exptype;
map TCExistsExpression{location, bindList, predicate, exptype} to POExistsExpression(location, bindList, predicate) set exptype;
map TCFieldExpression{object, field, memberName, exptype} to POFieldExpression(object, field, memberName) set exptype;
map TCFieldNumberExpression{tuple, field, type, exptype} to POFieldNumberExpression(tuple, field, type) set exptype;
map TCFloorExpression{location, exp, exptype} to POFloorExpression(location, exp) set exptype;
map TCForAllExpression{location, bindList, predicate, exptype} to POForAllExpression(location, bindList, predicate) set exptype;
map TCFuncInstantiationExpression{function, type, actualTypes, expdef, impdef, exptype} to POFuncInstantiationExpression(function, actualTypes, type, expdef, impdef) set exptype;
map TCGreaterEqualExpression{left, op, right, ltype, rtype, exptype} to POGreaterEqualExpression(left, op, right, ltype, rtype) set exptype;
map TCGreaterExpression{left, op, right, ltype, rtype, exptype} to POGreaterExpression(left, op, right, ltype, rtype) set exptype;
map TCHeadExpression{location, exp, etype, exptype} to POHeadExpression(location, exp, etype) set exptype;
map TCHistoryExpression{location, hop, opnames, exptype} to POHistoryExpression(location, hop, opnames) set exptype;
map TCIfExpression{location, ifExp, thenExp, elseList, elseExp, exptype} to POIfExpression(location, ifExp, thenExp, elseList, elseExp) set exptype;
map TCImpliesExpression{left, op, right, ltype, rtype, exptype} to POImpliesExpression(left, op, right, ltype, rtype) set exptype;
map TCIndicesExpression{location, exp, exptype} to POIndicesExpression(location, exp) set exptype;
map TCInSetExpression{left, op, right, ltype, rtype, exptype} to POInSetExpression(left, op, right, ltype, rtype) set exptype;
map TCIntegerLiteralExpression{value, exptype} to POIntegerLiteralExpression(value) set exptype;
map TCIotaExpression{location, bind, predicate, exptype} to POIotaExpression(location, bind, predicate) set exptype;
map TCIsExpression{location, typename, basictype, test, typedef, exptype} to POIsExpression(location, basictype, typename, test, typedef) set exptype;
map TCIsOfBaseClassExpression{location, baseclass, exp, exptype} to POIsOfBaseClassExpression(location, baseclass, exp) set exptype;
map TCIsOfClassExpression{location, classname, exp, classType, exptype} to POIsOfClassExpression(location, classname, exp, classType) set exptype;
map TCLambdaExpression{location, bindList, paramPatterns, type, expression, paramDefinitions, exptype} to POLambdaExpression(location, bindList, expression, type, paramPatterns, paramDefinitions) set exptype;
map TCLenExpression{location, exp, exptype} to POLenExpression(location, exp) set exptype;
map TCLessEqualExpression{left, op, right, ltype, rtype, exptype} to POLessEqualExpression(left, op, right, ltype, rtype) set exptype;
map TCLessExpression{left, op, right, ltype, rtype, exptype} to POLessExpression(left, op, right, ltype, rtype) set exptype;
map TCLetBeStExpression{location, bind, suchThat, value, def, exptype} to POLetBeStExpression(location, bind, suchThat, value, def) set exptype;
map TCLetDefExpression{location, localDefs, expression, exptype} to POLetDefExpression(location, localDefs, expression) set exptype;
map TCMapCompExpression{location, first, bindings, predicate, maptype, exptype} to POMapCompExpression(location, first, bindings, predicate, maptype) set exptype;
map TCMapDomainExpression{location, exp, exptype} to POMapDomainExpression(location, exp) set exptype;
map TCMapEnumExpression{location, members, domtypes, rngtypes, exptype} to POMapEnumExpression(location, members, domtypes, rngtypes) set exptype;
map TCMapExpression{} to POMapExpression();
map TCMapInverseExpression{location, exp, type, exptype} to POMapInverseExpression(location, exp, type) set exptype;
map TCMapletExpression{location, left, right} to POMapletExpression(location, left, right);
map TCMapletExpressionList{} to POMapletExpressionList(this);
map TCMapRangeExpression{location, exp, exptype} to POMapRangeExpression(location, exp) set exptype;
map TCMapUnionExpression{left, op, right, ltype, rtype, exptype} to POMapUnionExpression(left, op, right, ltype, rtype) set exptype;
map TCMkBasicExpression{type, arg, exptype} to POMkBasicExpression(type, arg) set exptype;
map TCMkTypeExpression{typename, args, recordType, argTypes, exptype} to POMkTypeExpression(typename, args, recordType, argTypes) set exptype;
map TCModExpression{left, op, right, ltype, rtype, exptype} to POModExpression(left, op, right, ltype, rtype) set exptype;
map TCMuExpression{location, record, modifiers, recordType, modTypes, exptype} to POMuExpression(location, record, modifiers, recordType, modTypes) set exptype;
map TCNarrowExpression{location, basictype, typename, test, typedef, testtype, exptype} to PONarrowExpression(location, basictype, typename, test, typedef, testtype) set exptype;
map TCNewExpression{location, classname, args, exptype} to PONewExpression(location, classname, args) set exptype;
map TCNilExpression{location, exptype} to PONilExpression(location) set exptype;
map TCNotEqualExpression{left, op, right, ltype, rtype, exptype} to PONotEqualExpression(left, op, right, ltype, rtype) set exptype;
map TCNotExpression{location, exp, exptype} to PONotExpression(location, exp) set exptype;
map TCNotInSetExpression{left, op, right, ltype, rtype, exptype} to PONotInSetExpression(left, op, right, ltype, rtype) set exptype;
map TCNotYetSpecifiedExpression{location, exptype} to PONotYetSpecifiedExpression(location) set exptype;
map TCNumericBinaryExpression{} to PONumericBinaryExpression();
map TCOrExpression{left, op, right, ltype, rtype, exptype} to POOrExpression(left, op, right, ltype, rtype) set exptype;
map TCPlusExpression{left, op, right, ltype, rtype, exptype} to POPlusExpression(left, op, right, ltype, rtype) set exptype;
map TCPlusPlusExpression{left, op, right, ltype, rtype, exptype} to POPlusPlusExpression(left, op, right, ltype, rtype) set exptype;
map TCPostOpExpression{postexpression, exptype} to POPostOpExpression(postexpression) set exptype;
map TCPowerSetExpression{location, exp, exptype} to POPowerSetExpression(location, exp) set exptype;
map TCPreExpression{location, function, args, exptype} to POPreExpression(location, function, args) set exptype;
map TCPreOpExpression{expression, exptype} to POPreOpExpression(expression) set exptype;
map TCProperSubsetExpression{left, op, right, ltype, rtype, exptype} to POProperSubsetExpression(left, op, right, ltype, rtype) set exptype;
map TCQuoteLiteralExpression{type, exptype} to POQuoteLiteralExpression(type) set exptype;
map TCRangeResByExpression{left, op, right, ltype, rtype, exptype} to PORangeResByExpression(left, op, right, ltype, rtype) set exptype;
map TCRangeResToExpression{left, op, right, ltype, rtype, exptype} to PORangeResToExpression(left, op, right, ltype, rtype) set exptype;
map TCRealLiteralExpression{value, exptype} to PORealLiteralExpression(value) set exptype;
map TCRecordModifier{tag, value} to PORecordModifier(tag, value);
map TCRecordModifierList{} to PORecordModifierList(this);
map TCRemExpression{left, op, right, ltype, rtype, exptype} to PORemExpression(left, op, right, ltype, rtype) set exptype;
map TCReverseExpression{location, exp, exptype} to POReverseExpression(location, exp) set exptype;
map TCSameBaseClassExpression{location, left, right, exptype} to POSameBaseClassExpression(location, left, right) set exptype;
map TCSameClassExpression{location, left, right, exptype} to POSameClassExpression(location, left, right) set exptype;
map TCSelfExpression{location, exptype} to POSelfExpression(location) set exptype;
map TCSeqCompExpression{location, first, bind, predicate, exptype} to POSeqCompExpression(location, first, bind, predicate) set exptype;
map TCSeqConcatExpression{left, op, right, ltype, rtype, exptype} to POSeqConcatExpression(left, op, right, ltype, rtype) set exptype;
map TCSeqEnumExpression{location, members, types, exptype} to POSeqEnumExpression(location, members, types) set exptype;
map TCSeqExpression{} to POSeqExpression();
map TCSetCompExpression{location, first, bindings, predicate, setType, exptype} to POSetCompExpression(location, first, bindings, predicate, setType) set exptype;
map TCSetDifferenceExpression{left, op, right, ltype, rtype, exptype} to POSetDifferenceExpression(left, op, right, ltype, rtype) set exptype;
map TCSetEnumExpression{location, members, types, exptype} to POSetEnumExpression(location, members, types) set exptype;
map TCSetExpression{} to POSetExpression();
map TCSetIntersectExpression{left, op, right, ltype, rtype, exptype} to POSetIntersectExpression(left, op, right, ltype, rtype) set exptype;
map TCSetRangeExpression{location, first, last, ftype, ltype, exptype} to POSetRangeExpression(location, first, last, ftype, ltype) set exptype;
map TCSetUnionExpression{left, op, right, ltype, rtype, exptype} to POSetUnionExpression(left, op, right, ltype, rtype) set exptype;
map TCStarStarExpression{left, op, right, ltype, rtype, exptype} to POStarStarExpression(left, op, right, ltype, rtype) set exptype;
map TCStateInitExpression{state, exptype} to POStateInitExpression(state) set exptype;
map TCStringLiteralExpression{value, exptype} to POStringLiteralExpression(value) set exptype;
map TCSubclassResponsibilityExpression{location, exptype} to POSubclassResponsibilityExpression(location) set exptype;
map TCSubseqExpression{seq, from, to, ftype, ttype, exptype} to POSubseqExpression(seq, from, to, ftype, ttype) set exptype;
map TCSubsetExpression{left, op, right, ltype, rtype, exptype} to POSubsetExpression(left, op, right, ltype, rtype) set exptype;
map TCSubtractExpression{left, op, right, ltype, rtype, exptype} to POSubtractExpression(left, op, right, ltype, rtype) set exptype;
map TCTailExpression{location, exp, etype, exptype} to POTailExpression(location, exp, etype) set exptype;
map TCThreadIdExpression{location, exptype} to POThreadIdExpression(location) set exptype;
map TCTimeExpression{location, exptype} to POTimeExpression(location) set exptype;
map TCTimesExpression{left, op, right, ltype, rtype, exptype} to POTimesExpression(left, op, right, ltype, rtype) set exptype;
map TCTupleExpression{location, args, types, exptype} to POTupleExpression(location, args, types) set exptype;
map TCUnaryExpression{} to POUnaryExpression();
map TCUnaryMinusExpression{location, exp, exptype} to POUnaryMinusExpression(location, exp) set exptype;
map TCUnaryPlusExpression{location, exp, exptype} to POUnaryPlusExpression(location, exp) set exptype;
map TCUndefinedExpression{location, exptype} to POUndefinedExpression(location) set exptype;
map TCVariableExpression{name, vardef, exptype} to POVariableExpression(name, vardef) set exptype;
# annotations
package com.fujitsu.vdmj.tc.annotations to com.fujitsu.vdmj.po.annotations;
map TCAnnotatedExpression{location, annotation, expression} to POAnnotatedExpression(location, annotation, expression);
map TCAnnotatedStatement{location, annotation, statement} to POAnnotatedStatement(location, annotation, statement);
map TCAnnotation{} to POAnnotation();
map TCAnnotationList{} to POAnnotationList(this);
# lex
unmapped com.fujitsu.vdmj.ast.lex.LexIntegerToken;
unmapped com.fujitsu.vdmj.ast.lex.LexBooleanToken;
unmapped com.fujitsu.vdmj.ast.lex.LexCharacterToken;
unmapped com.fujitsu.vdmj.ast.lex.LexKeywordToken;
unmapped com.fujitsu.vdmj.ast.lex.LexQuoteToken;
unmapped com.fujitsu.vdmj.ast.lex.LexRealToken;
unmapped com.fujitsu.vdmj.ast.lex.LexStringToken;
unmapped com.fujitsu.vdmj.lex.LexLocation;
unmapped com.fujitsu.vdmj.lex.Token;
unmapped com.fujitsu.vdmj.tc.lex.TCIdentifierToken;
unmapped com.fujitsu.vdmj.tc.lex.TCNameToken;
unmapped com.fujitsu.vdmj.tc.lex.TCNameList;
# modules
package com.fujitsu.vdmj.tc.modules to com.fujitsu.vdmj.po.modules;
map TCModuleList{} to POModuleList(this);
map TCModule{annotations, name, defs} to POModule(annotations, name, defs, this);
# patterns
package com.fujitsu.vdmj.tc.patterns to com.fujitsu.vdmj.po.patterns;
map TCBind{} to POBind();
map TCBooleanPattern{value} to POBooleanPattern(value);
map TCCharacterPattern{value} to POCharacterPattern(value);
map TCConcatenationPattern{left, location, right} to POConcatenationPattern(left, location, right);
map TCExpressionPattern{exp} to POExpressionPattern(exp);
map TCIdentifierPattern{name} to POIdentifierPattern(name);
map TCIgnorePattern{location} to POIgnorePattern(location);
map TCIntegerPattern{value} to POIntegerPattern(value);
map TCMapletPattern{from, to} to POMapletPattern(from, to);
map TCMapletPatternList{} to POMapletPatternList(this);
map TCMapPattern{location, maplets} to POMapPattern(location, maplets);
map TCMapUnionPattern{left, location, right} to POMapUnionPattern(left, location, right);
map TCMultipleBind{} to POMultipleBind();
map TCMultipleBindList{} to POMultipleBindList(this);
map TCMultipleSeqBind{plist, sequence} to POMultipleSeqBind(plist, sequence);
map TCMultipleSetBind{plist, set} to POMultipleSetBind(plist, set);
map TCMultipleTypeBind{plist, type} to POMultipleTypeBind(plist, type);
map TCNamePatternPair{name, pattern} to PONamePatternPair(name, pattern);
map TCNamePatternPairList{} to PONamePatternPairList(this);
map TCNilPattern{location} to PONilPattern(location);
map TCObjectPattern{location, classname, fieldlist} to POObjectPattern(location, classname, fieldlist);
map TCPattern{} to POPattern();
map TCPatternList{} to POPatternList(this);
map TCPatternListList{} to POPatternListList(this);
map TCPatternBind{location, pattern, bind, defs} to POPatternBind(location, pattern, bind, defs);
map TCQuotePattern{value} to POQuotePattern(value);
map TCRealPattern{value} to PORealPattern(value);
map TCRecordPattern{typename, plist, type} to PORecordPattern(typename, plist, type);
map TCSeqBind{pattern, sequence} to POSeqBind(pattern, sequence);
map TCSeqPattern{location, plist} to POSeqPattern(location, plist);
map TCSetBind{pattern, set} to POSetBind(pattern, set);
map TCSetPattern{location, plist} to POSetPattern(location, plist);
map TCStringPattern{value} to POStringPattern(value);
map TCTuplePattern{location, plist} to POTuplePattern(location, plist);
map TCTypeBind{pattern, type} to POTypeBind(pattern, type);
map TCTypeBindList{} to POTypeBindList(this);
map TCUnionPattern{left, location, right} to POUnionPattern(left, location, right);
# statements
package com.fujitsu.vdmj.tc.statements to com.fujitsu.vdmj.po.statements;
map TCAlwaysStatement{location, always, body, stmttype} to POAlwaysStatement(location, always, body) set stmttype;
map TCAssignmentStatement{location, target, exp, expType, targetType, classDefinition, stateDefinition, inConstructor, stmttype} to POAssignmentStatement(location, target, exp, targetType, expType, classDefinition, stateDefinition, inConstructor) set stmttype;
map TCAssignmentStatementList{} to POAssignmentStatementList(this);
map TCAtomicStatement{location, assignments, stmttype} to POAtomicStatement(location, assignments) set stmttype;
map TCBlockStatement{location, assignmentDefs, statements, stmttype} to POBlockStatement(location, assignmentDefs, statements) set stmttype;
map TCCallObjectStatement{designator, classname, fieldname, args, stmttype} to POCallObjectStatement(designator, classname, fieldname, args) set stmttype;
map TCCallStatement{name, args, stmttype} to POCallStatement(name, args) set stmttype;
map TCCasesStatement{location, exp, cases, others, stmttype} to POCasesStatement(location, exp, cases, others) set stmttype;
map TCCaseStmtAlternative{pattern, statement} to POCaseStmtAlternative(pattern, statement);
map TCCaseStmtAlternativeList{} to POCaseStmtAlternativeList(this);
map TCClassInvariantStatement{name, invdefs, stmttype} to POClassInvariantStatement(name, invdefs) set stmttype;
map TCCyclesStatement{location, cycles, statement, stmttype} to POCyclesStatement(location, cycles, statement) set stmttype;
map TCDefStatement{location, equalsDefs, statement, stmttype} to PODefStatement(location, equalsDefs, statement) set stmttype;
map TCDurationStatement{location, duration, statement, stmttype} to PODurationStatement(location, duration, statement) set stmttype;
map TCElseIfStatement{location, elseIfExp, thenStmt, stmttype} to POElseIfStatement(location, elseIfExp, thenStmt) set stmttype;
map TCElseIfStatementList{} to POElseIfStatementList(this);
map TCErrorCase{name, left, right} to POErrorCase(name, left, right);
map TCErrorCaseList{} to POErrorCaseList(this);
map TCErrorStatement{location, stmttype} to POErrorStatement(location) set stmttype;
map TCExitStatement{location, expression, stmttype} to POExitStatement(location, expression) set stmttype;
map TCExternalClause{mode, identifiers, type} to POExternalClause(mode, identifiers, type);
map TCExternalClauseList{} to POExternalClauseList(this);
map TCFieldDesignator{object, field} to POFieldDesignator(object, field);
map TCForAllStatement{location, pattern, set, statement, stmttype} to POForAllStatement(location, pattern, set, statement) set stmttype;
map TCForIndexStatement{location, var, from, to, by, statement, stmttype} to POForIndexStatement(location, var, from, to, by, statement) set stmttype;
map TCForPatternBindStatement{location, patternBind, reverse, exp, statement, stmttype} to POForPatternBindStatement(location, patternBind, reverse, exp, statement) set stmttype;
map TCIdentifierDesignator{name} to POIdentifierDesignator(name);
map TCIfStatement{location, ifExp, thenStmt, elseList, elseStmt, stmttype} to POIfStatement(location, ifExp, thenStmt, elseList, elseStmt) set stmttype;
map TCLetBeStStatement{location, bind, suchThat, statement, stmttype} to POLetBeStStatement(location, bind, suchThat, statement) set stmttype;
map TCLetDefStatement{location, localDefs, statement, stmttype} to POLetDefStatement(location, localDefs, statement) set stmttype;
map TCMapSeqDesignator{mapseq, exp, seqType} to POMapSeqDesignator(mapseq, exp, seqType);
map TCNonDeterministicStatement{location, statements, stmttype} to PONonDeterministicStatement(location, statements) set stmttype;
map TCNotYetSpecifiedStatement{location, stmttype} to PONotYetSpecifiedStatement(location) set stmttype;
map TCObjectApplyDesignator{object, args} to POObjectApplyDesignator(object, args);
map TCObjectDesignator{} to POObjectDesignator();
map TCObjectFieldDesignator{object, classname, fieldname} to POObjectFieldDesignator(object, classname, fieldname);
map TCObjectIdentifierDesignator{name} to POObjectIdentifierDesignator(name);
map TCObjectNewDesignator{expression} to POObjectNewDesignator(expression);
map TCObjectSelfDesignator{location} to POObjectSelfDesignator(location);
map TCPeriodicStatement{opname, args, stmttype} to POPeriodicStatement(opname, args) set stmttype;
map TCReturnStatement{location, expression, stmttype} to POReturnStatement(location, expression) set stmttype;
map TCSkipStatement{location, stmttype} to POSkipStatement(location) set stmttype;
map TCSpecificationStatement{location, externals, precondition, postcondition, errors, stmttype} to POSpecificationStatement(location, externals, precondition, postcondition, errors) set stmttype;
map TCSporadicStatement{opname, args, stmttype} to POSporadicStatement(opname, args) set stmttype;
map TCStartStatement{location, objects, stmttype} to POStartStatement(location, objects) set stmttype;
map TCStateDesignator{} to POStateDesignator();
map TCStatement{} to POStatement();
map TCStatementList{} to POStatementList(this);
map TCStopStatement{location, objects, stmttype} to POStopStatement(location, objects) set stmttype;
map TCSubclassResponsibilityStatement{location, stmttype} to POSubclassResponsibilityStatement(location) set stmttype;
map TCTixeStatement{location, traps, body, stmttype} to POTixeStatement(location, traps, body) set stmttype;
map TCTixeStmtAlternative{patternBind, statement} to POTixeStmtAlternative(patternBind, statement);
map TCTixeStmtAlternativeList{} to POTixeStmtAlternativeList(this);
map TCTrapStatement{location, patternBind, with, body, stmttype} to POTrapStatement(location, patternBind, with, body) set stmttype;
map TCWhileStatement{location, exp, statement, stmttype} to POWhileStatement(location, exp, statement) set stmttype;
# traces
package com.fujitsu.vdmj.tc.traces to com.fujitsu.vdmj.po.traces;
map TCTraceApplyExpression{} to POTraceApplyExpression();
map TCTraceBracketedExpression{} to POTraceBracketedExpression();
map TCTraceConcurrentExpression{} to POTraceConcurrentExpression();
map TCTraceCoreDefinition{} to POTraceCoreDefinition();
map TCTraceDefinition{} to POTraceDefinition();
map TCTraceDefinitionList{} to POTraceDefinitionList();
map TCTraceDefinitionTerm{} to POTraceDefinitionTerm();
map TCTraceDefinitionTermList{} to POTraceDefinitionTermList();
map TCTraceLetBeStBinding{} to POTraceLetBeStBinding();
map TCTraceLetDefBinding{} to POTraceLetDefBinding();
map TCTraceRepeatDefinition{} to POTraceRepeatDefinition();
# types
package com.fujitsu.vdmj.tc.types to com.fujitsu.vdmj.po.types;
map TCPatternListTypePairList{} to POPatternListTypePairList(this);
map TCPatternListTypePair{patterns, type} to POPatternListTypePair(patterns, type);
map TCPatternTypePair{pattern, type} to POPatternTypePair(pattern, type);
unmapped com.fujitsu.vdmj.tc.types.TCType;
unmapped com.fujitsu.vdmj.tc.types.TCTypeList;
unmapped com.fujitsu.vdmj.tc.types.TCBasicType;
unmapped com.fujitsu.vdmj.tc.types.TCBooleanType;
unmapped com.fujitsu.vdmj.tc.types.TCBracketType;
unmapped com.fujitsu.vdmj.tc.types.TCCharacterType;
unmapped com.fujitsu.vdmj.tc.types.TCClassType;
unmapped com.fujitsu.vdmj.tc.types.TCField;
unmapped com.fujitsu.vdmj.tc.types.TCFieldList;
unmapped com.fujitsu.vdmj.tc.types.TCFunctionType;
unmapped com.fujitsu.vdmj.tc.types.TCInMapType;
unmapped com.fujitsu.vdmj.tc.types.TCInvariantType;
unmapped com.fujitsu.vdmj.tc.types.TCMapType;
unmapped com.fujitsu.vdmj.tc.types.TCNamedType;
unmapped com.fujitsu.vdmj.tc.types.TCNaturalOneType;
unmapped com.fujitsu.vdmj.tc.types.TCNaturalType;
unmapped com.fujitsu.vdmj.tc.types.TCIntegerType;
unmapped com.fujitsu.vdmj.tc.types.TCNumericType;
unmapped com.fujitsu.vdmj.tc.types.TCOperationType;
unmapped com.fujitsu.vdmj.tc.types.TCOptionalType;
unmapped com.fujitsu.vdmj.tc.types.TCParameterType;
unmapped com.fujitsu.vdmj.tc.types.TCProductType;
unmapped com.fujitsu.vdmj.tc.types.TCQuoteType;
unmapped com.fujitsu.vdmj.tc.types.TCRationalType;
unmapped com.fujitsu.vdmj.tc.types.TCRealType;
unmapped com.fujitsu.vdmj.tc.types.TCRecordType;
unmapped com.fujitsu.vdmj.tc.types.TCSeq1Type;
unmapped com.fujitsu.vdmj.tc.types.TCSeqType;
unmapped com.fujitsu.vdmj.tc.types.TCSetType;
unmapped com.fujitsu.vdmj.tc.types.TCSet1Type;
unmapped com.fujitsu.vdmj.tc.types.TCTokenType;
unmapped com.fujitsu.vdmj.tc.types.TCTypeSet;
unmapped com.fujitsu.vdmj.tc.types.TCUndefinedType;
unmapped com.fujitsu.vdmj.tc.types.TCUnionType;
unmapped com.fujitsu.vdmj.tc.types.TCUnknownType;
unmapped com.fujitsu.vdmj.tc.types.TCUnresolvedType;
unmapped com.fujitsu.vdmj.tc.types.TCVoidReturnType;
unmapped com.fujitsu.vdmj.tc.types.TCVoidType;
# Java - usually unmappeds
unmapped java.lang.Boolean;
unmapped java.lang.String;
unmapped java.lang.Long;
unmapped java.lang.Integer;
unmapped com.fujitsu.vdmj.mapper.FileList;