public static UseStatement Use(Identifier databaseName)
{
UseStatement fragment = new UseStatement();
fragment.DatabaseName = databaseName;
return(fragment);
}
public override Node VisitUse([NotNull] FlyLangParser.UseContext context)
{
var use = new UseStatement(context.id().GetText());
ActionTree.UseStatements.Add(use);
return(use);
}
public object Visit(UseStatement useStatement)
{
PrintStart("use", ConsoleColor.Magenta);
PrintMiddle(StringifyModulePath(useStatement.ModulePath), ConsoleColor.Green);
_indentationLevel--;
return(null !);
}
public override void VisitUseStatement(UseStatement x)
{
_serializer.StartSerialize(typeof(UseStatement).Name, SerializeSpan(x.Span), new NodeObj("Kind", x.Kind.ToString()));
_serializer.Serialize("Aliases", x.Uses.All(u => u is SimpleUse)?
x.Uses.Where(u => u is SimpleUse).Select(u => new NodeObj(((SimpleUse)u).Alias.Name.Value, SerializeSpan(u.Span))).ToArray():
((GroupUse)x.Uses.First(u => u is GroupUse)).Uses.Select(u => new NodeObj(u.Alias.Name.Value, SerializeSpan(u.Span))).ToArray());
base.VisitUseStatement(x);
_serializer.EndSerialize();
}
public override void VisitUseStatement(UseStatement x)
{
VisitSpecificElementProlog();
SerializeToken(nameof(x.Kind), x.Kind.ToString(), null);
x.Uses.Foreach(SerializeUse);
base.VisitUseStatement(x);
}
public void ParseTest()
{
var context = new ParserContext(new Vrml97Tokenizer(new StringReader(@"
USE qwe123
")));
var statement = UseStatement.Parse(context);
Assert.AreEqual("qwe123", statement.NodeName);
}
protected internal override Node VisitUseStatement([NotNull] UseStatement node)
{
this.Builder.Append("USE DEFAULT ");
this.Visit(node.SettingFunction);
this.Builder.Append($" FOR {node.FunctionName}");
return(node);
}
public QsiChangeSearchPathActionNode VisitUseStatement(UseStatement useStatement)
{
return(new()
{
Identifiers = new[]
{
IdentifierVisitor.CreateIdentifier(useStatement.DatabaseName),
}
});
}
/// <summary>
/// Visits a <see cref="UseStatement"/>.
/// </summary>
/// <param name="node">
/// The node.
/// </param>
/// <returns>
/// The node, or a new version of the node.
/// </returns>
protected internal override Node VisitUseStatement(UseStatement node)
{
try
{
((IInternalExecutionContext)this.statements).RegisterDefault(node.SettingFunction.Name, node.FunctionName, this.Evaluate(node.SettingFunction, out bool sideEffects));
}
catch
{
// Ignore.
}
return(base.VisitUseStatement(node));
}
public override void VisitUseStatement(UseStatement x)
{
ConsumeToken(Tokens.T_USE, "use", x.Span.Start);
switch (x.Kind)
{
case AliasKind.Constant: ConsumeToken(Tokens.T_CONST, "const"); break;
case AliasKind.Function: ConsumeToken(Tokens.T_FUNCTION, "function"); break;
}
VisitElementList(x.Uses, VisitUse, Tokens.T_COMMA, ",");
ConsumeToken(Tokens.T_SEMI, ";", x.Span.End - 1);
}
public QsiChangeSearchPathActionNode VisitUseStatement(UseStatement useStatement)
{
var node = new QsiChangeSearchPathActionNode
{
Identifiers = new[]
{
IdentifierVisitor.CreateIdentifier(useStatement.DatabaseName),
}
};
SqlServerTree.PutFragmentSpan(node, useStatement);
return(node);
}
protected internal override Node VisitUseStatement(UseStatement node)
{
node = (UseStatement)base.VisitUseStatement(node);
var context = Expression.Parameter(typeof(IExecutionContext), "context");
var getValue = Expression.Lambda <Func <IExecutionContext, object> >(
GenericVisitor.Visit(
(ExecutionContextExpression e) => context,
(CompareExpression e) => e.CreateComparer(),
this.data.ConvertToLinqExpression(node.SettingFunction)),
context).Compile();
this.data.SetQueryPlan(node, new UseDefaultQueryPlan(node.SettingFunction.Name, node.FunctionName, getValue));
return(node);
}
public override void Accept(UseStatement useStmt)
{
string import = !useStmt.Relative ? useStmt.Module : Path.Combine(
Path.GetDirectoryName(useStmt.Location.File),
useStmt.Module);
/*
* Implementation detail: The use statement in all reality is simply an
* alias for the function require (); Here we translate the use statement
* into a call to the require function
*/
if (useStmt.Wildcard)
{
module.Initializer.EmitInstruction(useStmt.Location, Opcode.LoadConst,
module.DefineConstant(new IodineString(import)));
module.Initializer.EmitInstruction(useStmt.Location, Opcode.BuildTuple, 0);
module.Initializer.EmitInstruction(useStmt.Location, Opcode.LoadGlobal,
module.DefineConstant(new IodineName("require")));
module.Initializer.EmitInstruction(useStmt.Location, Opcode.Invoke, 2);
module.Initializer.EmitInstruction(useStmt.Location, Opcode.Pop);
}
else
{
IodineObject[] items = new IodineObject [useStmt.Imports.Count];
module.Initializer.EmitInstruction(useStmt.Location, Opcode.LoadConst,
module.DefineConstant(new IodineString(import)));
if (items.Length > 0)
{
for (int i = 0; i < items.Length; i++)
{
items [i] = new IodineString(useStmt.Imports [i]);
module.Initializer.EmitInstruction(useStmt.Location, Opcode.LoadConst,
module.DefineConstant(new IodineString(useStmt.Imports [i])));
}
module.Initializer.EmitInstruction(useStmt.Location, Opcode.BuildTuple, items.Length);
}
module.Initializer.EmitInstruction(useStmt.Location, Opcode.LoadGlobal,
module.DefineConstant(new IodineName("require")));
module.Initializer.EmitInstruction(useStmt.Location, Opcode.Invoke,
items.Length == 0 ? 1 : 2);
module.Initializer.EmitInstruction(useStmt.Location, Opcode.Pop);
}
}
protected virtual void ParseNodeStatement(ParserContext context)
{
var token = context.PeekNextToken();
switch (token.Text)
{
case "DEF":
ParseDefNodeStatement(context);
break;
case "USE":
var useStatement = UseStatement.Parse(context);
var node = context.FindNode(useStatement.NodeName);
context.AcceptChild(node);
break;
default:
ParseNode(context);
break;
}
}
/// <summary>
/// Visits <c>declare</c> statement and its inner statement.
/// </summary>
virtual public void VisitUseStatement(UseStatement x)
{
// nothing
}
public override void Accept(UseStatement useStmt)
{
errorLog.AddError(ErrorType.ParserError, useStmt.Location,
"use statement not valid inside function body!");
}
public virtual void EnterUseStatement(UseStatement useStatement)
{
Enter(new Use(useStatement), useStatement);
Exit();
}
/// <summary>
/// Visits a <see cref="UseStatement"/>.
/// </summary>
/// <param name="node">
/// The node.
/// </param>
/// <returns>
/// The node, or a new version of the node.
/// </returns>
protected internal virtual Node VisitUseStatement([NotNull] UseStatement node)
{
return(node.VisitChildren(this));
}
public override void Visit(UseStatement node) { this.action(node); }
public override void Accept(UseStatement useStmt)
{
}
public override void ExplicitVisit(UseStatement fragment)
{
_fragments.Add(fragment);
}
/// <summary>
/// Visits a <see cref="UseStatement"/>.
/// </summary>
/// <param name="node">
/// The node.
/// </param>
/// <returns>
/// The node, or a new version of the node.
/// </returns>
protected internal override Node VisitUseStatement(UseStatement node)
{
return(this.VisitImplementation(node) ?? base.VisitUseStatement(node));
}
public override void Accept(UseStatement useStmt)
{
errorLog.AddError(ErrorType.ParserError, useStmt.Location,
"statement can not exist inside pattern!");
}
public virtual void Accept(UseStatement useStmt)
{
}
