void RedundantVoidArgCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(functionDecl(parameterCountIs(0), unless(isImplicit()),
unless(isExternC()))
.bind(FunctionId),
this);
Finder->addMatcher(typedefNameDecl().bind(TypedefId), this);
auto ParenFunctionType = parenType(innerType(functionType()));
auto PointerToFunctionType = pointee(ParenFunctionType);
auto FunctionOrMemberPointer =
anyOf(hasType(pointerType(PointerToFunctionType)),
hasType(memberPointerType(PointerToFunctionType)));
Finder->addMatcher(fieldDecl(FunctionOrMemberPointer).bind(FieldId), this);
Finder->addMatcher(varDecl(FunctionOrMemberPointer).bind(VarId), this);
auto CastDestinationIsFunction =
hasDestinationType(pointsTo(ParenFunctionType));
Finder->addMatcher(
cStyleCastExpr(CastDestinationIsFunction).bind(CStyleCastId), this);
Finder->addMatcher(
cxxStaticCastExpr(CastDestinationIsFunction).bind(NamedCastId), this);
Finder->addMatcher(
cxxReinterpretCastExpr(CastDestinationIsFunction).bind(NamedCastId),
this);
Finder->addMatcher(
cxxConstCastExpr(CastDestinationIsFunction).bind(NamedCastId), this);
Finder->addMatcher(lambdaExpr().bind(LambdaId), this);
}
bool loadFunctionStats(const char *pFunctionData, UDWORD bufferSize)
{
//array of functions pointers for each load function
static const LoadFunction pLoadFunction[NUMFUNCTIONS] =
{
loadProduction,
loadProductionUpgradeFunction,
loadResearchFunction,
loadResearchUpgradeFunction,
loadPowerGenFunction,
loadResourceFunction,
loadRepairDroidFunction,
loadWeaponUpgradeFunction,
loadWallFunction,
loadStructureUpgradeFunction,
loadWallDefenceUpgradeFunction,
loadPowerUpgradeFunction,
loadRepairUpgradeFunction,
loadDroidRepairUpgradeFunction,
loadDroidECMUpgradeFunction,
loadDroidBodyUpgradeFunction,
loadDroidSensorUpgradeFunction,
loadDroidConstUpgradeFunction,
loadReArmFunction,
loadReArmUpgradeFunction,
};
const unsigned int totalFunctions = numCR(pFunctionData, bufferSize);
UDWORD i, type;
char FunctionType[MAX_STR_LENGTH];
FUNCTION **pStartList;
//allocate storage for the Function pointer array
asFunctions = (FUNCTION **) malloc(totalFunctions * sizeof(FUNCTION *));
pStartList = asFunctions;
//initialise the storage
memset(asFunctions, 0, totalFunctions * sizeof(FUNCTION *));
numFunctions = 0;
for (i = 0; i < totalFunctions; i++)
{
//read the data into the storage - the data is delimeted using comma's
FunctionType[0] = '\0';
sscanf(pFunctionData, "%255[^,'\r\n]", FunctionType);
type = functionType(FunctionType);
pFunctionData += (strlen(FunctionType) + 1);
if (!(pLoadFunction[type](pFunctionData)))
{
return false;
}
//increment the pointer to the start of the next record
pFunctionData = strchr(pFunctionData, '\n') + 1;
}
//set the function list pointer to the start
asFunctions = pStartList;
return true;
}
Foam::autoPtr<Foam::functionObject> Foam::functionObject::New
(
const word& name,
const Time& t,
const dictionary& functionDict
)
{
word functionType(functionDict.lookup("type"));
if (debug)
{
Info<< "Selecting function " << functionType << endl;
}
dlLibraryTable::open
(
functionDict,
"functionObjectLibs",
dictionaryConstructorTablePtr_
);
if (!dictionaryConstructorTablePtr_)
{
FatalErrorIn
(
"functionObject::New"
"(const word& name, const Time&, const dictionary&)"
) << "Unknown function type "
<< functionType << nl << nl
<< "Table of functionObjects is empty" << endl
<< exit(FatalError);
}
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(functionType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"functionObject::New"
"(const word& name, const Time&, const dictionary&)"
) << "Unknown function type "
<< functionType << nl << nl
<< "Valid functions are : " << nl
<< dictionaryConstructorTablePtr_->sortedToc() << endl
<< exit(FatalError);
}
return autoPtr<functionObject>(cstrIter()(name, t, functionDict));
}
Output::Output(CompilerState& state)
: m_state(state)
, m_repo(state.m_context, state.m_module)
, m_builder(nullptr)
, m_stackMapsId(1)
, m_currentBlockTerminated(false)
{
m_argType = pointerType(arrayType(repo().intPtr, state.m_platformDesc.m_contextSize / sizeof(intptr_t)));
state.m_function = addFunction(
state.m_module, "main", functionType(repo().voidType, m_argType));
llvmAPI->SetFunctionCallConv(state.m_function, LLVMFastCallConv);
m_builder = llvmAPI->CreateBuilderInContext(state.m_context);
m_prologue = appendBasicBlock("Prologue");
positionToBBEnd(m_prologue);
buildGetArg();
}
eth::AssemblyItem CompilerContext::virtualFunctionEntryLabel(
FunctionDefinition const& _function,
vector<ContractDefinition const*>::const_iterator _searchStart
)
{
string name = _function.name();
FunctionType functionType(_function);
auto it = _searchStart;
for (; it != m_inheritanceHierarchy.end(); ++it)
for (FunctionDefinition const* function: (*it)->definedFunctions())
if (
function->name() == name &&
!function->isConstructor() &&
FunctionType(*function).hasEqualArgumentTypes(functionType)
)
return functionEntryLabel(*function);
solAssert(false, "Super function " + name + " not found.");
return m_asm.newTag(); // not reached
}
TEST(DynTypedNode, TypeLocSourceRange) {
RangeVerifier<DynTypedNode> Verifier;
Verifier.expectRange(1, 1, 1, 8);
EXPECT_TRUE(Verifier.match("void f() {}", typeLoc(loc(functionType()))));
}
parse::Grammar function(parse::GenericAction<type::Function const *> out) {
return functionType(out);
}
