com.fujitsu.vdmj.tc.definitions.TCExplicitFunctionDefinition Maven / Gradle / Ivy
The newest version!
/*******************************************************************************
*
* Copyright (c) 2016 Fujitsu Services Ltd.
*
* Author: Nick Battle
*
* This file is part of VDMJ.
*
* VDMJ is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* VDMJ is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with VDMJ. If not, see plists, TCFunctionType ftype)
{
TCTypeList ptypes = ftype.parameters;
TCPatternList patterns = plists.next();
if (patterns.size() > ptypes.size())
{
report(3020, "Too many parameter patterns");
detail2("Pattern(s)", patterns, "Type(s)", ptypes);
return ftype.result;
}
else if (patterns.size() < ptypes.size())
{
report(3021, "Too few parameter patterns");
detail2("Pattern(s)", patterns, "Type(s)", ptypes);
return ftype.result;
}
if (ftype.result instanceof TCFunctionType)
{
if (!plists.hasNext())
{
// We're returning the function itself
return ftype.result;
}
// We're returning what the function returns, assuming we
// pass the right parameters. Note that this recursion
// means that we finally return the result of calling the
// function with *all* of the curried argument sets applied.
// This is because the type check of the body determines
// the return type when all of the curried parameters are
// provided.
return checkParams(plists, (TCFunctionType)ftype.result);
}
if (plists.hasNext())
{
report(3022, "Too many curried parameters");
}
return ftype.result;
}
public TCDefinitionListList getParamDefinitions()
{
TCDefinitionListList defList = new TCDefinitionListList();
TCFunctionType ftype = type; // Start with the overall function
Iterator piter = paramPatternList.iterator();
while (piter.hasNext())
{
TCPatternList plist = piter.next();
TCDefinitionList defs = new TCDefinitionList();
TCTypeList ptypes = ftype.parameters;
Iterator titer = ptypes.iterator();
if (plist.size() != ptypes.size())
{
// This is a type/param mismatch, reported elsewhere. But we
// have to create definitions to avoid a cascade of errors.
TCType unknown = new TCUnknownType(location);
for (TCPattern p: plist)
{
defs.addAll(p.getDefinitions(unknown, NameScope.LOCAL));
}
}
else
{
for (TCPattern p: plist)
{
defs.addAll(p.getDefinitions(titer.next(), NameScope.LOCAL));
}
}
defList.add(checkDuplicatePatterns(defs));
if (ftype.result instanceof TCFunctionType) // else???
{
ftype = (TCFunctionType)ftype.result;
}
}
return defList;
}
@Override
public TCDefinition findName(TCNameToken sought, NameScope scope)
{
if (super.findName(sought, scope) != null)
{
return this;
}
if (predef != null && predef.findName(sought, scope) != null)
{
return predef;
}
if (postdef != null && postdef.findName(sought, scope) != null)
{
return postdef;
}
if (measureDef != null)
{
return measureDef.findName(sought, scope); // eg. pre_measure_f
}
return null;
}
@Override
public TCDefinitionList getDefinitions()
{
TCDefinitionList defs = new TCDefinitionList(this);
if (predef != null)
{
defs.add(predef);
}
if (postdef != null)
{
defs.add(postdef);
}
if (measureDef != null && measureName.isMeasureName())
{
defs.add(measureDef);
}
return defs;
}
private TCExplicitFunctionDefinition getPreDefinition()
{
TCExplicitFunctionDefinition def = new TCExplicitFunctionDefinition(null, accessSpecifier, name.getPreName(precondition.location),
typeParams, type.getCurriedPreType(isCurried), paramPatternList, precondition, null, null, false, null);
def.classDefinition = classDefinition;
return def;
}
private TCExplicitFunctionDefinition getPostDefinition()
{
TCPatternList last = new TCPatternList();
int psize = paramPatternList.size();
for (TCPattern p: paramPatternList.get(psize - 1))
{
last.add(p);
}
last.add(new TCIdentifierPattern(name.getResultName(location)));
TCPatternListList parameters = new TCPatternListList();
if (psize > 1)
{
parameters.addAll(paramPatternList.subList(0, psize - 1));
}
parameters.add(last);
TCExplicitFunctionDefinition def = new TCExplicitFunctionDefinition(null, accessSpecifier, name.getPostName(postcondition.location),
typeParams, type.getCurriedPostType(isCurried), parameters, postcondition, null, null, false, null);
def.classDefinition = classDefinition;
return def;
}
@Override
public boolean isFunction()
{
return true;
}
@Override
public boolean isCallableFunction()
{
return true;
}
@Override
public boolean isSubclassResponsibility()
{
return body instanceof TCSubclassResponsibilityExpression;
}
@Override
public TCNameSet getCallMap()
{
TCFunctionCallFinder finder = new TCFunctionCallFinder();
TCNameSet found = new TCNameSet();
found.addAll(body.apply(finder, null));
if (predef != null)
{
found.addAll(predef.getCallMap());
}
if (postdef != null)
{
found.addAll(postdef.getCallMap());
}
return found;
}
@Override
public R apply(TCDefinitionVisitor visitor, S arg)
{
return visitor.caseExplicitFunctionDefinition(this, arg);
}
}