WAST Namespace Reference

Classes
struct	Action
struct	ActionCommand
struct	AssertInvalidOrMalformedCommand
struct	AssertReturnCommand
struct	AssertReturnNaNCommand
struct	AssertTrapCommand
struct	AssertUnlinkableCommand
struct	Command
struct	Error
struct	FatalParseException
struct	FunctionPrintContext
struct	GetAction
struct	InvokeAction
struct	LineInfo
struct	ModuleAction
struct	ModuleParseState
struct	ModulePrintContext
struct	Name
struct	NameScope
struct	ParseState
struct	RecoverParseException
struct	Reference
struct	RegisterCommand
struct	ScopedTagPrinter
struct	StaticData
struct	TextFileLocus
struct	UnresolvedError
struct	UnresolvedFunctionType

Typedefs
typedef std::unordered_map< Name, U32, Name::Hasher >	NameToIndexMap

Enumerations
enum class	ActionType { _module , invoke , get }
enum	TokenType : U16 { numTokenTypes }

Functions
WAST_API void	parseTestCommands (const char *string, Uptr stringLength, std::vector< std::unique_ptr< Command > > &outTestCommands, std::vector< Error > &outErrors)
WAST_API bool	parseModule (const char *string, Uptr stringLength, IR::Module &outModule, std::vector< Error > &outErrors)
WAST_API std::string	print (const IR::Module &module)
const char *	describeToken (TokenType tokenType)
bool	isRecoveryPointChar (char c)
Token *	lex (const char *string, Uptr stringLength, LineInfo *&outLineInfo)
void	freeTokens (Token *tokens)
void	freeLineInfo (LineInfo *lineInfo)
TextFileLocus	calcLocusFromOffset (const char *string, const LineInfo *lineInfo, Uptr charOffset)
	PACKED_STRUCT (struct Token { TokenType type;U32 begin;})
void	findClosingParenthesis (ParseState &state, const Token *openingParenthesisToken)
void	parseErrorf (ParseState &state, Uptr charOffset, const char *messageFormat, va_list messageArguments)
void	parseErrorf (ParseState &state, Uptr charOffset, const char *messageFormat,...)
void	parseErrorf (ParseState &state, const char *nextChar, const char *messageFormat,...)
void	parseErrorf (ParseState &state, const Token *nextToken, const char *messageFormat,...)
void	require (ParseState &state, TokenType type)
bool	tryParseValueType (ParseState &state, ValueType &outValueType)
bool	tryParseResultType (ParseState &state, ResultType &outResultType)
ValueType	parseValueType (ParseState &state)
const FunctionType *	parseFunctionType (ModuleParseState &state, NameToIndexMap &outLocalNameToIndexMap, std::vector< std::string > &outLocalDisassemblyNames)
UnresolvedFunctionType	parseFunctionTypeRefAndOrDecl (ModuleParseState &state, NameToIndexMap &outLocalNameToIndexMap, std::vector< std::string > &outLocalDisassemblyNames)
IndexedFunctionType	resolveFunctionType (ModuleParseState &state, const UnresolvedFunctionType &unresolvedType)
IndexedFunctionType	getUniqueFunctionTypeIndex (ModuleParseState &state, const FunctionType *functionType)
bool	tryParseName (ParseState &state, Name &outName)
bool	tryParseNameOrIndexRef (ParseState &state, Reference &outRef)
U32	parseAndResolveNameOrIndexRef (ParseState &state, const NameToIndexMap &nameToIndexMap, Uptr maxIndex, const char *context)
void	bindName (ParseState &state, NameToIndexMap &nameToIndexMap, const Name &name, Uptr index)
U32	resolveRef (ParseState &state, const NameToIndexMap &nameToIndexMap, Uptr maxIndex, const Reference &ref)
bool	tryParseHexit (const char *&nextChar, U8 &outValue)
bool	tryParseString (ParseState &state, std::string &outString)
std::string	parseUTF8String (ParseState &state)
bool	tryParseI32 (ParseState &state, U32 &outI32)
bool	tryParseI64 (ParseState &state, U64 &outI64)
U8	parseI8 (ParseState &state)
U32	parseI32 (ParseState &state)
U64	parseI64 (ParseState &state)
F32	parseF32 (ParseState &state)
F64	parseF64 (ParseState &state)
IR::FunctionDef	parseFunctionDef (ModuleParseState &state, const Token *funcToken)
void	parseModuleBody (ModuleParseState &state)
char	nibbleToHexChar (U8 value)
std::string	escapeString (const char *string, Uptr numChars)
std::string	expandIndentation (std::string &&inString, U8 spacesPerIndentLevel=2)
void	print (std::string &string, ValueType type)
void	print (std::string &string, ResultType type)
void	print (std::string &string, const SizeConstraints &size)
void	print (std::string &string, const FunctionType *functionType)
void	print (std::string &string, const TableType &type)
void	print (std::string &string, const MemoryType &type)
void	print (std::string &string, GlobalType type)
void	printControlSignature (std::string &string, ResultType resultType)
template<typename Type >
void	printImportType (std::string &string, const Module &module, Type type)
template<>
void	printImportType< IndexedFunctionType > (std::string &string, const Module &module, IndexedFunctionType type)
template<typename Type >
void	printImport (std::string &string, const Module &module, const Import< Type > &import, Uptr importIndex, const char *name, const char *typeTag)

Typedef Documentation

NameToIndexMap

typedef std::unordered_map<Name,U32,Name::Hasher> WAST::NameToIndexMap

Definition at line 88 of file Parse.h.

Enumeration Type Documentation

ActionType

enum class WAST::ActionType

strong

Enumerator
_module
invoke
get

Definition at line 41 of file TestScript.h.

    {
        _module,
        invoke,
        get,
    };

TokenType

enum WAST::TokenType : U16

Enumerator
numTokenTypes

Definition at line 87 of file Lexer.h.

    {
        #define VISIT_TOKEN(name,description) t_##name,
        ENUM_TOKENS()
        #undef VISIT_TOKEN
        numTokenTypes
    };

Function Documentation

bindName()

void WAST::bindName	(	ParseState &	state,
		NameToIndexMap &	nameToIndexMap,
		const Name &	name,
		Uptr	index )

Definition at line 322 of file Parse.cpp.

    {
        errorUnless(index <= UINT32_MAX);
 
        if(name)
        {
            auto mapIt = nameToIndexMap.find(name);
            if(mapIt != nameToIndexMap.end())
            {
                const TextFileLocus previousDefinitionLocus = calcLocusFromOffset(state.string, state.lineInfo,mapIt->first.getCharOffset(state.string));
                parseErrorf(state,name.getCharOffset(state.string),"redefinition of name defined at %s",previousDefinitionLocus.describe().c_str());
            }
            nameToIndexMap.emplace(name,U32(index));
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

calcLocusFromOffset()

TextFileLocus WAST::calcLocusFromOffset	(	const char *	string,
		const LineInfo *	lineInfo,
		Uptr	charOffset )

Definition at line 331 of file Lexer.cpp.

    {
        // Binary search the line starts for the last one before charIndex.
        Uptr minLineIndex = 0;
        Uptr maxLineIndex = lineInfo->numLineStarts - 1;
        while(maxLineIndex > minLineIndex)
        {
            const Uptr medianLineIndex = (minLineIndex + maxLineIndex + 1) / 2;
            if(charOffset < lineInfo->lineStarts[medianLineIndex])
            {
                maxLineIndex = medianLineIndex - 1;
            }
            else if(charOffset > lineInfo->lineStarts[medianLineIndex])
            {
                minLineIndex = medianLineIndex;
            }
            else
            {
                minLineIndex = maxLineIndex = medianLineIndex;
            }
        };
        TextFileLocus result;
        result.newlines = (U32)minLineIndex;
 
        // Count tabs and and spaces from the beginning of the line to charIndex.
        for(U32 index = lineInfo->lineStarts[result.newlines];index < charOffset;++index)
        {
            if(string[index] == '\t') { ++result.tabs; }
            else { ++result.characters; }
        }
 
        // Copy the full source line into the TextFileLocus for context.
        const Uptr lineStartOffset = getLineOffset(lineInfo,result.newlines);
        Uptr lineEndOffset = getLineOffset(lineInfo,result.newlines+1) - 1;
        result.sourceLine = std::string(string + lineStartOffset,lineEndOffset - lineStartOffset);
 
        return result;
    }

Here is the caller graph for this function:

describeToken()

const char * WAST::describeToken

(

TokenType

tokenType

)

Definition at line 14 of file Lexer.cpp.

    {
        WAVM_ASSERT_THROW(tokenType < numTokenTypes);
        static const char* tokenDescriptions[] =
        {
            // This ENUM_TOKENS must come before the literalTokenPairs definition that redefines VISIT_OPERATOR_TOKEN.
            #define VISIT_TOKEN(name,description) description,
            ENUM_TOKENS()
            #undef VISIT_TOKEN
        };
        return tokenDescriptions[tokenType];
    }

Here is the caller graph for this function:

escapeString()

std::string WAST::escapeString	(	const char *	string,
		Uptr	numChars )

Definition at line 18 of file Print.cpp.

    {
        std::string result;
        for(Uptr charIndex = 0;charIndex < numChars;++charIndex)
        {
            auto c = string[charIndex];
            if(c == '\\') { result += "\\\\"; }
            else if(c == '\"') { result += "\\\""; }
            else if(c == '\n') { result += "\\n"; }
            else if(c < 0x20 || c > 0x7e)
            {
                result += '\\';
                result += nibbleToHexChar((c & 0xf0) >> 4);
                result += nibbleToHexChar((c & 0x0f) >> 0);
            }
            else { result += c; }
        }
        return result;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

expandIndentation()

std::string WAST::expandIndentation	(	std::string &&	inString,
		U8	spacesPerIndentLevel = 2 )

Definition at line 38 of file Print.cpp.

    {
        std::string paddedInput = std::move(inString);
        paddedInput += '\0';
 
        std::string result;
        const char* next = paddedInput.data();
        const char* end = paddedInput.data() + paddedInput.size() - 1;
        Uptr indentDepth = 0;
        while(next < end)
        {
            // Absorb INDENT_STRING and DEDENT_STRING, but keep track of the indentation depth,
            // and insert a proportional number of spaces following newlines. 
            if(*(U16*)next == *(U16*)INDENT_STRING) { ++indentDepth; next += 2; }
            else if(*(U16*)next == *(U16*)DEDENT_STRING) { errorUnless(indentDepth > 0); --indentDepth; next += 2; }
            else if(*next == '\n')
            {
                result += '\n';
                result.insert(result.end(),indentDepth*2,' ');
                ++next;
            }
            else { result += *next++; }
        }
        return result;
    }

Here is the caller graph for this function:

findClosingParenthesis()

void WAST::findClosingParenthesis	(	ParseState &	state,
		const Token *	openingParenthesisToken )

Definition at line 19 of file Parse.cpp.

    {
        // Skip over tokens until the ')' closing the current parentheses nesting depth is found.
        Uptr depth = 1;
        while(depth > 0)
        {
            switch(state.nextToken->type)
            {
            default:
                ++state.nextToken;
                break;
            case t_leftParenthesis:
                ++state.nextToken;
                ++depth;
                break;
            case t_rightParenthesis:
                ++state.nextToken;
                --depth;
                break;
            case t_eof:
                parseErrorf(state,openingParenthesisToken,"reached end of input while trying to find closing parenthesis");
                throw FatalParseException();
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

freeLineInfo()

void WAST::freeLineInfo

(

LineInfo *

lineInfo

)

Definition at line 319 of file Lexer.cpp.

    {
        free(lineInfo->lineStarts);
        delete lineInfo;
    }

Here is the caller graph for this function:

freeTokens()

void WAST::freeTokens

(

Token *

tokens

)

Definition at line 314 of file Lexer.cpp.

    {
        free(tokens);
    }

Here is the caller graph for this function:

getUniqueFunctionTypeIndex()

IR::IndexedFunctionType WAST::getUniqueFunctionTypeIndex	(	ModuleParseState &	state,
		const FunctionType *	functionType )

Definition at line 226 of file Parse.cpp.

    {
        // If this type is not in the module's type table yet, add it.
        auto functionTypeToIndexMapIt = state.functionTypeToIndexMap.find(functionType);
        if(functionTypeToIndexMapIt != state.functionTypeToIndexMap.end())
        {
            return IndexedFunctionType {functionTypeToIndexMapIt->second};
        }
        else
        {
            const Uptr functionTypeIndex = state.module.types.size();
            state.module.types.push_back(functionType);
            state.disassemblyNames.types.push_back(std::string());
            errorUnless(functionTypeIndex < UINT32_MAX);
            state.functionTypeToIndexMap.emplace(functionType,(U32)functionTypeIndex);
            return IndexedFunctionType {(U32)functionTypeIndex};
        }
    }

Here is the caller graph for this function:

isRecoveryPointChar()

bool WAST::isRecoveryPointChar ( char c )

inline

Definition at line 153 of file Lexer.cpp.

    {
        switch(c)
        {
        // Recover lexing at the next whitespace or parenthesis.
        case ' ': case '\t': case '\r': case '\n': case '\f':
        case '(': case ')':
            return true;
        default:
            return false;
        };
    }

Here is the caller graph for this function:

lex()

Token * WAST::lex	(	const char *	string,
		Uptr	stringLength,
		LineInfo *&	outLineInfo )

Definition at line 166 of file Lexer.cpp.

    {
        static StaticData staticData;
        
        Timing::Timer timer;
 
        if(stringLength > UINT32_MAX)
        {
            Errors::fatalf("cannot lex strings with more than %u characters",UINT32_MAX);
        }
        
        // Allocate enough memory up front for a token and newline for each character in the input string.
        Token* tokens = (Token*)malloc(sizeof(Token) * (stringLength + 1));
        U32* lineStarts = (U32*)malloc(sizeof(U32) * (stringLength + 2));
 
        Token* nextToken = tokens;
        U32* nextLineStart = lineStarts;
        *nextLineStart++ = 0;
 
        const char* nextChar = string;
        while(true)
        {
            // Skip whitespace and comments (keeping track of newlines).
            while(true)
            {
                switch(*nextChar)
                {
                // Single line comments.
                case ';':
                    if(nextChar[1] != ';') { goto doneSkippingWhitespace; }
                    else
                    {
                        nextChar += 2;
                        while(*nextChar)
                        {
                            if(*nextChar == '\n')
                            {
                                // Emit a line start for the newline.
                                *nextLineStart++ = U32(nextChar - string + 1);
                                ++nextChar;
                                break;
                            }
                            ++nextChar;
                        };
                    }
                    break;
                // Delimited (possibly multi-line) comments.
                case '(':
                    if(nextChar[1] != ';') { goto doneSkippingWhitespace; }
                    else
                    {
                        const char* firstCommentChar = nextChar;
                        nextChar += 2;
                        U32 commentDepth = 1;
                        while(commentDepth)
                        {
                            if(nextChar[0] == ';' && nextChar[1] == ')')
                            {
                                --commentDepth;
                                nextChar += 2;
                            }
                            else if(nextChar[0] == '(' && nextChar[1] == ';')
                            {
                                ++commentDepth;
                                nextChar += 2;
                            }
                            else if(nextChar == string + stringLength)
                            {
                                // Emit an unterminated comment token.
                                nextToken->type = t_unterminatedComment;
                                nextToken->begin = U32(firstCommentChar - string);
                                ++nextToken;
                                goto doneSkippingWhitespace;
                            }
                            else
                            {
                                if(*nextChar == '\n')
                                {
                                    // Emit a line start for the newline.
                                    *nextLineStart++ = U32(nextChar - string);
                                }
                                ++nextChar;
                            }
                        };
                    }
                    break;
                // Whitespace.
                case '\n':
                    *nextLineStart++ = U32(nextChar - string + 1);
                    ++nextChar;
                    break;
                case ' ': case '\t': case '\r': case '\f':
                    ++nextChar;
                    break;
                default:
                    goto doneSkippingWhitespace;
                };
            }
            doneSkippingWhitespace:
 
            // Once we reach a non-whitespace, non-comment character, feed characters into the NFA until it reaches a terminal state.
            nextToken->begin = U32(nextChar - string);
            NFA::StateIndex terminalState = staticData.nfaMachine.feed(nextChar);
            if(terminalState != NFA::unmatchedCharacterTerminal)
            {
                nextToken->type = TokenType(NFA::maximumTerminalStateIndex - (NFA::StateIndex)terminalState);
                ++nextToken;
            }
            else
            {
                if(nextToken->begin < stringLength)
                {
                    // Emit an unrecognized token.
                    nextToken->type = t_unrecognized;
                    ++nextToken;
 
                    // Advance until a recovery point.
                    while(!isRecoveryPointChar(*nextChar)) { ++nextChar; }
                }
                else
                {
                    break;
                }
            }
        }
 
        // Emit an end token to mark the end of the token stream.
        nextToken->type = t_eof;
        ++nextToken;
        
        // Emit an extra line start for the end of the file, so you can find the end of a line with lineStarts[line + 1].
        *nextLineStart++ = U32(nextChar - string) + 1;
 
        // Shrink the line start and token arrays to the final number of tokens/lines.
        const Uptr numLineStarts = nextLineStart - lineStarts;
        const Uptr numTokens = nextToken - tokens;
        lineStarts = (U32*)realloc(lineStarts,sizeof(U32) * numLineStarts);
        tokens = (Token*)realloc(tokens,sizeof(Token) * numTokens);
 
        // Create the LineInfo object that encapsulates the line start information.
        outLineInfo = new LineInfo {lineStarts,U32(numLineStarts)};
 
        Timing::logRatePerSecond("lexed WAST file",timer,stringLength/1024.0/1024.0,"MB");
        Log::printf(Log::Category::metrics,"lexer produced %u tokens (%.1fMB)\n",numTokens,numTokens*sizeof(Token)/1024.0/1024.0);
 
        return tokens;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

nibbleToHexChar()

char WAST::nibbleToHexChar

(

U8

value

)

Definition at line 16 of file Print.cpp.

{ return value < 10 ? ('0' + value) : 'a' + value - 10; }

Here is the caller graph for this function:

PACKED_STRUCT()

WAST::PACKED_STRUCT

(

struct Token { TokenType type;U32 begin;}

)

parseAndResolveNameOrIndexRef()

U32 WAST::parseAndResolveNameOrIndexRef	(	ParseState &	state,
		const NameToIndexMap &	nameToIndexMap,
		Uptr	maxIndex,
		const char *	context )

Definition at line 295 of file Parse.cpp.

    {
        Reference ref;
 
        if(strcmp(context, "type") == 0     //limits this block strictly to call_indirect
        && state.nextToken[0].type == t_leftParenthesis
        && state.nextToken[1].type == t_type)
        {
            parseParenthesized(state,[&]
            {
                require(state,t_type);
                if(!tryParseNameOrIndexRef(state,ref))
                {
                    parseErrorf(state,state.nextToken,"expected type name or index");
                    throw RecoverParseException();
                }
            });
        }
 
        if(ref.type == Reference::Type::invalid && !tryParseNameOrIndexRef(state,ref))
        {
            parseErrorf(state,state.nextToken,"expected %s name or index",context);
            throw RecoverParseException();
        }
        return resolveRef(state,nameToIndexMap,maxIndex,ref);
    }

Here is the call graph for this function:

parseErrorf() [1/4]

void WAST::parseErrorf	(	ParseState &	state,
		const char *	nextChar,
		const char *	messageFormat,
			... )

Definition at line 63 of file Parse.cpp.

    {
        va_list messageArguments;
        va_start(messageArguments,messageFormat);
        parseErrorf(state,nextChar - state.string,messageFormat,messageArguments);
        va_end(messageArguments);
    }

Here is the call graph for this function:

parseErrorf() [2/4]

void WAST::parseErrorf	(	ParseState &	state,
		const Token *	nextToken,
		const char *	messageFormat,
			... )

Definition at line 70 of file Parse.cpp.

    {
        va_list messageArguments;
        va_start(messageArguments,messageFormat);
        parseErrorf(state,nextToken->begin,messageFormat,messageArguments);
        va_end(messageArguments);
    }

Here is the call graph for this function:

parseErrorf() [3/4]

void WAST::parseErrorf	(	ParseState &	state,
		Uptr	charOffset,
		const char *	messageFormat,
		va_list	messageArguments )

Definition at line 45 of file Parse.cpp.

    {
        // Format the message.
        char messageBuffer[1024];
        int numPrintedChars = std::vsnprintf(messageBuffer,sizeof(messageBuffer),messageFormat,messageArguments);
        if(numPrintedChars >= 1023 || numPrintedChars < 0) { Errors::unreachable(); }
        messageBuffer[numPrintedChars] = 0;
 
        // Add the error to the state's error list.
        state.errors.emplace_back(charOffset,messageBuffer);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

parseErrorf() [4/4]

void WAST::parseErrorf	(	ParseState &	state,
		Uptr	charOffset,
		const char *	messageFormat,
			... )

Definition at line 56 of file Parse.cpp.

    {
        va_list messageArguments;
        va_start(messageArguments,messageFormat);
        parseErrorf(state,charOffset,messageFormat,messageArguments);
        va_end(messageArguments);
    }

Here is the call graph for this function:

parseF32()

F32 WAST::parseF32

(

ParseState &

state

)

Definition at line 320 of file ParseNumbers.cpp.

    {
        F32 result;
        if(!tryParseFloat(state,result))
        {
            parseErrorf(state,state.nextToken,"expected f32 literal");
            throw RecoverParseException();
        }
        return result;
    }

Here is the call graph for this function:

parseF64()

F64 WAST::parseF64

(

ParseState &

state

)

Definition at line 331 of file ParseNumbers.cpp.

    {
        F64 result;
        if(!tryParseFloat(state,result))
        {
            parseErrorf(state,state.nextToken,"expected f64 literal");
            throw RecoverParseException();
        }
        return result;
    }

Here is the call graph for this function:

parseFunctionDef()

FunctionDef WAST::parseFunctionDef	(	ModuleParseState &	state,
		const Token *	funcToken )

Definition at line 542 of file ParseFunction.cpp.

    {
        std::vector<std::string>* localDisassemblyNames = new std::vector<std::string>;
        NameToIndexMap* localNameToIndexMap = new NameToIndexMap();
 
        // Parse the function type, as a reference or explicit declaration.
        const UnresolvedFunctionType unresolvedFunctionType = parseFunctionTypeRefAndOrDecl(state,*localNameToIndexMap,*localDisassemblyNames);
        
        // Defer resolving the function type until all type declarations have been parsed.
        const Uptr functionIndex = state.module.functions.size();
        const Uptr functionDefIndex = state.module.functions.defs.size();
        const Token* firstBodyToken = state.nextToken;
        state.postTypeCallbacks.push_back(
        [functionIndex,functionDefIndex,firstBodyToken,localNameToIndexMap,localDisassemblyNames,unresolvedFunctionType]
        (ModuleParseState& state)
        {
            // Resolve the function type and set it on the FunctionDef.
            const IndexedFunctionType functionTypeIndex = resolveFunctionType(state,unresolvedFunctionType);
            state.module.functions.defs[functionDefIndex].type = functionTypeIndex;
            
            // Defer parsing the body of the function until all function types have been resolved.
            state.postDeclarationCallbacks.push_back(
            [functionIndex,functionDefIndex,firstBodyToken,localNameToIndexMap,localDisassemblyNames,functionTypeIndex]
            (ModuleParseState& state)
            {
                FunctionDef& functionDef = state.module.functions.defs[functionDefIndex];
                const FunctionType* functionType = functionTypeIndex.index == UINT32_MAX
                    ? FunctionType::get()
                    : state.module.types[functionTypeIndex.index];
 
                // Parse the function's local variables.
                ParseState localParseState(state.string,state.lineInfo,state.errors,firstBodyToken);
                while(tryParseParenthesizedTagged(localParseState,t_local,[&]
                {
                    Name localName;
                    if(tryParseName(localParseState,localName))
                    {
                        bindName(localParseState,*localNameToIndexMap,localName,functionType->parameters.size() + functionDef.nonParameterLocalTypes.size());
                        localDisassemblyNames->push_back(localName.getString());
                        functionDef.nonParameterLocalTypes.push_back(parseValueType(localParseState));
                    }
                    else
                    {
                        while(localParseState.nextToken->type != t_rightParenthesis)
                        {
                            localDisassemblyNames->push_back(std::string());
                            functionDef.nonParameterLocalTypes.push_back(parseValueType(localParseState));
                        };
                    }
                }));
                state.disassemblyNames.functions[functionIndex].locals = std::move(*localDisassemblyNames);
                delete localDisassemblyNames;
 
                // Parse the function's code.
                FunctionParseState functionState(state,localNameToIndexMap,localParseState.nextToken,functionDef);
                try
                {
                    parseInstrSequence(functionState);
                    if(!functionState.errors.size())
                    {
                        functionState.validatingCodeStream.end();
                        functionState.validatingCodeStream.finishValidation();
                    }
                }
                catch(ValidationException exception)
                {
                    parseErrorf(state,firstBodyToken,"%s",exception.message.c_str());
                }
                catch(RecoverParseException) {}
                catch(FatalParseException) {}
                functionDef.code = std::move(functionState.codeByteStream.getBytes());
            });
        });
 
        // Continue parsing after the closing parenthesis.
        findClosingParenthesis(state,funcToken-1);
        --state.nextToken;
    
        return {{UINT32_MAX},{},{}};
    }

Here is the call graph for this function:

parseFunctionType()

const IR::FunctionType * WAST::parseFunctionType	(	ModuleParseState &	state,
		NameToIndexMap &	outLocalNameToIndexMap,
		std::vector< std::string > &	outLocalDisassemblyNames )

Definition at line 121 of file Parse.cpp.

    {
        std::vector<ValueType> parameters;
        ResultType ret = ResultType::none;
 
        // Parse the function parameters.
        while(tryParseParenthesizedTagged(state,t_param,[&]
        {
            Name parameterName;
            if(tryParseName(state,parameterName))
            {
                // (param <name> <type>)
                bindName(state,outLocalNameToIndexMap,parameterName,parameters.size());
                parameters.push_back(parseValueType(state));
                outLocalDisassemblyNames.push_back(parameterName.getString());
            }
            else
            {
                // (param <type>*)
                ValueType parameterType;
                while(tryParseValueType(state,parameterType))
                {
                    parameters.push_back(parameterType);
                    outLocalDisassemblyNames.push_back(std::string());
                };
            }
        }));
 
        // Parse <= 1 result type: (result <value type>*)*
        while(state.nextToken[0].type == t_leftParenthesis
        && state.nextToken[1].type == t_result)
        {
            parseParenthesized(state,[&]
            {
                require(state,t_result);
 
                ResultType resultElementType;
                const Token* elementToken = state.nextToken;
                while(tryParseResultType(state,resultElementType))
                {
                    if(ret != ResultType::none) { parseErrorf(state,elementToken,"function type cannot have more than 1 result element"); }
                    ret = resultElementType;
                };
            });
        };
 
        return FunctionType::get(ret,parameters);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

parseFunctionTypeRefAndOrDecl()

UnresolvedFunctionType WAST::parseFunctionTypeRefAndOrDecl	(	ModuleParseState &	state,
		NameToIndexMap &	outLocalNameToIndexMap,
		std::vector< std::string > &	outLocalDisassemblyNames )

Definition at line 170 of file Parse.cpp.

    {
        // Parse an optional function type reference.
        Reference functionTypeRef;
        if(state.nextToken[0].type == t_leftParenthesis
        && state.nextToken[1].type == t_type)
        {
            parseParenthesized(state,[&]
            {
                require(state,t_type);
                if(!tryParseNameOrIndexRef(state,functionTypeRef))
                {
                    parseErrorf(state,state.nextToken,"expected type name or index");
                    throw RecoverParseException();
                }
            });
        }
 
        // Parse the explicit function parameters and result type.
        const FunctionType* explicitFunctionType = parseFunctionType(state,outLocalNameToIndexMap,outLocalDisassemblyNames);
 
        UnresolvedFunctionType result;
        result.reference = functionTypeRef;
        result.explicitType = explicitFunctionType;
        return result;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

parseI32()

U32 WAST::parseI32

(

ParseState &

state

)

Definition at line 298 of file ParseNumbers.cpp.

    {
        U32 result;
        if(!tryParseI32(state,result))
        {
            parseErrorf(state,state.nextToken,"expected i32 literal");
            throw RecoverParseException();
        }
        return result;
    }

Here is the call graph for this function:

parseI64()

U64 WAST::parseI64

(

ParseState &

state

)

Definition at line 309 of file ParseNumbers.cpp.

    {
        U64 result;
        if(!tryParseI64(state,result))
        {
            parseErrorf(state,state.nextToken,"expected i64 literal");
            throw RecoverParseException();
        }
        return result;
    }

Here is the call graph for this function:

parseI8()

U8 WAST::parseI8

(

ParseState &

state

)

Definition at line 287 of file ParseNumbers.cpp.

    {
        U32 result;
        if(!tryParseInt<U32>(state,result,INT8_MIN,UINT8_MAX))
        {
            parseErrorf(state,state.nextToken,"expected i8 literal");
            throw RecoverParseException();
        }
        return U8(result);
    }

Here is the call graph for this function:

parseModule()

bool WAST::parseModule	(	const char *	string,
		Uptr	stringLength,
		IR::Module &	outModule,
		std::vector< Error > &	outErrors )

Definition at line 638 of file ParseModule.cpp.

    {
        Timing::Timer timer;
        
        // Lex the string.
        LineInfo* lineInfo = nullptr;
        std::vector<UnresolvedError> unresolvedErrors;
        Token* tokens = lex(string,stringLength,lineInfo);
        ModuleParseState state(string,lineInfo,unresolvedErrors,tokens,outModule);
 
        try
        {
            // Parse (module ...)<eof>
            parseParenthesized(state,[&]
            {
                require(state,t_module);
                parseModuleBody(state);
            });
            require(state,t_eof);
        }
        catch(RecoverParseException) {}
        catch(FatalParseException) {}
 
        // Resolve line information for any errors, and write them to outErrors.
        for(auto& unresolvedError : unresolvedErrors)
        {
            TextFileLocus locus = calcLocusFromOffset(state.string,lineInfo,unresolvedError.charOffset);
            outErrors.push_back({std::move(locus),std::move(unresolvedError.message)});
        }
 
        // Free the tokens and line info.
        freeTokens(tokens);
        freeLineInfo(lineInfo);
 
        Timing::logRatePerSecond("lexed and parsed WAST",timer,stringLength / 1024.0 / 1024.0,"MB");
 
        return outErrors.size() == 0;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

parseModuleBody()

void WAST::parseModuleBody

(

ModuleParseState &

state

)

Definition at line 589 of file ParseModule.cpp.

    {
        const Token* firstToken = state.nextToken;
 
        // Parse the module's declarations.
        while(state.nextToken->type != t_rightParenthesis)
        {
            parseDeclaration(state);
        };
 
        // Process the callbacks requested after all type declarations have been parsed.
        if(!state.errors.size())
        {
            for(const auto& callback : state.postTypeCallbacks)
            {
                callback(state);
            }
        }
 
        // Process the callbacks requested after all declarations have been parsed.
        if(!state.errors.size())
        {
            for(const auto& callback : state.postDeclarationCallbacks)
            {
                callback(state);
            }
        }
        
        // Validate the module's definitions (excluding function code, which is validated as it is parsed).
        if(!state.errors.size())
        {
            try
            {
                IR::validateDefinitions(state.module);
            }
            catch(ValidationException validationException)
            {
                parseErrorf(state,firstToken,"validation exception: %s",validationException.message.c_str());
            }
        }
 
        // Set the module's disassembly names.
        WAVM_ASSERT_THROW(state.module.functions.size() == state.disassemblyNames.functions.size());
        WAVM_ASSERT_THROW(state.module.tables.size() == state.disassemblyNames.tables.size());
        WAVM_ASSERT_THROW(state.module.memories.size() == state.disassemblyNames.memories.size());
        WAVM_ASSERT_THROW(state.module.globals.size() == state.disassemblyNames.globals.size());
        IR::setDisassemblyNames(state.module,state.disassemblyNames);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

parseTestCommands()

WAST_API void WAST::parseTestCommands	(	const char *	string,
		Uptr	stringLength,
		std::vector< std::unique_ptr< Command > > &	outTestCommands,
		std::vector< Error > &	outErrors )

parseUTF8String()

std::string WAST::parseUTF8String

(

ParseState &

state

)

Definition at line 481 of file Parse.cpp.

    {
        const Token* stringToken = state.nextToken;
        std::string result;
        if(!tryParseString(state,result))
        {
            parseErrorf(state,stringToken,"expected string literal");
            throw RecoverParseException();
        }
 
        // Check that the string is a valid UTF-8 encoding.
        const U8* endChar = (const U8*)result.data() + result.size();
        const U8* nextChar = UTF8::validateString((const U8*)result.data(),endChar);
        if(nextChar != endChar)
        {
            const Uptr charOffset = stringToken->begin + (nextChar - (const U8*)result.data()) + 1;
            parseErrorf(state,charOffset,"invalid UTF-8 encoding");
        }
 
        return result;
    }

Here is the call graph for this function:

parseValueType()

IR::ValueType WAST::parseValueType

(

ParseState &

state

)

Definition at line 110 of file Parse.cpp.

    {
        ValueType result;
        if(!tryParseValueType(state,result))
        {
            parseErrorf(state,state.nextToken,"expected value type");
            throw RecoverParseException();
        }
        return result;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

print() [1/8]

std::string WAST::print

(

const IR::Module &

module

)

Definition at line 687 of file Print.cpp.

    {
        std::string string;
        ModulePrintContext context(module,string);
        context.printModule();
        return expandIndentation(std::move(string));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

print() [2/8]

void WAST::print	(	std::string &	string,
		const FunctionType *	functionType )

Definition at line 91 of file Print.cpp.

    {
        // Print the function parameters.
        if(functionType->parameters.size())
        {
            ScopedTagPrinter paramTag(string,"param");
            for(Uptr parameterIndex = 0;parameterIndex < functionType->parameters.size();++parameterIndex)
            {
                string += ' ';
                print(string,functionType->parameters[parameterIndex]);
            }
        }
 
        // Print the function return type.
        if(functionType->ret != ResultType::none)
        {
            string += ' ';
            ScopedTagPrinter resultTag(string,"result");
            string += ' ';
            print(string,functionType->ret);
        }
    }

Here is the call graph for this function:

print() [3/8]

void WAST::print	(	std::string &	string,
		const MemoryType &	type )

Definition at line 120 of file Print.cpp.

    {
        print(string,type.size);
    }

Here is the call graph for this function:

print() [4/8]

void WAST::print	(	std::string &	string,
		const SizeConstraints &	size )

Definition at line 85 of file Print.cpp.

    {
        string += std::to_string(size.min);
        if(size.max != UINT64_MAX) { string += ' '; string += std::to_string(size.max); }
    }

print() [5/8]

void WAST::print	(	std::string &	string,
		const TableType &	type )

Definition at line 114 of file Print.cpp.

    {
        print(string,type.size);
        string += " anyfunc";
    }

Here is the call graph for this function:

print() [6/8]

void WAST::print	(	std::string &	string,
		GlobalType	type )

Definition at line 125 of file Print.cpp.

    {
        if(type.isMutable) { string += "(mut "; }
        print(string,type.valueType);
        if(type.isMutable) { string += ")"; }
    }

Here is the call graph for this function:

print() [7/8]

void WAST::print	(	std::string &	string,
		ResultType	type )

Definition at line 83 of file Print.cpp.

{ string += asString(type); }

Here is the call graph for this function:

print() [8/8]

void WAST::print	(	std::string &	string,
		ValueType	type )

Definition at line 82 of file Print.cpp.

{ string += asString(type); }

Here is the call graph for this function:

printControlSignature()

void WAST::printControlSignature	(	std::string &	string,
		ResultType	resultType )

Definition at line 132 of file Print.cpp.

    {
        if(resultType != ResultType::none)
        {
            string += " (result ";
            print(string,resultType);
            string += ')';
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

printImport()

template<typename Type >

void WAST::printImport	(	std::string &	string,
		const Module &	module,
		const Import< Type > &	import,
		Uptr	importIndex,
		const char *	name,
		const char *	typeTag )

Definition at line 460 of file Print.cpp.

    {
        string += '\n';
        ScopedTagPrinter importTag(string,"import");
        string += " \"";
        string += escapeString(import.moduleName.c_str(),import.moduleName.length());
        string += "\" \"";
        string += escapeString(import.exportName.c_str(),import.exportName.length());
        string += "\" (";
        string += typeTag;
        string += ' ';
        string += name;
        string += ' ';
        printImportType(string,module,import.type);
        string += ')';
    }

Here is the call graph for this function:

Here is the caller graph for this function:

printImportType()

template<typename Type >

void WAST::printImportType	(	std::string &	string,
		const Module &	module,
		Type	type )

Definition at line 449 of file Print.cpp.

    {
        print(string,type);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

printImportType< IndexedFunctionType >()

template<>

void WAST::printImportType< IndexedFunctionType >	(	std::string &	string,
		const Module &	module,
		IndexedFunctionType	type )

Definition at line 454 of file Print.cpp.

    {
        print(string,module.types[type.index]);
    }

Here is the call graph for this function:

require()

void WAST::require	(	ParseState &	state,
		TokenType	type )

Definition at line 78 of file Parse.cpp.

    {
        if(state.nextToken->type != type)
        {
            parseErrorf(state,state.nextToken,"expected %s",describeToken(type));
            throw RecoverParseException();
        }
        ++state.nextToken;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

resolveFunctionType()

IR::IndexedFunctionType WAST::resolveFunctionType	(	ModuleParseState &	state,
		const UnresolvedFunctionType &	unresolvedType )

Definition at line 197 of file Parse.cpp.

    {
        if(!unresolvedType.reference)
        {
            return getUniqueFunctionTypeIndex(state,unresolvedType.explicitType);
        }
        else
        {
            // Resolve the referenced type.
            const U32 referencedFunctionTypeIndex = resolveRef(state,state.typeNameToIndexMap,state.module.types.size(),unresolvedType.reference);
 
            // Validate that if the function definition has both a type reference and explicit parameter/result type declarations, they match.
            const bool hasExplicitParametersOrResultType = unresolvedType.explicitType != FunctionType::get();
            if(hasExplicitParametersOrResultType)
            {
                if(referencedFunctionTypeIndex != UINT32_MAX
                && state.module.types[referencedFunctionTypeIndex] != unresolvedType.explicitType)
                {
                    parseErrorf(state,unresolvedType.reference.token,"referenced function type (%s) does not match declared parameters and results (%s)",
                        asString(state.module.types[referencedFunctionTypeIndex]).c_str(),
                        asString(unresolvedType.explicitType).c_str()
                        );
                }
            }
 
            return {referencedFunctionTypeIndex};
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

resolveRef()

U32 WAST::resolveRef	(	ParseState &	state,
		const NameToIndexMap &	nameToIndexMap,
		Uptr	maxIndex,
		const Reference &	ref )

Definition at line 338 of file Parse.cpp.

    {
        switch(ref.type)
        {
        case Reference::Type::index:
        {
            if(ref.index >= maxIndex)
            {
                parseErrorf(state,ref.token,"invalid index");
                return UINT32_MAX;
            }
            return ref.index;
        }
        case Reference::Type::name:
        {
            auto nameToIndexMapIt = nameToIndexMap.find(ref.name);
            if(nameToIndexMapIt == nameToIndexMap.end())
            {
                parseErrorf(state,ref.token,"unknown name");
                return UINT32_MAX;
            }
            else
            {
                return nameToIndexMapIt->second;
            }
        }
        default: Errors::unreachable();
        };
    }

Here is the call graph for this function:

Here is the caller graph for this function:

tryParseHexit()

bool WAST::tryParseHexit	(	const char *&	nextChar,
		U8 &	outValue )

Definition at line 368 of file Parse.cpp.

    {
        if(*nextChar >= '0' && *nextChar <= '9') { outValue = *nextChar - '0'; }
        else if(*nextChar >= 'a' && *nextChar <= 'f') { outValue = *nextChar - 'a' + 10; }
        else if(*nextChar >= 'A' && *nextChar <= 'F') { outValue = *nextChar - 'A' + 10; }
        else
        {
            outValue = 0;
            return false;
        }
        ++nextChar;
        return true;
    }

tryParseI32()

bool WAST::tryParseI32	(	ParseState &	state,
		U32 &	outI32 )

Definition at line 277 of file ParseNumbers.cpp.

    {
        return tryParseInt<U32>(state,outI32,INT32_MIN,UINT32_MAX);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

tryParseI64()

bool WAST::tryParseI64	(	ParseState &	state,
		U64 &	outI64 )

Definition at line 282 of file ParseNumbers.cpp.

    {
        return tryParseInt<U64>(state,outI64,INT64_MIN,UINT64_MAX);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

tryParseName()

bool WAST::tryParseName	(	ParseState &	state,
		Name &	outName )

Definition at line 252 of file Parse.cpp.

    {
        if(state.nextToken->type != t_name) { return false; }
 
        // Find the first non-name character.
        const char* firstChar = state.string + state.nextToken->begin;;
        const char* nextChar = firstChar;
        WAVM_ASSERT_THROW(*nextChar == '$');
        ++nextChar;
        while(true)
        {
            const char c = *nextChar;
            if((c >= 'a' && c <= 'z')
            || (c >= 'A' && c <= 'Z')
            || (c >= '0' && c <= '9')
            || c=='_' || c=='\'' || c=='+' || c=='-' || c=='*' || c=='/' || c=='\\' || c=='^' || c=='~' || c=='='
            || c=='<' || c=='>' || c=='!' || c=='?' || c=='@' || c=='#' || c=='$' || c=='%' || c=='&' || c=='|'
            || c==':' || c=='`' || c=='.')
            {
                ++nextChar;
            }
            else
            {
                break;
            }
        };
 
        WAVM_ASSERT_THROW(U32(nextChar - state.string) > state.nextToken->begin + 1);
        ++state.nextToken;
        WAVM_ASSERT_THROW(U32(nextChar - state.string) <= state.nextToken->begin);
        WAVM_ASSERT_THROW(U32(nextChar - firstChar) <= UINT32_MAX);
        outName = Name(firstChar,U32(nextChar - firstChar));
        return true;
    }

Here is the caller graph for this function:

tryParseNameOrIndexRef()

bool WAST::tryParseNameOrIndexRef	(	ParseState &	state,
		Reference &	outRef )

Definition at line 287 of file Parse.cpp.

    {
        outRef.token = state.nextToken;
        if(tryParseName(state,outRef.name)) { outRef.type = Reference::Type::name; return true; }
        else if(tryParseI32(state,outRef.index)) { outRef.type = Reference::Type::index; return true; }
        return false;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

tryParseResultType()

bool WAST::tryParseResultType	(	ParseState &	state,
		ResultType &	outResultType )

Definition at line 105 of file Parse.cpp.

    {
        return tryParseValueType(state,*(ValueType*)&outResultType);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

tryParseString()

bool WAST::tryParseString	(	ParseState &	state,
		std::string &	outString )

Definition at line 448 of file Parse.cpp.

    {
        if(state.nextToken->type != t_string)
        {
            return false;
        }
 
        // Parse a string literal; the lexer has already rejected unterminated strings,
        // so this just needs to copy the characters and evaluate escape codes.
        const char* nextChar = state.string + state.nextToken->begin;
        WAVM_ASSERT_THROW(*nextChar == '\"');
        ++nextChar;
        while(true)
        {
            switch(*nextChar)
            {
            case '\\':
            {
                ++nextChar;
                parseCharEscapeCode(nextChar,state,outString);
                break;
            }
            case '\"':
                ++state.nextToken;
                WAVM_ASSERT_THROW(state.string + state.nextToken->begin > nextChar);
                return true;
            default:
                outString += *nextChar++;
                break;
            };
        };
    }

Here is the caller graph for this function:

tryParseValueType()

bool WAST::tryParseValueType	(	ParseState &	state,
		ValueType &	outValueType )

Definition at line 88 of file Parse.cpp.

    {
        switch(state.nextToken->type)
        {
        case t_i32: ++state.nextToken; outValueType = ValueType::i32; return true;
        case t_i64: ++state.nextToken; outValueType = ValueType::i64; return true;
        case t_f32: ++state.nextToken; outValueType = ValueType::f32; return true;
        case t_f64: ++state.nextToken; outValueType = ValueType::f64; return true;
        #if ENABLE_SIMD_PROTOTYPE
        case t_v128: ++state.nextToken; outValueType = ValueType::v128; return true;
        #endif
        default:
            outValueType = ValueType::any;
            return false;
        };
    }

Here is the caller graph for this function: