static void parseImm(CursorState* cursor,CallIndirectImm& outImm) { if(cursor->nextToken->type == t_name || cursor->nextToken->type == t_decimalInt || cursor->nextToken->type == t_hexInt) { // Parse the callee type as a legacy naked name or index referring to a type declaration. outImm.type.index = parseAndResolveNameOrIndexRef( cursor, cursor->moduleState->typeNameToIndexMap, cursor->moduleState->module.types.size(), "type"); } else { // Parse the callee type, as a reference or explicit declaration. const Token* firstTypeToken = cursor->nextToken; std::vector<std::string> paramDisassemblyNames; NameToIndexMap paramNameToIndexMap; const UnresolvedFunctionType unresolvedFunctionType = parseFunctionTypeRefAndOrDecl( cursor, paramNameToIndexMap, paramDisassemblyNames); outImm.type.index = resolveFunctionType(cursor->moduleState,unresolvedFunctionType).index; // Disallow named parameters. if(paramNameToIndexMap.size()) { auto paramNameIt = paramNameToIndexMap.begin(); parseErrorf( cursor->parseState, firstTypeToken, "call_indirect callee type declaration may not declare parameter names ($%s)", paramNameIt->key.getString().c_str()); } } }
static void parseControlImm(CursorState* cursor,Name& outBranchTargetName,ControlStructureImm& imm) { tryParseName(cursor,outBranchTargetName); cursor->functionState->labelDisassemblyNames.push_back(outBranchTargetName.getString()); FunctionType functionType; // For backward compatibility, handle a naked result type. ValueType singleResultType; if(tryParseValueType(cursor, singleResultType)) { functionType = FunctionType(TypeTuple(singleResultType)); } else { // Parse the callee type, as a reference or explicit declaration. const Token* firstTypeToken = cursor->nextToken; std::vector<std::string> paramDisassemblyNames; NameToIndexMap paramNameToIndexMap; const UnresolvedFunctionType unresolvedFunctionType = parseFunctionTypeRefAndOrDecl( cursor, paramNameToIndexMap, paramDisassemblyNames); // Disallow named parameters. if(paramNameToIndexMap.size()) { auto paramNameIt = paramNameToIndexMap.begin(); parseErrorf( cursor->parseState, firstTypeToken, "block type declaration may not declare parameter names ($%s)", paramNameIt->key.getString().c_str()); } if(!unresolvedFunctionType.reference) { // If there wasn't a type reference, just use the inline declared params and results. functionType = unresolvedFunctionType.explicitType; } else { // If there was a type reference, resolve it. This also verifies that if there were also // params and/or results declared inline that they match the resolved type reference. const Uptr referencedFunctionTypeIndex = resolveFunctionType( cursor->moduleState, unresolvedFunctionType ).index; functionType = cursor->moduleState->module.types[referencedFunctionTypeIndex]; } } // Translate the function type into an indexed block type. if(functionType.params().size() == 0 && functionType.results().size() == 0) { imm.type.format = IndexedBlockType::noParametersOrResult; imm.type.resultType = ValueType::any; } else if(functionType.params().size() == 0 && functionType.results().size() == 1) { imm.type.format = IndexedBlockType::oneResult; imm.type.resultType = functionType.results()[0]; } else { imm.type.format = IndexedBlockType::functionType; imm.type.index = getUniqueFunctionTypeIndex(cursor->moduleState, functionType).index; } }