• Home
• dk.au.ece.vdmj
• vdmj
• 4.6.0-P
• source code

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

j.vdmj.4.6.0-P.source-code.ast-tc.mappings Maven / Gradle / Ivy

##########################################################################################
# The class mapping definition for the VDMJ Type Checker. See ClassMapper.
##########################################################################################

# initializers, called by ClassMapper.init()
init com.fujitsu.vdmj.tc.annotations.TCAnnotation.reset();

# definitions
package com.fujitsu.vdmj.ast.definitions to com.fujitsu.vdmj.tc.definitions;
map ASTDefinitionList{} to TCDefinitionList(this);
map ASTAccessSpecifier{isStatic, isAsync, access, isPure} to TCAccessSpecifier(isStatic, isAsync, access, isPure);
map ASTAssignmentDefinition{accessSpecifier, name, type, expression, comments} to TCAssignmentDefinition(accessSpecifier, name, type, expression) set comments;
map ASTBUSClassDefinition{name, supernames, definitions, comments} to TCBUSClassDefinition(name, supernames, definitions) set comments;
map ASTClassDefinition{annotations, name, supernames, definitions, comments} to TCClassDefinition(annotations, name, supernames, definitions) set comments;
map ASTClassInvariantDefinition{accessSpecifier, name, expression, comments} to TCClassInvariantDefinition(accessSpecifier, name, expression) set comments;
map ASTClassList{} to TCClassList(this);
map ASTCPUClassDefinition{name, supernames, definitions, comments} to TCCPUClassDefinition(name, supernames, definitions) set comments;
map ASTDefinition{comments} to TCDefinition() set comments;
map ASTEqualsDefinition{location, pattern, typebind, bind, test, comments} to TCEqualsDefinition(location, pattern, typebind, bind, test) set comments;
map ASTExplicitFunctionDefinition{annotations, accessSpecifier, name, typeParams, type, paramPatternList, body, precondition, postcondition, isTypeInvariant, measure, comments} to TCExplicitFunctionDefinition(annotations, accessSpecifier, name, typeParams, type, paramPatternList, body, precondition, postcondition, isTypeInvariant, measure) set comments;
map ASTExplicitOperationDefinition{annotations, accessSpecifier, name, type, parameterPatterns, precondition, postcondition, body, comments} to TCExplicitOperationDefinition(annotations, accessSpecifier, name, type, parameterPatterns, precondition, postcondition, body) set comments;
map ASTExternalDefinition{state, readOnly, comments} to TCExternalDefinition(state, readOnly) set comments;
map ASTImplicitFunctionDefinition{annotations, accessSpecifier, name, typeParams, parameterPatterns, result, body, precondition, postcondition, measureExp, comments} to TCImplicitFunctionDefinition(annotations, accessSpecifier, name, typeParams, parameterPatterns, result, body, precondition, postcondition, measureExp) set comments;
map ASTImplicitOperationDefinition{annotations, accessSpecifier, name, parameterPatterns, result, body, externals, precondition, postcondition, errors, comments} to TCImplicitOperationDefinition(annotations, accessSpecifier, name, parameterPatterns, result, body, externals, precondition, postcondition, errors) set comments;
map ASTImportedDefinition{location, def, comments} to TCImportedDefinition(location, def) set comments;
map ASTInheritedDefinition{accessSpecifier, name, superdef, comments} to TCInheritedDefinition(accessSpecifier, name, superdef) set comments;
map ASTInstanceVariableDefinition{annotations, accessSpecifier, name, type, expression, comments} to TCInstanceVariableDefinition(annotations, accessSpecifier, name, type, expression) set comments;
map ASTMultiBindListDefinition{location, bindings, comments} to TCMultiBindListDefinition(location, bindings) set comments;
map ASTMutexSyncDefinition{annotations, location, operations, comments} to TCMutexSyncDefinition(annotations, location, operations) set comments;
map ASTNamedTraceDefinition{annotations, location, name, terms, comments} to TCNamedTraceDefinition(annotations, location, name, terms) set comments;
map ASTPerSyncDefinition{annotations, location, opname, guard, comments} to TCPerSyncDefinition(annotations, location, opname, guard) set comments;
map ASTRenamedDefinition{name, def, comments} to TCRenamedDefinition(name, def) set comments;
map ASTStateDefinition{name, fields, invPattern, invExpression, initPattern, initExpression, comments} to TCStateDefinition(name, fields, invPattern, invExpression, initPattern, initExpression) set comments;
map ASTSystemDefinition{annotations, name, definitions, comments} to TCSystemDefinition(annotations, name, definitions) set comments;
map ASTThreadDefinition{statement, comments} to TCThreadDefinition(statement) set comments;
map ASTTypeDefinition{annotations, accessSpecifier, name, type, invPattern, invExpression, eqPattern1, eqPattern2, eqExpression, ordPattern1, ordPattern2, ordExpression, comments} to TCTypeDefinition(annotations, accessSpecifier, name, type, invPattern, invExpression, eqPattern1, eqPattern2, eqExpression, ordPattern1, ordPattern2, ordExpression) set comments;
map ASTUntypedDefinition{location, name, comments} to TCUntypedDefinition(location, name) set comments;
map ASTValueDefinition{scope, annotations, accessSpecifier, pattern, type, exp, comments} to TCValueDefinition(scope, annotations, accessSpecifier, pattern, type, exp) set comments;

# expressions
package com.fujitsu.vdmj.ast.expressions to com.fujitsu.vdmj.tc.expressions;
map ASTExpression{comments} to TCExpression() set comments;
map ASTExpressionList{} to TCExpressionList(this);
map ASTAbsoluteExpression{location, exp, comments} to TCAbsoluteExpression(location, exp) set comments;
map ASTAndExpression{left, op, right, comments} to TCAndExpression(left, op, right) set comments;
map ASTApplyExpression{root, args, comments} to TCApplyExpression(root, args) set comments;
map ASTBinaryExpression{} to TCBinaryExpression();
map ASTBooleanBinaryExpression{} to TCBooleanBinaryExpression();
map ASTBooleanLiteralExpression{value, comments} to TCBooleanLiteralExpression(value) set comments;
map ASTCardinalityExpression{location, exp, comments} to TCCardinalityExpression(location, exp) set comments;
map ASTCaseAlternative{cexp, pattern, result} to TCCaseAlternative(cexp, pattern, result);
map ASTCaseAlternativeList{} to TCCaseAlternativeList(this);
map ASTCasesExpression{location, exp, cases, others, comments} to TCCasesExpression(location, exp, cases, others) set comments;
map ASTCharLiteralExpression{value, comments} to TCCharLiteralExpression(value) set comments;
map ASTCompExpression{left, op, right, comments} to TCCompExpression(left, op, right) set comments;
map ASTDefExpression{location, localDefs, expression, comments} to TCDefExpression(location, localDefs, expression) set comments;
map ASTDistConcatExpression{location, exp, comments} to TCDistConcatExpression(location, exp) set comments;
map ASTDistIntersectExpression{location, exp, comments} to TCDistIntersectExpression(location, exp) set comments;
map ASTDistMergeExpression{location, exp, comments} to TCDistMergeExpression(location, exp) set comments;
map ASTDistUnionExpression{location, exp, comments} to TCDistUnionExpression(location, exp) set comments;
map ASTDivExpression{left, op, right, comments} to TCDivExpression(left, op, right) set comments;
map ASTDivideExpression{left, op, right, comments} to TCDivideExpression(left, op, right) set comments;
map ASTDomainResByExpression{left, op, right, comments} to TCDomainResByExpression(left, op, right) set comments;
map ASTDomainResToExpression{left, op, right, comments} to TCDomainResToExpression(left, op, right) set comments;
map ASTElementsExpression{location, exp, comments} to TCElementsExpression(location, exp) set comments;
map ASTElseIfExpression{location, elseIfExp, thenExp, comments} to TCElseIfExpression(location, elseIfExp, thenExp) set comments;
map ASTElseIfExpressionList{} to TCElseIfExpressionList(this);
map ASTEqualsExpression{left, op, right, comments} to TCEqualsExpression(left, op, right) set comments;
map ASTEquivalentExpression{left, op, right, comments} to TCEquivalentExpression(left, op, right) set comments;
map ASTExists1Expression{location, bind, predicate, comments} to TCExists1Expression(location, bind, predicate) set comments;
map ASTExistsExpression{location, bindList, predicate, comments} to TCExistsExpression(location, bindList, predicate) set comments;
map ASTFieldExpression{object, field, memberName, comments} to TCFieldExpression(object, field, memberName) set comments;
map ASTFieldNumberExpression{tuple, field, comments} to TCFieldNumberExpression(tuple, field) set comments;
map ASTFloorExpression{location, exp, comments} to TCFloorExpression(location, exp) set comments;
map ASTForAllExpression{location, bindList, predicate, comments} to TCForAllExpression(location, bindList, predicate) set comments;
map ASTFuncInstantiationExpression{function, actualTypes, comments} to TCFuncInstantiationExpression(function, actualTypes) set comments;
map ASTGreaterEqualExpression{left, op, right, comments} to TCGreaterEqualExpression(left, op, right) set comments;
map ASTGreaterExpression{left, op, right, comments} to TCGreaterExpression(left, op, right) set comments;
map ASTHeadExpression{location, exp, comments} to TCHeadExpression(location, exp) set comments;
map ASTHistoryExpression{location, hop, opnames, comments} to TCHistoryExpression(location, hop, opnames) set comments;
map ASTIfExpression{location, ifExp, thenExp, elseList, elseExp, comments} to TCIfExpression(location, ifExp, thenExp, elseList, elseExp) set comments;
map ASTImpliesExpression{left, op, right, comments} to TCImpliesExpression(left, op, right) set comments;
map ASTIndicesExpression{location, exp, comments} to TCIndicesExpression(location, exp) set comments;
map ASTInSetExpression{left, op, right, comments} to TCInSetExpression(left, op, right) set comments;
map ASTIntegerLiteralExpression{value, comments} to TCIntegerLiteralExpression(value) set comments;
map ASTIotaExpression{location, bind, predicate, comments} to TCIotaExpression(location, bind, predicate) set comments;
map ASTIsExpression{location, typename, basictype, test, comments} to TCIsExpression(location, typename, basictype, test) set comments;
map ASTIsOfBaseClassExpression{location, baseclass, exp, comments} to TCIsOfBaseClassExpression(location, baseclass, exp) set comments;
map ASTIsOfClassExpression{location, classname, exp, comments} to TCIsOfClassExpression(location, classname, exp) set comments;
map ASTLambdaExpression{location, bindList, expression, comments} to TCLambdaExpression(location, bindList, expression) set comments;
map ASTLenExpression{location, exp, comments} to TCLenExpression(location, exp) set comments;
map ASTLessEqualExpression{left, op, right, comments} to TCLessEqualExpression(left, op, right) set comments;
map ASTLessExpression{left, op, right, comments} to TCLessExpression(left, op, right) set comments;
map ASTLetBeStExpression{location, bind, suchThat, value, comments} to TCLetBeStExpression(location, bind, suchThat, value) set comments;
map ASTLetDefExpression{location, localDefs, expression, comments} to TCLetDefExpression(location, localDefs, expression) set comments;
map ASTMapCompExpression{location, first, bindings, predicate, comments} to TCMapCompExpression(location, first, bindings, predicate) set comments;
map ASTMapDomainExpression{location, exp, comments} to TCMapDomainExpression(location, exp) set comments;
map ASTMapEnumExpression{location, members, comments} to TCMapEnumExpression(location, members) set comments;
map ASTMapExpression{} to TCMapExpression();
map ASTMapInverseExpression{location, exp, comments} to TCMapInverseExpression(location, exp) set comments;
map ASTMapletExpression{left, right} to TCMapletExpression(left, right);
map ASTMapletExpressionList{} to TCMapletExpressionList(this);
map ASTMapRangeExpression{location, exp, comments} to TCMapRangeExpression(location, exp) set comments;
map ASTMapUnionExpression{left, op, right, comments} to TCMapUnionExpression(left, op, right) set comments;
map ASTMkBasicExpression{type, arg, comments} to TCMkBasicExpression(type, arg) set comments;
map ASTMkTypeExpression{typename, args, maximal, comments} to TCMkTypeExpression(typename, args, maximal) set comments;
map ASTModExpression{left, op, right, comments} to TCModExpression(left, op, right) set comments;
map ASTMuExpression{location, record, modifiers, comments} to TCMuExpression(location, record, modifiers) set comments;
map ASTNarrowExpression{location, typename, basictype, test, comments} to TCNarrowExpression(location, typename, basictype, test) set comments;
map ASTNewExpression{location, classname, args, comments} to TCNewExpression(location, classname, args) set comments;
map ASTNilExpression{location, comments} to TCNilExpression(location) set comments;
map ASTNotEqualExpression{left, op, right, comments} to TCNotEqualExpression(left, op, right) set comments;
map ASTNotExpression{location, exp, comments} to TCNotExpression(location, exp) set comments;
map ASTNotInSetExpression{left, op, right, comments} to TCNotInSetExpression(left, op, right) set comments;
map ASTNotYetSpecifiedExpression{location, comments} to TCNotYetSpecifiedExpression(location) set comments;
map ASTNumericBinaryExpression{} to TCNumericBinaryExpression();
map ASTOrExpression{left, op, right, comments} to TCOrExpression(left, op, right) set comments;
map ASTPlusExpression{left, op, right, comments} to TCPlusExpression(left, op, right) set comments;
map ASTPlusPlusExpression{left, op, right, comments} to TCPlusPlusExpression(left, op, right) set comments;
map ASTPostOpExpression{opname, preexpression, postexpression, errors, state, comments} to TCPostOpExpression(opname, preexpression, postexpression, errors, state) set comments;
map ASTPowerSetExpression{location, exp, comments} to TCPowerSetExpression(location, exp) set comments;
map ASTPreExpression{location, function, args, comments} to TCPreExpression(location, function, args) set comments;
map ASTPreOpExpression{opname, expression, errors, state, comments} to TCPreOpExpression(opname, expression, errors, state) set comments;
map ASTProperSubsetExpression{left, op, right, comments} to TCProperSubsetExpression(left, op, right) set comments;
map ASTQuoteLiteralExpression{location, type, comments} to TCQuoteLiteralExpression(location, type) set comments;
map ASTRangeResByExpression{left, op, right, comments} to TCRangeResByExpression(left, op, right) set comments;
map ASTRangeResToExpression{left, op, right, comments} to TCRangeResToExpression(left, op, right) set comments;
map ASTRealLiteralExpression{value, comments} to TCRealLiteralExpression(value) set comments;
map ASTRecordModifier{tag, value} to TCRecordModifier(tag, value);
map ASTRecordModifierList{} to TCRecordModifierList(this);
map ASTRemExpression{left, op, right, comments} to TCRemExpression(left, op, right) set comments;
map ASTReverseExpression{location, exp, comments} to TCReverseExpression(location, exp) set comments;
map ASTSameBaseClassExpression{location, left, right, comments} to TCSameBaseClassExpression(location, left, right) set comments;
map ASTSameClassExpression{location, left, right, comments} to TCSameClassExpression(location, left, right) set comments;
map ASTSelfExpression{location, comments} to TCSelfExpression(location) set comments;
map ASTSeqCompExpression{location, first, bind, predicate, comments} to TCSeqCompExpression(location, first, bind, predicate) set comments;
map ASTSeqConcatExpression{left, op, right, comments} to TCSeqConcatExpression(left, op, right) set comments;
map ASTSeqEnumExpression{location, members, comments} to TCSeqEnumExpression(location, members) set comments;
map ASTSeqExpression{} to TCSeqExpression();
map ASTSetCompExpression{location, first, bindings, predicate, comments} to TCSetCompExpression(location, first, bindings, predicate) set comments;
map ASTSetDifferenceExpression{left, op, right, comments} to TCSetDifferenceExpression(left, op, right) set comments;
map ASTSetEnumExpression{location, members, comments} to TCSetEnumExpression(location, members) set comments;
map ASTSetExpression{} to TCSetExpression();
map ASTSetIntersectExpression{left, op, right, comments} to TCSetIntersectExpression(left, op, right) set comments;
map ASTSetRangeExpression{location, first, last, comments} to TCSetRangeExpression(location, first, last) set comments;
map ASTSetUnionExpression{left, op, right, comments} to TCSetUnionExpression(left, op, right) set comments;
map ASTStarStarExpression{left, op, right, comments} to TCStarStarExpression(left, op, right) set comments;
map ASTStateInitExpression{state, comments} to TCStateInitExpression(state) set comments;
map ASTStringLiteralExpression{value, comments} to TCStringLiteralExpression(value) set comments;
map ASTSubclassResponsibilityExpression{location, comments} to TCSubclassResponsibilityExpression(location) set comments;
map ASTSubseqExpression{seq, from, to, comments} to TCSubseqExpression(seq, from, to) set comments;
map ASTSubsetExpression{left, op, right, comments} to TCSubsetExpression(left, op, right) set comments;
map ASTSubtractExpression{left, op, right, comments} to TCSubtractExpression(left, op, right) set comments;
map ASTTailExpression{location, exp, comments} to TCTailExpression(location, exp) set comments;
map ASTThreadIdExpression{location, comments} to TCThreadIdExpression(location) set comments;
map ASTTimeExpression{location, comments} to TCTimeExpression(location) set comments;
map ASTTimesExpression{left, op, right, comments} to TCTimesExpression(left, op, right) set comments;
map ASTTupleExpression{location, args, comments} to TCTupleExpression(location, args) set comments;
map ASTUnaryExpression{} to TCUnaryExpression();
map ASTUnaryMinusExpression{location, exp, comments} to TCUnaryMinusExpression(location, exp) set comments;
map ASTUnaryPlusExpression{location, exp, comments} to TCUnaryPlusExpression(location, exp) set comments;
map ASTUndefinedExpression{location, comments} to TCUndefinedExpression(location) set comments;
map ASTVariableExpression{location, name, original, comments} to TCVariableExpression(location, name, original) set comments;

# annotations
package com.fujitsu.vdmj.ast.annotations to com.fujitsu.vdmj.tc.annotations;
map ASTAnnotatedExpression{location, annotation, expression, comments} to TCAnnotatedExpression(location, annotation, expression) set comments;
map ASTAnnotatedStatement{location, annotation, statement, comments} to TCAnnotatedStatement(location, annotation, statement) set comments;
map ASTAnnotation{} to TCAnnotation();
map ASTAnnotationList{} to TCAnnotationList(this);

# lex
package com.fujitsu.vdmj.ast.lex to com.fujitsu.vdmj.tc.lex;
map LexNameToken{} to TCNameToken(this);
map LexNameList{} to TCNameList(this);
map LexIdentifierToken{} to TCIdentifierToken(this);
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.ast.lex.LexComment;
unmapped com.fujitsu.vdmj.ast.lex.LexCommentList;
unmapped com.fujitsu.vdmj.lex.LexLocation;
unmapped com.fujitsu.vdmj.lex.Token;

# modules
package com.fujitsu.vdmj.ast.modules to com.fujitsu.vdmj.tc.modules;
map ASTModuleList{} to TCModuleList(this);
map ASTExportList{} to TCExportList(this);
map ASTImportList{} to TCImportList(this);
map ASTModule{annotations, name, imports, exports, defs, files, isFlat, comments} to TCModule(annotations, name, imports, exports, defs, files, isFlat) set comments;
map ASTModuleImports{name, imports} to TCModuleImports(name, imports);
map ASTModuleExports{exports} to TCModuleExports(exports);
map ASTExport{} to TCExport();
map ASTExportAll{location} to TCExportAll(location);
map ASTExportedFunction{location, nameList, type, typeParams} to TCExportedFunction(location, nameList, type, typeParams);
map ASTExportedOperation{location, nameList, type} to TCExportedOperation(location, nameList, type);
map ASTExportedType{name, struct} to TCExportedType(name, struct);
map ASTExportedValue{location, nameList, type} to TCExportedValue(location, nameList, type);
map ASTImport{} to TCImport();
map ASTImportAll{name} to TCImportAll(name);
map ASTImportedFunction{name, type, typeParams, renamed} to TCImportedFunction(name, type, typeParams, renamed);
map ASTImportedOperation{name, type, renamed} to TCImportedOperation(name, type, renamed);
map ASTImportedType{name, def, renamed} to TCImportedType(name, def, renamed);
map ASTImportedValue{name, type, renamed} to TCImportedValue(name, type, renamed);
map ASTImportFromModule{name, signatures} to TCImportFromModule(name, signatures);
map ASTImportFromModuleList{} to TCImportFromModuleList(this);


# patterns
package com.fujitsu.vdmj.ast.patterns to com.fujitsu.vdmj.tc.patterns;
map ASTBind{} to TCBind();
map ASTBooleanPattern{value} to TCBooleanPattern(value);
map ASTCharacterPattern{value} to TCCharacterPattern(value);
map ASTConcatenationPattern{left, location, right} to TCConcatenationPattern(left, location, right);
map ASTExpressionPattern{exp} to TCExpressionPattern(exp);
map ASTIdentifierPattern{name} to TCIdentifierPattern(name);
map ASTIgnorePattern{location} to TCIgnorePattern(location);
map ASTIntegerPattern{value} to TCIntegerPattern(value);
map ASTMapletPattern{from, to} to TCMapletPattern(from, to);
map ASTMapletPatternList{} to TCMapletPatternList(this);
map ASTMapPattern{location, maplets} to TCMapPattern(location, maplets);
map ASTMapUnionPattern{left, location, right} to TCMapUnionPattern(left, location, right);
map ASTMultipleBind{} to TCMultipleBind();
map ASTMultipleBindList{} to TCMultipleBindList(this);
map ASTMultipleSeqBind{plist, sequence} to TCMultipleSeqBind(plist, sequence);
map ASTMultipleSetBind{plist, set} to TCMultipleSetBind(plist, set);
map ASTMultipleTypeBind{plist, type} to TCMultipleTypeBind(plist, type);
map ASTNamePatternPair{name, pattern} to TCNamePatternPair(name, pattern);
map ASTNamePatternPairList{} to TCNamePatternPairList(this);
map ASTNilPattern{location} to TCNilPattern(location);
map ASTObjectPattern{location, classname, fieldlist} to TCObjectPattern(location, classname, fieldlist);
map ASTPattern{} to TCPattern();
map ASTPatternList{} to TCPatternList(this);
map ASTPatternListList{} to TCPatternListList(this);
map ASTPatternBind{location, pattern, bind} to TCPatternBind(location, pattern, bind);
map ASTQuotePattern{value} to TCQuotePattern(value);
map ASTRealPattern{value} to TCRealPattern(value);
map ASTRecordPattern{typename, plist} to TCRecordPattern(typename, plist);
map ASTSeqBind{pattern, sequence} to TCSeqBind(pattern, sequence);
map ASTSeqPattern{location, plist} to TCSeqPattern(location, plist);
map ASTSetBind{pattern, set} to TCSetBind(pattern, set);
map ASTSetPattern{location, plist} to TCSetPattern(location, plist);
map ASTStringPattern{value} to TCStringPattern(value);
map ASTTuplePattern{location, plist} to TCTuplePattern(location, plist);
map ASTTypeBind{pattern, type} to TCTypeBind(pattern, type);
map ASTTypeBindList{} to TCTypeBindList(this);
map ASTUnionPattern{left, location, right} to TCUnionPattern(left, location, right);

# statements
package com.fujitsu.vdmj.ast.statements to com.fujitsu.vdmj.tc.statements;
map ASTAlwaysStatement{location, always, body, comments} to TCAlwaysStatement(location, always, body) set comments;
map ASTAssignmentStatement{location, target, exp, comments} to TCAssignmentStatement(location, target, exp) set comments;
map ASTAssignmentStatementList{} to TCAssignmentStatementList(this);
map ASTAtomicStatement{location, assignments, comments} to TCAtomicStatement(location, assignments) set comments;
map ASTBlockStatement{location, assignmentDefs, statements, comments} to TCBlockStatement(location, assignmentDefs, statements) set comments;
map ASTCallObjectStatement{designator, classname, fieldname, args, comments} to TCCallObjectStatement(designator, classname, fieldname, args) set comments;
map ASTCallStatement{name, args, comments} to TCCallStatement(name, args) set comments;
map ASTCasesStatement{location, exp, cases, others, comments} to TCCasesStatement(location, exp, cases, others) set comments;
map ASTCaseStmtAlternative{pattern, statement} to TCCaseStmtAlternative(pattern, statement);
map ASTCaseStmtAlternativeList{} to TCCaseStmtAlternativeList(this);
map ASTClassInvariantStatement{name, invdefs, comments} to TCClassInvariantStatement(name, invdefs) set comments;
map ASTCyclesStatement{location, cycles, statement, comments} to TCCyclesStatement(location, cycles, statement) set comments;
map ASTDefStatement{location, localDefs, statement, comments} to TCDefStatement(location, localDefs, statement) set comments;
map ASTDurationStatement{location, duration, statement, comments} to TCDurationStatement(location, duration, statement) set comments;
map ASTElseIfStatement{location, elseIfExp, thenStmt, comments} to TCElseIfStatement(location, elseIfExp, thenStmt) set comments;
map ASTElseIfStatementList{} to TCElseIfStatementList(this);
map ASTErrorCase{name, left, right} to TCErrorCase(name, left, right);
map ASTErrorCaseList{} to TCErrorCaseList(this);
map ASTErrorStatement{location, comments} to TCErrorStatement(location) set comments;
map ASTExitStatement{location, expression, comments} to TCExitStatement(location, expression) set comments;
map ASTExternalClause{mode, identifiers, type} to TCExternalClause(mode, identifiers, type);
map ASTExternalClauseList{} to TCExternalClauseList(this);
map ASTFieldDesignator{object, field} to TCFieldDesignator(object, field);
map ASTForAllStatement{location, pattern, set, statement, comments} to TCForAllStatement(location, pattern, set, statement) set comments;
map ASTForIndexStatement{location, var, from, to, by, statement, comments} to TCForIndexStatement(location, var, from, to, by, statement) set comments;
map ASTForPatternBindStatement{location, patternBind, reverse, exp, statement, comments} to TCForPatternBindStatement(location, patternBind, reverse, exp, statement) set comments;
map ASTIdentifierDesignator{name} to TCIdentifierDesignator(name);
map ASTIfStatement{location, ifExp, thenStmt, elseList, elseStmt, comments} to TCIfStatement(location, ifExp, thenStmt, elseList, elseStmt) set comments;
map ASTLetBeStStatement{location, bind, suchThat, statement, comments} to TCLetBeStStatement(location, bind, suchThat, statement) set comments;
map ASTLetDefStatement{location, localDefs, statement, comments} to TCLetDefStatement(location, localDefs, statement) set comments;
map ASTMapSeqDesignator{mapseq, exp} to TCMapSeqDesignator(mapseq, exp);
map ASTNonDeterministicStatement{location, statements, comments} to TCNonDeterministicStatement(location, statements) set comments;
map ASTNotYetSpecifiedStatement{location, comments} to TCNotYetSpecifiedStatement(location) set comments;
map ASTObjectApplyDesignator{object, args} to TCObjectApplyDesignator(object, args);
map ASTObjectDesignator{} to TCObjectDesignator();
map ASTObjectFieldDesignator{object, classname, fieldname} to TCObjectFieldDesignator(object, classname, fieldname);
map ASTObjectIdentifierDesignator{name} to TCObjectIdentifierDesignator(name);
map ASTObjectNewDesignator{expression} to TCObjectNewDesignator(expression);
map ASTObjectSelfDesignator{location} to TCObjectSelfDesignator(location);
map ASTPeriodicStatement{opname, args, comments} to TCPeriodicStatement(opname, args) set comments;
map ASTReturnStatement{location, expression, comments} to TCReturnStatement(location, expression) set comments;
map ASTSimpleBlockStatement{} to TCSimpleBlockStatement();
map ASTSkipStatement{location, comments} to TCSkipStatement(location) set comments;
map ASTSpecificationStatement{location, externals, precondition, postcondition, errors, comments} to TCSpecificationStatement(location, externals, precondition, postcondition, errors) set comments;
map ASTSporadicStatement{opname, args, comments} to TCSporadicStatement(opname, args) set comments;
map ASTStartStatement{location, objects, comments} to TCStartStatement(location, objects) set comments;
map ASTStateDesignator{} to TCStateDesignator();
map ASTStatement{comments} to TCStatement() set comments;
map ASTStatementList{} to TCStatementList(this);
map ASTStopStatement{location, objects, comments} to TCStopStatement(location, objects) set comments;
map ASTSubclassResponsibilityStatement{location, comments} to TCSubclassResponsibilityStatement(location) set comments;
map ASTTixeStatement{location, traps, body, comments} to TCTixeStatement(location, traps, body) set comments;
map ASTTixeStmtAlternative{patternBind, statement} to TCTixeStmtAlternative(patternBind, statement);
map ASTTixeStmtAlternativeList{} to TCTixeStmtAlternativeList(this);
map ASTTrapStatement{location, patternBind, with, body, comments} to TCTrapStatement(location, patternBind, with, body) set comments;
map ASTWhileStatement{location, exp, statement, comments} to TCWhileStatement(location, exp, statement) set comments;

# traces
package com.fujitsu.vdmj.ast.traces to com.fujitsu.vdmj.tc.traces;
map ASTTraceApplyExpression{callStatement} to TCTraceApplyExpression(callStatement);
map ASTTraceBracketedExpression{location, terms} to TCTraceBracketedExpression(location, terms);
map ASTTraceConcurrentExpression{location, defs} to TCTraceConcurrentExpression(location, defs);
map ASTTraceCoreDefinition{} to TCTraceCoreDefinition();
map ASTTraceDefinition{} to TCTraceDefinition();
map ASTTraceDefinitionList{} to TCTraceDefinitionList(this);
map ASTTraceDefinitionTerm{} to TCTraceDefinitionTerm(this);
map ASTTraceDefinitionTermList{} to TCTraceDefinitionTermList(this);
map ASTTraceLetBeStBinding{location, bind, stexp, body} to TCTraceLetBeStBinding(location, bind, stexp, body);
map ASTTraceLetDefBinding{location, localDefs, body} to TCTraceLetDefBinding(location, localDefs, body);
map ASTTraceRepeatDefinition{location, core, to, from} to TCTraceRepeatDefinition(location, core, from, to);

# types
package com.fujitsu.vdmj.ast.types to com.fujitsu.vdmj.tc.types;
map ASTType{} to TCType();
map ASTTypeList{} to TCTypeList(this);
map ASTBasicType{} to TCBasicType();
map ASTBooleanType{location} to TCBooleanType(location);
map ASTBracketType{type} to TCBracketType(type);
map ASTCharacterType{location} to TCCharacterType(location);
map ASTClassType{location, classdef} to TCClassType(location, classdef);
map ASTField{tagname, tag, type, equalityAbstraction} to TCField(tagname, tag, type, equalityAbstraction);
map ASTFieldList{} to TCFieldList(this);
map ASTFunctionType{location, parameters, partial, result} to TCFunctionType(location, parameters, partial, result);
map ASTInMapType{location, from, to} to TCInMapType(location, from, to);
map ASTInvariantType{} to TCInvariantType();
map ASTMapType{location, from, to} to TCMapType(location, from, to);
map ASTNamedType{typename, type} to TCNamedType(typename, type);
map ASTNaturalOneType{location} to TCNaturalOneType(location);
map ASTNaturalType{location} to TCNaturalType(location);
map ASTIntegerType{location} to TCIntegerType(location);
map ASTNumericType{} to TCNumericType();
map ASTOperationType{location, parameters, result} to TCOperationType(location, parameters, result);
map ASTOptionalType{location, type} to TCOptionalType(location, type);
map ASTParameterType{name} to TCParameterType(name);
map ASTPatternListTypePair{patterns, type} to TCPatternListTypePair(patterns, type);
map ASTPatternListTypePairList{} to TCPatternListTypePairList(this);
map ASTPatternTypePair{pattern, type} to TCPatternTypePair(pattern, type);
map ASTProductType{location, types} to TCProductType(location, types);
map ASTQuoteType{location, value} to TCQuoteType(location, value);
map ASTRationalType{location} to TCRationalType(location);
map ASTRealType{location} to TCRealType(location);
map ASTRecordType{name, fields, composed} to TCRecordType(name, fields, composed);
map ASTSeq1Type{location, seqof} to TCSeq1Type(location, seqof);
map ASTSeqType{location, seqof} to TCSeqType(location, seqof);
map ASTSetType{location, setof} to TCSetType(location, setof);
map ASTSet1Type{location, setof} to TCSet1Type(location, setof);
map ASTTokenType{location} to TCTokenType(location);
map ASTTypeSet{} to TCTypeSet(this);
map ASTUndefinedType{location} to TCUndefinedType(location);
map ASTUnionType{location, types} to TCUnionType(location, types);
map ASTUnknownType{location} to TCUnknownType(location);
map ASTUnresolvedType{typename, maximal} to TCUnresolvedType(typename, maximal);
map ASTVoidReturnType{location} to TCVoidReturnType(location);
map ASTVoidType{location} to TCVoidType(location);

# Java - usually unmappeds
unmapped java.lang.Boolean;
unmapped java.lang.String;
unmapped java.lang.Long;
unmapped com.fujitsu.vdmj.mapper.FileList;
unmapped com.fujitsu.vdmj.typechecker.NameScope;