public bool QueryExtension(ExtensionKind extensionKind)
{
return(false);
//if (_extensions == null) return false;
//return _extensions.TryGetValue(extensionKind, out bool value) && value;
}
public ILexicalAnalysis <TToken, TNode, TModel> extension(string keyword, ExtensionKind kind, Func <IEnumerable <TToken>, Scope, LexicalExtension <TToken>, IEnumerable <TToken> > handler)
{
//extension [identifier](args) {content}
var result = createMatch();
result
.token(keyword, named: "keyword")
.identifier(named: "id", optional: true)
.enclosed('(', ')', contents: "arguments")
.enclosed('{', '}', contents: "body")
.then(ReplaceExtension(keyword, kind, handler));
_matchers.Add(result);
//extension [identifier] {content}
result = createMatch();
result
.token(keyword, named: "keyword")
.identifier(named: "id", optional: true)
.enclosed('{', '}', contents: "body")
.then(ReplaceExtension(keyword, kind, handler));
_matchers.Add(result);
return(this);
}
public void Unserialize(UndertaleReader reader)
{
Filename = reader.ReadUndertaleString();
CleanupScript = reader.ReadUndertaleString();
InitScript = reader.ReadUndertaleString();
Kind = (ExtensionKind)reader.ReadUInt32();
Functions = reader.ReadUndertaleObject <UndertalePointerList <ExtensionFunction> >();
}
public void Unserialize(GMDataReader reader)
{
Filename = reader.ReadStringPointerObject();
FinalFunction = reader.ReadStringPointerObject();
InitFunction = reader.ReadStringPointerObject();
Kind = (ExtensionKind)reader.ReadUInt32();
Functions = new GMPointerList <ExtensionFunction>();
Functions.Unserialize(reader);
}
public bool QueryExtension(ExtensionKind extensionKind)
{
if (_extensions == null)
{
return(false);
}
return(_extensions.TryGetValue(extensionKind, out bool value) && value);
}
public override IIndentationGrammarAnalysis <SyntaxToken, SyntaxNode, GNode> indented <GNode, GRoot>(
string keyword,
ExtensionKind kind,
Action <GRoot, LexicalExtension <SyntaxToken> > init)
{
var result = new RoslynIndentationGrammarAnalysis <GNode, GRoot>(null);
var grammar = new IndentedGrammar <SyntaxToken, SyntaxNode, GNode>(
(extension, scope) =>
{
var indentRoot = IndentationParser.Parse(extension.Body, 4); //td: !!!
var root = new GRoot();
init?.Invoke(root, extension);
foreach (var child in indentRoot.Children)
{
result.transform(root, child, scope);
}
return(root);
});
result.Grammar = grammar <IndentedGrammar <SyntaxToken, SyntaxNode, GNode>, GNode>(keyword, kind, grammar);
return(result);
}
public abstract IIndentationGrammarAnalysis <TToken, TNode, GNode> indented <GNode, GRoot>(
string keyword,
ExtensionKind kind,
Action <GRoot, LexicalExtension <TToken> > init) where GRoot : GNode, new();
public IGrammarAnalysis <GNode, TToken, TNode> grammar <TGrammar, GNode>(string keyword, ExtensionKind kind, TGrammar grammar) where TGrammar : IGrammar <TToken, TNode, GNode>
{
return(new BaseGrammarAnalysis <TToken, TNode, TModel, GNode, TGrammar>(this, keyword, kind, grammar));
}
public ILexicalAnalysis <TToken, TNode, TModel> extension(string keyword, ExtensionKind kind, Func <TNode, Scope, LexicalExtension <TToken>, TNode> handler)
{
return(extension(keyword, kind, SyntacticalExtension(handler)));
}
private Func <IEnumerable <TToken>, Scope, IEnumerable <TToken> > ReplaceExtension(string keyword, ExtensionKind kind, Func <IEnumerable <TToken>, Scope, LexicalExtension <TToken>, IEnumerable <TToken> > handler)
{
return((tokens, scope) =>
{
dynamic context = scope;
var extension = new LexicalExtension <TToken>
{
Kind = kind,
Keyword = context.keyword,
Identifier = context.id != null ? context.id : default(TToken),
Arguments = context.arguments,
Body = context.body,
};
return handler(tokens, scope, extension);
});
}
public ISyntaxAnalysis <TToken, TNode, TModel> extension(string keyword, ExtensionKind kind, Func <TNode, SyntacticalExtension <TNode>, TNode> handler)
{
_extensions.Add(new SyntacticalExtension <TNode>(keyword, kind, (node, scope, ext) => handler(node, ext)));
return(this);
}
public ExtensionAttribute(ExtensionKind kind)
{
Kind = kind;
}
public BaseGrammarAnalysis(ILexicalAnalysis <TToken, TNode, TModel> lexical, string keyword, ExtensionKind kind, TGrammar grammar)
{
lexical.extension(keyword, kind, ParseExtension);
_grammar = grammar;
}
public SyntacticalExtension(string keyword, ExtensionKind kind, Func <TNode, Scope, SyntacticalExtension <TNode>, TNode> handler)
{
Keyword = keyword;
Kind = kind;
Handler = handler;
}
public Extension(int degree, Accidental accidental, ExtensionKind kind)
{
Kind = kind;
Accidental = accidental;
Degree = degree;
}
