public ArrayInitNode(ExpressionNode[] Nodes, ArrayIndices[] Indices,
CodeString Code, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.Children = Nodes;
this.Indices = Indices;
}
public ObjectInitNode(IdentifierReference[] Members, ExpressionNode[] Nodes,
CodeString Code, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.Members = Members;
this.Children = Nodes;
}
///////////////////////////////////////////////////////////////////////
//
// NOTE: For use by InteractiveOps.Commands._break() and
// Engine.CheckBreakpoints() only.
//
internal InteractiveLoopData(
ReturnCode code,
BreakpointType breakpointType,
string breakpointName,
IToken token,
ITraceInfo traceInfo,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
HeaderFlags headerFlags,
IClientData clientData,
ArgumentList arguments
)
: this()
{
this.code = code;
this.breakpointType = breakpointType;
this.breakpointName = breakpointName;
this.token = token;
this.traceInfo = traceInfo;
this.engineFlags = engineFlags;
this.substitutionFlags = substitutionFlags;
this.eventFlags = eventFlags;
this.expressionFlags = expressionFlags;
this.headerFlags = headerFlags;
this.clientData = clientData;
this.arguments = arguments;
}
internal AsynchronousContext(
int threadId,
EngineMode engineMode,
Interpreter interpreter,
string text,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
AsynchronousCallback callback,
IClientData clientData
)
{
this.threadId = threadId;
this.engineMode = engineMode;
this.interpreter = interpreter;
this.text = text;
this.engineFlags = engineFlags;
this.substitutionFlags = substitutionFlags;
this.eventFlags = eventFlags;
this.expressionFlags = expressionFlags;
this.callback = callback;
this.clientData = clientData;
}
///////////////////////////////////////////////////////////////////////
public static IScript Create(
string name,
string group,
string description,
string type,
string text,
string fileName,
int startLine,
int endLine,
bool viaSource,
DateTime timeStamp,
EngineMode engineMode,
ScriptFlags scriptFlags,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
IClientData clientData
)
{
return(PrivateCreate(
Guid.Empty, name, group, description, type, text, fileName,
startLine, endLine, viaSource,
#if XML
XmlBlockType.None, timeStamp, null, null,
#endif
engineMode, scriptFlags, engineFlags, substitutionFlags,
eventFlags, expressionFlags, clientData));
}
/// <summary>
/// Build list of expression separated by comma
/// </summary>
/// <param name="lexemes">List of lexemes</param>
/// <param name="pos">Position of current parsed lexeme</param>
/// <param name="flags">Control flags. ExpressionFlags.None to ignore all flags</param>
/// <param name="elements">Builded expressions</param>
/// <returns>Position of a next lexeme</returns>
private int ExtractSeparatedExpressions(List <Lexeme> lexemes, int pos, ExpressionFlags flags,
out List <ValueElement> elements)
{
elements = new List <ValueElement>();
ValueElement val;
int currentLevel = 1;
++pos; //skip '('
for (int i = pos; currentLevel != 0 && i < lexemes.Count;)
{
switch (lexemes[i].Source)
{
case ";":
Compilation.WriteError("Unexpected symbol ';'. Did you forget ')' ?", lexemes[i].Line);
break;
case "(":
++currentLevel;
++i;
continue;
case ")":
--currentLevel;
if (currentLevel == 0)
{
pos = i = ParseExpression(lexemes, pos, i, flags & (~ExpressionFlags.OperationRequired)
| ExpressionFlags.AllowDefaultValue, out val) +
1;
elements.Add(val);
}
else
{
++i;
}
continue;
case ",":
if (currentLevel == 1)
{
pos = i = ParseExpression(lexemes, pos, i, flags & (~ExpressionFlags.OperationRequired)
| ExpressionFlags.AllowDefaultValue, out val) +
1;
elements.Add(val);
}
else
{
++i;
}
break;
default:
++i;
break;
}
}
return(pos);
}
protected IMatched <SkipTake> getSkipTake(ParseState state, ExpressionFlags flags)
{
var skipTake = new SkipTake();
var noSkipMatch = state.Scan("^ /(|s|) /','", Color.Whitespace, Color.Structure);
if (noSkipMatch.If(out _, out var _exception))
{
}
///////////////////////////////////////////////////////////////////////
/* INTERNAL STATIC OK */
internal static IScript CreateForPolicy(
string name,
string type,
string text,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags
)
{
return(Create(
name, null, null, type, text, TimeOps.GetUtcNow(),
EngineMode.EvaluateScript, ScriptFlags.None,
engineFlags, substitutionFlags, eventFlags,
expressionFlags, null));
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region Protected Constructors
//
// NOTE: Sets up default values for the properties we use. The MSBuild
// documentation is not entirely clear about whether or not having
// constructors is allowed; however, it does not appear to forbid
// them.
//
protected Script()
{
//
// NOTE: Get the effective interpreter creation flags from the
// environment, etc.
//
createFlags = Interpreter.GetStartupCreateFlags(null,
DefaultCreateFlags, OptionOriginFlags.Standard, true, true);
//
// NOTE: By default, we do not want any special evaluation flags.
//
engineFlags = EngineFlags.None;
//
// NOTE: By default, we want all the substitution flags.
//
substitutionFlags = SubstitutionFlags.Default;
//
// NOTE: By default, we want to handle events targeted at the
// engine.
//
eventFlags = EventFlags.Default;
//
// NOTE: By default, we want all the expression flags.
//
expressionFlags = ExpressionFlags.Default;
//
// NOTE: By default, we do not want to allow "exceptional" (non-Ok)
// success return codes.
//
exceptions = false;
//
// NOTE: By default, we want to show the exception stack trace.
//
showStackTrace = true;
}
///////////////////////////////////////////////////////////////////////
private static IScript PrivateCreate(
Guid id,
string name,
string group,
string description,
string type,
string text,
string fileName,
int startLine,
int endLine,
bool viaSource,
#if XML
XmlBlockType blockType,
DateTime timeStamp,
string publicKeyToken,
byte[] signature,
#endif
EngineMode engineMode,
ScriptFlags scriptFlags,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
IClientData clientData
)
{
return(new Script(
id, name, group, description, type, text, fileName,
startLine, endLine, viaSource,
#if XML
blockType, timeStamp, publicKeyToken, signature,
#endif
#if CAS_POLICY
DefaultEvidence,
DefaultHashValue,
DefaultHashAlgorithm,
#endif
engineMode, scriptFlags, engineFlags, substitutionFlags,
eventFlags, expressionFlags, clientData));
}
///////////////////////////////////////////////////////////////////
private static ExpressionFlags GetExpressionFlags(
NameValueCollection appSettings,
ExpressionFlags @default
)
{
try
{
string value = Utility.GetEnvironmentVariable(
ExpressionFlags, true, true);
if (String.IsNullOrEmpty(value) && (appSettings != null))
{
value = appSettings[ExpressionFlags];
}
//
// NOTE: Were we able to get the value from somewhere?
//
if (!String.IsNullOrEmpty(value))
{
Result error = null;
object enumValue = Utility.TryParseFlagsEnum(
null, typeof(ExpressionFlags), @default.ToString(),
value, null, true, true, true, ref error);
if (enumValue is ExpressionFlags)
{
return((ExpressionFlags)enumValue);
}
}
}
catch
{
// do nothing.
}
return(@default);
}
///////////////////////////////////////////////////////////////////////
public static IScript Create(
string name,
string group,
string description,
string type,
string text,
DateTime timeStamp,
EngineMode engineMode,
ScriptFlags scriptFlags,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
IClientData clientData
)
{
return(Create(
name, group, description, type, text, null, Parser.UnknownLine,
Parser.UnknownLine, false, timeStamp, engineMode, scriptFlags,
engineFlags, substitutionFlags, eventFlags, expressionFlags,
clientData));
}
private InteractiveLoopData(
bool debug,
IEnumerable <string> args,
ReturnCode code,
BreakpointType breakpointType,
string breakpointName,
IToken token,
ITraceInfo traceInfo,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
HeaderFlags headerFlags,
IClientData clientData,
ArgumentList arguments,
bool exit
)
{
this.kind = IdentifierKind.InteractiveLoopData;
this.id = AttributeOps.GetObjectId(this);
this.debug = debug;
this.args = args;
this.code = code;
this.breakpointType = breakpointType;
this.breakpointName = breakpointName;
this.token = token;
this.traceInfo = traceInfo;
this.engineFlags = engineFlags;
this.substitutionFlags = substitutionFlags;
this.eventFlags = eventFlags;
this.expressionFlags = expressionFlags;
this.headerFlags = headerFlags;
this.clientData = clientData;
this.arguments = arguments;
this.exit = exit;
}
public NamedParameterNode(CodeString Code, ExpressionNode Child, CodeString Name, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.Children = new ExpressionNode[] { Child };
this.Name = Name;
}
public ExpressionNode(CodeString Code, ExpressionFlags Flags = ExpressionFlags.None)
{
this.Code = Code;
this.Flags = Flags;
}
public InitializationNode(CodeString Code, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
}
public LabelExpressionNode(CodeString Code, string Label, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.Label = Label;
}
public OpExpressionNode(CodeString Code, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.Operator = Operator.Unknown;
this.Children = null;
}
public LinkingNode(LinkedExprNode Node, CodeString Code, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.LinkedNode = Node;
}
public IdExpressionNode(Identifier Identifier, CodeString Code, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.Identifier = Identifier;
}
public OpExpressionNode(Operator Operator, ExpressionNode[] Children, CodeString Code, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.Operator = Operator;
this.Children = Children;
}
public StrExpressionNode(CodeString Code, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
}
public DataPointerNode(CodeString Code, Assembly Assembly, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.DescPointerType = DataPointerType.Assembly;
this.Assembly = Assembly;
}
public DataPointerNode(CodeString Code, Identifier Id, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.DescPointerType = DataPointerType.Identifier;
this.Id = Id;
}
public DataPointerNode(CodeString Code, IncludedBinary IncBin, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.DescPointerType = DataPointerType.IncBin;
this.IncBin = IncBin;
}
public DataPointerNode(CodeString Code, DataPointerType Type, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.DescPointerType = Type;
}
///////////////////////////////////////////////////////////////////////
#if XML
/* INTERNAL STATIC OK */
internal static IScript CreateFromXmlNode( /* NOTE: Engine use only. */
string type,
XmlNode node,
EngineMode engineMode,
ScriptFlags scriptFlags,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
IClientData clientData,
ref Result error
)
{
try
{
XmlElement element = node as XmlElement;
if (element != null)
{
foreach (string attribute in _XmlAttribute.RequiredList)
{
if ((attribute != null) && !element.HasAttribute(attribute))
{
error = String.Format(
"missing required attribute \"{0}\"",
attribute);
return(null);
}
}
/* REQUIRED */
Guid id = element.HasAttribute(_XmlAttribute.Id) ?
new Guid(element.GetAttribute(_XmlAttribute.Id)) : Guid.Empty;
/* REQUIRED */
XmlBlockType blockType = element.HasAttribute(_XmlAttribute.Type) ?
(XmlBlockType)Enum.Parse(typeof(XmlBlockType),
element.GetAttribute(_XmlAttribute.Type), true) :
XmlBlockType.None;
/* REQUIRED */
string text = element.InnerText;
/* OPTIONAL */
string name = element.HasAttribute(_XmlAttribute.Name) ?
element.GetAttribute(_XmlAttribute.Name) : null;
/* OPTIONAL */
string group = element.HasAttribute(_XmlAttribute.Group) ?
element.GetAttribute(_XmlAttribute.Group) : null;
/* OPTIONAL */
string description = element.HasAttribute(_XmlAttribute.Description) ?
element.GetAttribute(_XmlAttribute.Description) : null;
/* OPTIONAL */
DateTime timeStamp = element.HasAttribute(_XmlAttribute.TimeStamp) ?
DateTime.Parse(element.GetAttribute(_XmlAttribute.TimeStamp)).ToUniversalTime() :
DateTime.MinValue;
/* OPTIONAL */
string publicKeyToken = element.HasAttribute(_XmlAttribute.PublicKeyToken) ?
element.GetAttribute(_XmlAttribute.PublicKeyToken) : null;
/* OPTIONAL */
byte[] signature = element.HasAttribute(_XmlAttribute.Signature) ?
Convert.FromBase64String(
element.GetAttribute(_XmlAttribute.Signature)) : null;
//
// NOTE: Create the script using the values extracted from the XML element.
//
return(PrivateCreate(
id, name, group, description, type, text, null, Parser.UnknownLine,
Parser.UnknownLine, false, blockType, timeStamp, publicKeyToken,
signature, engineMode, scriptFlags, engineFlags, substitutionFlags,
eventFlags, expressionFlags, clientData));
}
else
{
error = "xml node is not an element";
}
}
catch (Exception e)
{
error = e;
}
return(null);
}
public MacroExpressionNode(Macro Macro, CodeString Code, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.Macro = Macro;
}
///////////////////////////////////////////////////////////////////////
#region Private Constructors
private Script(
Guid id,
string name,
string group,
string description,
string type,
string text,
string fileName,
int startLine,
int endLine,
bool viaSource,
#if XML
XmlBlockType blockType,
DateTime timeStamp,
string publicKeyToken,
byte[] signature,
#endif
#if CAS_POLICY
Evidence evidence,
byte[] hashValue,
HashAlgorithm hashAlgorithm,
#endif
EngineMode engineMode,
ScriptFlags scriptFlags,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
IClientData clientData
)
{
this.kind = IdentifierKind.Script;
this.id = id;
this.name = name;
this.group = group;
this.description = description;
this.type = type;
this.parts = null; /* TODO: If we ever support scripts with multiple
* parts, change this to be a formal argument
* to this constructor and remove text? */
this.text = text;
this.fileName = fileName;
this.startLine = startLine;
this.endLine = endLine;
this.viaSource = viaSource;
#if XML
this.blockType = blockType;
this.timeStamp = timeStamp;
this.publicKeyToken = publicKeyToken;
this.signature = signature;
#endif
#if CAS_POLICY
this.evidence = evidence;
this.hashValue = hashValue;
this.hashAlgorithm = hashAlgorithm;
#endif
this.engineMode = engineMode;
this.scriptFlags = scriptFlags;
this.engineFlags = engineFlags;
this.substitutionFlags = substitutionFlags;
this.expressionFlags = expressionFlags;
this.eventFlags = eventFlags;
this.clientData = clientData;
}
public MacroArgNode(int Index, CodeString Code, ExpressionFlags Flags = ExpressionFlags.None)
: base(Code, Flags)
{
this.Index = Index;
}