j.vdmj.4.6.0-P.source-code.tc-in.mappings Maven / Gradle / Ivy
The newest version!
##########################################################################################
# The class mapping definition for the VDMJ Interpreter. See ClassMapper.
##########################################################################################
# initializers, called by ClassMapper.init()
init com.fujitsu.vdmj.in.annotations.INAnnotation.reset();
# definitions
package com.fujitsu.vdmj.tc.definitions to com.fujitsu.vdmj.in.definitions;
map TCDefinitionList{} to INDefinitionList(this);
map TCAccessSpecifier{isStatic, isAsync, access, isPure} to INAccessSpecifier(isStatic, isAsync, access, isPure);
map TCAssignmentDefinition{accessSpecifier, name, type, expression, expType} to INAssignmentDefinition(accessSpecifier, name, type, expression, expType);
map TCBUSClassDefinition{name, classtype, supernames, definitions} to INBUSClassDefinition(name, classtype, supernames, definitions);
map TCClassDefinition{annotations, name, classtype, supernames, definitions, superInheritedDefinitions, localInheritedDefinitions, superdefs, invariant, isAbstract} to INClassDefinition(annotations, name, classtype, supernames, definitions, superInheritedDefinitions, localInheritedDefinitions, superdefs, invariant, isAbstract);
map TCClassInvariantDefinition{name, expression} to INClassInvariantDefinition(name, expression);
map TCClassList{} to INClassList(this);
map TCCPUClassDefinition{name, classtype, supernames, definitions} to INCPUClassDefinition(name, classtype, supernames, definitions);
map TCDefinition{} to INDefinition();
map TCEqualsDefinition{location, pattern, typebind, bind, test, defType, defs} to INEqualsDefinition(location, pattern, typebind, bind, test, defType, defs);
map TCExplicitFunctionDefinition{annotations, accessSpecifier, name, typeParams, type, paramPatternList, body, precondition, postcondition, isTypeInvariant, measureName, measureDef, predef, postdef, classDefinition} to INExplicitFunctionDefinition(annotations, accessSpecifier, name, typeParams, type, paramPatternList, body, precondition, postcondition, isTypeInvariant, measureName, measureDef, predef, postdef, classDefinition);
map TCExplicitOperationDefinition{annotations, accessSpecifier, name, type, parameterPatterns, precondition, postcondition, body, isConstructor, predef, postdef, state, classDefinition} to INExplicitOperationDefinition(annotations, accessSpecifier, name, type, parameterPatterns, precondition, postcondition, body, isConstructor, predef, postdef, state, classDefinition);
map TCExternalDefinition{state, readOnly} to INExternalDefinition(state, readOnly);
map TCImplicitFunctionDefinition{annotations, accessSpecifier, name, typeParams, parameterPatterns, result, body, precondition, postcondition, measureExp, measureName, measureDef, predef, postdef, classDefinition} to INImplicitFunctionDefinition(annotations, accessSpecifier, name, typeParams, parameterPatterns, result, body, precondition, postcondition, measureExp, measureName, measureDef, predef, postdef, classDefinition);
map TCImplicitOperationDefinition{annotations, accessSpecifier, name, parameterPatterns, result, body, precondition, postcondition, errors, isConstructor, predef, postdef, state, classDefinition} to INImplicitOperationDefinition(annotations, accessSpecifier, name, parameterPatterns, result, body, precondition, postcondition, errors, isConstructor, predef, postdef, state, classDefinition);
map TCImportedDefinition{location, def} to INImportedDefinition(location, def);
map TCInheritedDefinition{name, accessSpecifier, superdef} to INInheritedDefinition(name, accessSpecifier, superdef);
map TCInstanceVariableDefinition{accessSpecifier, name, type, expression, expType} to INInstanceVariableDefinition(accessSpecifier, name, type, expression, expType);
map TCLocalDefinition{location, name, type, valueDefinition} to INLocalDefinition(location, name, type, valueDefinition);
map TCMultiBindListDefinition{location, bindings, defs} to INMultiBindListDefinition(location, bindings, defs);
map TCMutexSyncDefinition{annotations, location, operations} to INMutexSyncDefinition(annotations, location, operations);
map TCNamedTraceDefinition{annotations, location, name, terms, classDefinition} to INNamedTraceDefinition(annotations, location, name, terms, classDefinition);
map TCPerSyncDefinition{annotations, location, opname, guard} to INPerSyncDefinition(annotations, location, opname, guard);
map TCRenamedDefinition{name, def} to INRenamedDefinition(name, def);
map TCStateDefinition{name, fields, invPattern, invExpression, initPattern, initExpression, invdef, initdef, canBeExecuted} to INStateDefinition(name, fields, invPattern, invExpression, initPattern, initExpression, invdef, initdef, canBeExecuted);
map TCSystemDefinition{annotations, name, classtype, definitions} to INSystemDefinition(annotations, name, classtype, definitions);
map TCThreadDefinition{statement, operationDef} to INThreadDefinition(statement, operationDef);
map TCTypeDefinition{annotations, accessSpecifier, name, type, invPattern, invExpression, invdef, eqdef, orddef, mindef, maxdef} to INTypeDefinition(annotations, accessSpecifier, name, type, invPattern, invExpression, invdef, eqdef, orddef, mindef, maxdef);
map TCValueDefinition{annotations, accessSpecifier, name, pattern, type, exp} to INValueDefinition(annotations, accessSpecifier, name, pattern, type, exp);
map TCUntypedDefinition{location, name} to INUntypedDefinition(location, name);
map TCQualifiedDefinition{def, type} to INQualifiedDefinition(def, type);
# expressions
package com.fujitsu.vdmj.tc.expressions to com.fujitsu.vdmj.in.expressions;
map TCExpression{} to INExpression();
map TCExpressionList{} to INExpressionList(this);
map TCAbsoluteExpression{location, exp} to INAbsoluteExpression(location, exp);
map TCAndExpression{left, op, right} to INAndExpression(left, op, right);
map TCApplyExpression{root, args, type} to INApplyExpression(root, args, type);
map TCBinaryExpression{} to INBinaryExpression();
map TCBooleanBinaryExpression{} to INBooleanBinaryExpression();
map TCBooleanLiteralExpression{value} to INBooleanLiteralExpression(value);
map TCCardinalityExpression{location, exp} to INCardinalityExpression(location, exp);
map TCCaseAlternative{cexp, pattern, result} to INCaseAlternative(cexp, pattern, result);
map TCCaseAlternativeList{} to INCaseAlternativeList(this);
map TCCasesExpression{location, exp, cases, others} to INCasesExpression(location, exp, cases, others);
map TCCharLiteralExpression{value} to INCharLiteralExpression(value);
map TCCompExpression{left, op, right} to INCompExpression(left, op, right);
map TCDefExpression{location, localDefs, expression} to INDefExpression(location, localDefs, expression);
map TCDistConcatExpression{location, exp} to INDistConcatExpression(location, exp);
map TCDistIntersectExpression{location, exp} to INDistIntersectExpression(location, exp);
map TCDistMergeExpression{location, exp} to INDistMergeExpression(location, exp);
map TCDistUnionExpression{location, exp} to INDistUnionExpression(location, exp);
map TCDivExpression{left, op, right} to INDivExpression(left, op, right);
map TCDivideExpression{left, op, right} to INDivideExpression(left, op, right);
map TCDomainResByExpression{left, op, right} to INDomainResByExpression(left, op, right);
map TCDomainResToExpression{left, op, right} to INDomainResToExpression(left, op, right);
map TCElementsExpression{location, exp} to INElementsExpression(location, exp);
map TCElseIfExpression{location, elseIfExp, thenExp} to INElseIfExpression(location, elseIfExp, thenExp);
map TCElseIfExpressionList{} to INElseIfExpressionList(this);
map TCEqualsExpression{left, op, right} to INEqualsExpression(left, op, right);
map TCEquivalentExpression{left, op, right} to INEquivalentExpression(left, op, right);
map TCExists1Expression{location, bind, predicate} to INExists1Expression(location, bind, predicate);
map TCExistsExpression{location, bindList, predicate} to INExistsExpression(location, bindList, predicate);
map TCFieldExpression{object, field, memberName} to INFieldExpression(object, field, memberName);
map TCFieldNumberExpression{tuple, field} to INFieldNumberExpression(tuple, field);
map TCFloorExpression{location, exp} to INFloorExpression(location, exp);
map TCForAllExpression{location, bindList, predicate} to INForAllExpression(location, bindList, predicate);
map TCFuncInstantiationExpression{function, actualTypes, expdef, impdef} to INFuncInstantiationExpression(function, actualTypes, expdef, impdef);
map TCGreaterEqualExpression{left, op, right} to INGreaterEqualExpression(left, op, right);
map TCGreaterExpression{left, op, right} to INGreaterExpression(left, op, right);
map TCHeadExpression{location, exp} to INHeadExpression(location, exp);
map TCHistoryExpression{location, hop, opnames} to INHistoryExpression(location, hop, opnames);
map TCIfExpression{location, ifExp, thenExp, elseList, elseExp} to INIfExpression(location, ifExp, thenExp, elseList, elseExp);
map TCImpliesExpression{left, op, right} to INImpliesExpression(left, op, right);
map TCIndicesExpression{location, exp} to INIndicesExpression(location, exp);
map TCInSetExpression{left, op, right} to INInSetExpression(left, op, right);
map TCIntegerLiteralExpression{value} to INIntegerLiteralExpression(value);
map TCIotaExpression{location, bind, predicate} to INIotaExpression(location, bind, predicate);
map TCIsExpression{location, typename, basictype, test, typedef} to INIsExpression(location, basictype, typename, test, typedef);
map TCIsOfBaseClassExpression{location, baseclass, exp} to INIsOfBaseClassExpression(location, baseclass, exp);
map TCIsOfClassExpression{location, classname, exp} to INIsOfClassExpression(location, classname, exp);
map TCLambdaExpression{location, type, paramPatterns, expression} to INLambdaExpression(location, type, paramPatterns, expression);
map TCLenExpression{location, exp} to INLenExpression(location, exp);
map TCLessEqualExpression{left, op, right} to INLessEqualExpression(left, op, right);
map TCLessExpression{left, op, right} to INLessExpression(left, op, right);
map TCLetBeStExpression{location, bind, suchThat, value, def} to INLetBeStExpression(location, bind, suchThat, value, def);
map TCLetDefExpression{location, localDefs, expression} to INLetDefExpression(location, localDefs, expression);
map TCMapCompExpression{location, first, bindings, predicate} to INMapCompExpression(location, first, bindings, predicate);
map TCMapDomainExpression{location, exp} to INMapDomainExpression(location, exp);
map TCMapEnumExpression{location, members} to INMapEnumExpression(location, members);
map TCMapExpression{} to INMapExpression();
map TCMapInverseExpression{location, exp} to INMapInverseExpression(location, exp);
map TCMapletExpression{left, right} to INMapletExpression(left, right);
map TCMapletExpressionList{} to INMapletExpressionList(this);
map TCMapRangeExpression{location, exp} to INMapRangeExpression(location, exp);
map TCMapUnionExpression{left, op, right} to INMapUnionExpression(left, op, right);
map TCMkBasicExpression{type, arg} to INMkBasicExpression(type, arg);
map TCMkTypeExpression{location, recordType, args} to INMkTypeExpression(location, recordType, args);
map TCModExpression{left, op, right} to INModExpression(left, op, right);
map TCMuExpression{location, record, modifiers} to INMuExpression(location, record, modifiers);
map TCNarrowExpression{location, basictype, typename, typedef, test} to INNarrowExpression(location, basictype, typename, typedef, test);
map TCNewExpression{location, classname, args, classdef, ctordef} to INNewExpression(location, classname, args, classdef, ctordef);
map TCNilExpression{location} to INNilExpression(location);
map TCNotEqualExpression{left, op, right} to INNotEqualExpression(left, op, right);
map TCNotExpression{location, exp} to INNotExpression(location, exp);
map TCNotInSetExpression{left, op, right} to INNotInSetExpression(left, op, right);
map TCNotYetSpecifiedExpression{location} to INNotYetSpecifiedExpression(location);
map TCNumericBinaryExpression{} to INNumericBinaryExpression();
map TCOrExpression{left, op, right} to INOrExpression(left, op, right);
map TCPlusExpression{left, op, right} to INPlusExpression(left, op, right);
map TCPlusPlusExpression{left, op, right} to INPlusPlusExpression(left, op, right);
map TCPostOpExpression{opname, preexpression, postexpression, errors, state} to INPostOpExpression(opname, preexpression, postexpression, errors, state);
map TCPowerSetExpression{location, exp} to INPowerSetExpression(location, exp);
map TCPreExpression{location, function, args} to INPreExpression(location, function, args);
map TCPreOpExpression{opname, expression, errors, state} to INPreOpExpression(opname, expression, errors, state);
map TCProperSubsetExpression{left, op, right} to INProperSubsetExpression(left, op, right);
map TCQuoteLiteralExpression{location, type} to INQuoteLiteralExpression(location, type);
map TCRangeResByExpression{left, op, right} to INRangeResByExpression(left, op, right);
map TCRangeResToExpression{left, op, right} to INRangeResToExpression(left, op, right);
map TCRealLiteralExpression{value} to INRealLiteralExpression(value);
map TCRecordModifier{tag, value} to INRecordModifier(tag, value);
map TCRecordModifierList{} to INRecordModifierList(this);
map TCRemExpression{left, op, right} to INRemExpression(left, op, right);
map TCReverseExpression{location, exp} to INReverseExpression(location, exp);
map TCSameBaseClassExpression{location, left, right} to INSameBaseClassExpression(location, left, right);
map TCSameClassExpression{location, left, right} to INSameClassExpression(location, left, right);
map TCSelfExpression{location} to INSelfExpression(location);
map TCSeqCompExpression{location, first, bind, predicate} to INSeqCompExpression(location, first, bind, predicate);
map TCSeqConcatExpression{left, op, right} to INSeqConcatExpression(left, op, right);
map TCSeqEnumExpression{location, members} to INSeqEnumExpression(location, members);
map TCSeqExpression{} to INSeqExpression();
map TCSetCompExpression{location, first, bindings, predicate} to INSetCompExpression(location, first, bindings, predicate);
map TCSetDifferenceExpression{left, op, right} to INSetDifferenceExpression(left, op, right);
map TCSetEnumExpression{location, members} to INSetEnumExpression(location, members);
map TCSetExpression{} to INSetExpression();
map TCSetIntersectExpression{left, op, right} to INSetIntersectExpression(left, op, right);
map TCSetRangeExpression{location, first, last} to INSetRangeExpression(location, first, last);
map TCSetUnionExpression{left, op, right} to INSetUnionExpression(left, op, right);
map TCStarStarExpression{left, op, right} to INStarStarExpression(left, op, right);
map TCStateInitExpression{location, state} to INStateInitExpression(location, state);
map TCStringLiteralExpression{value} to INStringLiteralExpression(value);
map TCSubclassResponsibilityExpression{location} to INSubclassResponsibilityExpression(location);
map TCSubseqExpression{seq, from, to} to INSubseqExpression(seq, from, to);
map TCSubsetExpression{left, op, right} to INSubsetExpression(left, op, right);
map TCSubtractExpression{left, op, right} to INSubtractExpression(left, op, right);
map TCTailExpression{location, exp} to INTailExpression(location, exp);
map TCThreadIdExpression{location} to INThreadIdExpression(location);
map TCTimeExpression{location} to INTimeExpression(location);
map TCTimesExpression{left, op, right} to INTimesExpression(left, op, right);
map TCTupleExpression{location, args} to INTupleExpression(location, args);
map TCUnaryExpression{} to INUnaryExpression();
map TCUnaryMinusExpression{location, exp} to INUnaryMinusExpression(location, exp);
map TCUnaryPlusExpression{location, exp} to INUnaryPlusExpression(location, exp);
map TCUndefinedExpression{location} to INUndefinedExpression(location);
map TCVariableExpression{name} to INVariableExpression(name);
# annotations
package com.fujitsu.vdmj.tc.annotations to com.fujitsu.vdmj.in.annotations;
map TCAnnotatedExpression{location, annotation, expression} to INAnnotatedExpression(location, annotation, expression);
map TCAnnotatedStatement{location, annotation, statement} to INAnnotatedStatement(location, annotation, statement);
map TCAnnotation{} to INAnnotation();
map TCAnnotationList{} to INAnnotationList(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.in.modules;
map TCModuleList{} to INModuleList(this);
map TCModule{name, defs, importdefs, files} to INModule(name, defs, importdefs, files);
# patterns
package com.fujitsu.vdmj.tc.patterns to com.fujitsu.vdmj.in.patterns;
map TCBind{} to INBind();
map TCBooleanPattern{value} to INBooleanPattern(value);
map TCCharacterPattern{value} to INCharacterPattern(value);
map TCConcatenationPattern{left, location, right} to INConcatenationPattern(left, location, right);
map TCExpressionPattern{exp} to INExpressionPattern(exp);
map TCIdentifierPattern{name} to INIdentifierPattern(name);
map TCIgnorePattern{location} to INIgnorePattern(location);
map TCIntegerPattern{value} to INIntegerPattern(value);
map TCMapletPattern{from, to} to INMapletPattern(from, to);
map TCMapletPatternList{} to INMapletPatternList(this);
map TCMapPattern{location, maplets} to INMapPattern(location, maplets);
map TCMapUnionPattern{left, location, right} to INMapUnionPattern(left, location, right);
map TCMultipleBind{} to INMultipleBind();
map TCMultipleBindList{} to INMultipleBindList(this);
map TCMultipleSeqBind{plist, sequence} to INMultipleSeqBind(plist, sequence);
map TCMultipleSetBind{plist, set} to INMultipleSetBind(plist, set);
map TCMultipleTypeBind{plist, type} to INMultipleTypeBind(plist, type);
map TCNamePatternPair{name, pattern} to INNamePatternPair(name, pattern);
map TCNamePatternPairList{} to INNamePatternPairList(this);
map TCNilPattern{location} to INNilPattern(location);
map TCObjectPattern{location, classname, fieldlist, type} to INObjectPattern(location, classname, fieldlist, type);
map TCPattern{} to INPattern();
map TCPatternList{} to INPatternList(this);
map TCPatternListList{} to INPatternListList(this);
map TCPatternBind{location, pattern, bind} to INPatternBind(location, pattern, bind);
map TCQuotePattern{value} to INQuotePattern(value);
map TCRealPattern{value} to INRealPattern(value);
map TCRecordPattern{typename, plist, type} to INRecordPattern(typename, plist, type);
map TCSeqBind{pattern, sequence} to INSeqBind(pattern, sequence);
map TCSeqPattern{location, plist} to INSeqPattern(location, plist);
map TCSetBind{pattern, set} to INSetBind(pattern, set);
map TCSetPattern{location, plist} to INSetPattern(location, plist);
map TCStringPattern{value} to INStringPattern(value);
map TCTuplePattern{location, plist} to INTuplePattern(location, plist);
map TCTypeBind{pattern, type} to INTypeBind(pattern, type);
map TCTypeBindList{} to INTypeBindList(this);
map TCUnionPattern{left, location, right} to INUnionPattern(left, location, right);
# statements
package com.fujitsu.vdmj.tc.statements to com.fujitsu.vdmj.in.statements;
map TCAlwaysStatement{location, always, body} to INAlwaysStatement(location, always, body);
map TCAssignmentStatement{location, target, exp, targetType} to INAssignmentStatement(location, target, exp, targetType);
map TCAssignmentStatementList{} to INAssignmentStatementList(this);
map TCAtomicStatement{location, assignments} to INAtomicStatement(location, assignments);
map TCBlockStatement{location, assignmentDefs, statements} to INBlockStatement(location, assignmentDefs, statements);
map TCCallObjectStatement{designator, classname, fieldname, args, field} to INCallObjectStatement(designator, classname, fieldname, args, field);
map TCCallStatement{name, args} to INCallStatement(name, args);
map TCCasesStatement{location, exp, cases, others} to INCasesStatement(location, exp, cases, others);
map TCCaseStmtAlternative{pattern, statement} to INCaseStmtAlternative(pattern, statement);
map TCCaseStmtAlternativeList{} to INCaseStmtAlternativeList(this);
map TCClassInvariantStatement{name, invdefs} to INClassInvariantStatement(name, invdefs);
map TCCyclesStatement{location, cycles, statement} to INCyclesStatement(location, cycles, statement);
map TCDefStatement{location, equalsDefs, statement} to INDefStatement(location, equalsDefs, statement);
map TCDurationStatement{location, duration, statement} to INDurationStatement(location, duration, statement);
map TCElseIfStatement{location, elseIfExp, thenStmt} to INElseIfStatement(location, elseIfExp, thenStmt);
map TCElseIfStatementList{} to INElseIfStatementList(this);
map TCErrorCase{name, left, right} to INErrorCase(name, left, right);
map TCErrorCaseList{} to INErrorCaseList(this);
map TCErrorStatement{location} to INErrorStatement(location);
map TCExitStatement{location, expression} to INExitStatement(location, expression);
map TCFieldDesignator{object, field, objectfield} to INFieldDesignator(object, field, objectfield);
map TCForAllStatement{location, pattern, set, statement} to INForAllStatement(location, pattern, set, statement);
map TCForIndexStatement{location, var, from, to, by, statement} to INForIndexStatement(location, var, from, to, by, statement);
map TCForPatternBindStatement{location, patternBind, reverse, exp, statement} to INForPatternBindStatement(location, patternBind, reverse, exp, statement);
map TCIdentifierDesignator{name} to INIdentifierDesignator(name);
map TCIfStatement{location, ifExp, thenStmt, elseList, elseStmt} to INIfStatement(location, ifExp, thenStmt, elseList, elseStmt);
map TCLetBeStStatement{location, bind, suchThat, statement, def} to INLetBeStStatement(location, bind, suchThat, statement, def);
map TCLetDefStatement{location, localDefs, statement} to INLetDefStatement(location, localDefs, statement);
map TCMapSeqDesignator{mapseq, exp, mapType, seqType} to INMapSeqDesignator(mapseq, exp, mapType, seqType);
map TCNonDeterministicStatement{location, statements} to INNonDeterministicStatement(location, statements);
map TCNotYetSpecifiedStatement{location} to INNotYetSpecifiedStatement(location);
map TCObjectApplyDesignator{object, args} to INObjectApplyDesignator(object, args);
map TCObjectDesignator{} to INObjectDesignator();
map TCObjectFieldDesignator{object, classname, fieldname, field} to INObjectFieldDesignator(object, classname, fieldname, field);
map TCObjectIdentifierDesignator{name} to INObjectIdentifierDesignator(name);
map TCObjectNewDesignator{expression} to INObjectNewDesignator(expression);
map TCObjectSelfDesignator{location} to INObjectSelfDesignator(location);
map TCPeriodicStatement{opname, args} to INPeriodicStatement(opname, args);
map TCReturnStatement{location, expression} to INReturnStatement(location, expression);
map TCSimpleBlockStatement{} to INSimpleBlockStatement();
map TCSkipStatement{location} to INSkipStatement(location);
map TCSpecificationStatement{location, precondition, postcondition, errors} to INSpecificationStatement(location, precondition, postcondition, errors);
map TCSporadicStatement{opname, args} to INSporadicStatement(opname, args);
map TCStartStatement{location, objects} to INStartStatement(location, objects);
map TCStateDesignator{} to INStateDesignator();
map TCStatement{} to INStatement();
map TCStatementList{} to INStatementList(this);
map TCStopStatement{location, objects} to INStopStatement(location, objects);
map TCSubclassResponsibilityStatement{location} to INSubclassResponsibilityStatement(location);
map TCTixeStatement{location, traps, body} to INTixeStatement(location, traps, body);
map TCTixeStmtAlternative{patternBind, statement} to INTixeStmtAlternative(patternBind, statement);
map TCTixeStmtAlternativeList{} to INTixeStmtAlternativeList(this);
map TCTrapStatement{location, patternBind, with, body} to INTrapStatement(location, patternBind, with, body);
map TCWhileStatement{location, exp, statement} to INWhileStatement(location, exp, statement);
# traces
package com.fujitsu.vdmj.tc.traces to com.fujitsu.vdmj.in.traces;
map TCTraceApplyExpression{callStatement} to INTraceApplyExpression(callStatement);
map TCTraceBracketedExpression{location, terms} to INTraceBracketedExpression(location, terms);
map TCTraceConcurrentExpression{location, defs} to INTraceConcurrentExpression(location, defs);
map TCTraceCoreDefinition{} to INTraceCoreDefinition();
map TCTraceDefinition{} to INTraceDefinition();
map TCTraceDefinitionList{} to INTraceDefinitionList(this);
map TCTraceDefinitionTerm{} to INTraceDefinitionTerm(this);
map TCTraceDefinitionTermList{} to INTraceDefinitionTermList(this);
map TCTraceLetBeStBinding{location, bind, stexp, body, def} to INTraceLetBeStBinding(location, bind, stexp, body, def);
map TCTraceLetDefBinding{location, localDefs, body} to INTraceLetDefBinding(location, localDefs, body);
map TCTraceRepeatDefinition{location, core, to, from} to INTraceRepeatDefinition(location, core, from, to);
# types
package com.fujitsu.vdmj.tc.types to com.fujitsu.vdmj.in.types;
map TCPatternListTypePairList{} to INPatternListTypePairList(this);
map TCPatternListTypePair{patterns, type} to INPatternListTypePair(patterns, type);
map TCPatternTypePair{pattern, type} to INPatternTypePair(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 com.fujitsu.vdmj.mapper.FileList;