public virtual QuoteFile CreateRandomFile(Identifiers allowedIdentifiers, int lineCount)
{
var quoteFile = new QuoteFile();
var randomQuotes = this.QuoteFactory.CreateListOfRandomQuotes(allowedIdentifiers, lineCount);
quoteFile.AddRange(randomQuotes);
return quoteFile;
}
public virtual List<Quote> CreateListOfRandomQuotes(Identifiers allowedIdentifiers, int count)
{
var list = new List<Quote>();
for (var i = 0; i < count; i++)
{
var quote = this.CreateRandomQuote(allowedIdentifiers);
list.Add(quote);
}
return list;
}
public void CreateRandomQuote_respects_my_authority()
{
// arrange
var factory = new QuoteFactory();
var allowedIdentifiers = new Identifiers(new List<string> { "SBUX" });
// act
var quote = factory.CreateRandomQuote(allowedIdentifiers);
// assert
Assert.That(quote.Identifier, Is.EqualTo("SBUX"));
}
public void SetUpSampleData(string containerName, int numFiles, int fileLineCount, Identifiers allowedIdentifiers)
{
var provider = new BlobProvider();
var factory = new QuoteFileFactory();
for (var n = 0; n < numFiles; n++)
{
var fileName = "stock" + n.ToString() + ".txt";
var file = factory.CreateRandomFile(allowedIdentifiers, fileLineCount);
provider.CreateBlob(containerName, fileName, file.ToString());
}
}
public void CreateRandomFile_creates_expected_number_of_lines()
{
// arrange
var factory = new QuoteFileFactory();
var allowedIdentifiers = new List<string> {"MSFT", "CSCO", "AMZN", "SBUX"};
var identifiers = new Identifiers(allowedIdentifiers);
var expectedLines = 100;
// act
var file = factory.CreateRandomFile(identifiers, expectedLines);
// assert
var fileContents = file.ToString();
AssertHelper.AssertHasLines(fileContents, expectedLines);
}
public virtual Quote CreateRandomQuote(Identifiers allowedIdentifiers)
{
var count = allowedIdentifiers.Count;
var rand = this.Rand.Next(0, count);
var chosenIdentifier = allowedIdentifiers[rand];
var ticker = this.TickerFactory.CreateRandomTicker();
var quoteDate = this.DateUtils.GetRandomDate();
var quote = new Quote
{
Identifier = chosenIdentifier,
Price = ticker.Price,
QuoteDate = quoteDate,
};
return quote;
}
public void OneTimeSetup_Method()
{
var identifiers = new Identifiers(
new List<string>
{
"MSFT",
"AMZN",
"SBUX",
"CSCO",
"F",
"X",
"T",
"BA",
"ANTHONY",
"CLOUD302"
});
var writer = new StockDataWriter();
writer.SetUpSampleData("stockdata2", 2, 100000, identifiers);
}
static TimePickerIsDropDownOpenDesignModeValueProvider()
{
_propertyIdentifier = new PropertyIdentifier(typeof(SSWC.TimePicker), "IsDropDownOpen");
Identifiers.Add(typeof(SSWC.TimePicker), _propertyIdentifier);
}
private Purchase(PurchaseData purchaseData, string jsonPurchaseData, string signature)
{
_purchaseData = purchaseData;
_identifiers = new Identifiers(_purchaseData.obfuscatedAccountId, _purchaseData.obfuscatedProfileId);
_purchaseReceipt = new PurchaseReceipt(jsonPurchaseData, signature);
}
protected override void Body(dynamic node = null)
{
int id = Identifiers.GetInstructionID();
if (node.ResultType != null || node.ResultType2 != null)
{
Lines.AppendLine("using Mosa.Compiler.MosaTypeSystem;");
Lines.AppendLine();
}
Lines.AppendLine("namespace Mosa.Compiler.Framework.IR");
Lines.AppendLine("{");
Lines.AppendLine("\t/// <summary>");
Lines.AppendLine("\t/// " + node.Name);
if (!string.IsNullOrWhiteSpace(node.Description))
{
Lines.AppendLine("\t\t/// " + node.Description);
}
Lines.AppendLine("\t/// </summary>");
Lines.AppendLine("\t/// <seealso cref=\"Mosa.Compiler.Framework.IR.BaseIRInstruction\" />");
Lines.AppendLine("\tpublic sealed class " + node.Name + " : BaseIRInstruction");
Lines.AppendLine("\t{");
Lines.AppendLine("\t\tpublic override int ID { get { return " + id.ToString() + "; } }");
Lines.AppendLine();
Lines.AppendLine("\t\tpublic " + node.Name + "()");
Lines.AppendLine("\t\t\t: base(" + node.OperandCount + ", " + node.ResultCount + ")");
Lines.AppendLine("\t\t{");
Lines.AppendLine("\t\t}");
if (node.FlowControl != null && node.FlowControl != "Next")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override FlowControl FlowControl { get { return FlowControl." + node.FlowControl + "; } }");
}
if (node.ResultType != null && node.ResultType != "")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override BuiltInType ResultType { get { return BuiltInType." + node.ResultType + "; } }");
}
if (node.ResultType2 != null && node.ResultType2 != "")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override BuiltInType ResultType2 { get { return BuiltInType." + node.ResultType2 + "; } }");
}
if (node.IgnoreDuringCodeGeneration != null && node.IgnoreDuringCodeGeneration == "true")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override bool IgnoreDuringCodeGeneration { get { return true; } }");
}
if (node.IgnoreInstructionBasicBlockTargets != null && node.IgnoreInstructionBasicBlockTargets == "true")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override bool IgnoreInstructionBasicBlockTargets { get { return true; } }");
}
if (node.VariableOperands != null && node.VariableOperands == "true")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override bool VariableOperands { get { return true; } }");
}
if (node.Commutative != null && node.Commutative == "true")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override bool IsCommutative { get { return true; } }");
}
if (node.MemoryWrite != null && node.MemoryWrite == "true")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override bool IsMemoryWrite { get { return true; } }");
}
if (node.MemoryRead != null && node.MemoryRead == "true")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override bool IsMemoryRead { get { return true; } }");
}
if (node.IOOperation != null && node.IOOperation == "true")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override bool IsIOOperation { get { return true; } }");
}
if (node.IRUnspecifiedSideEffect != null && node.IRUnspecifiedSideEffect == "true")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override bool HasIRUnspecifiedSideEffect { get { return true; } }");
}
if (node.ParameterLoad != null && node.ParameterLoad == "true")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override bool IsParameterLoad { get { return true; } }");
}
if (node.ParameterStore != null && node.ParameterStore == "true")
{
Lines.AppendLine();
Lines.AppendLine("\t\tpublic override bool IsParameterStore { get { return true; } }");
}
Lines.AppendLine("\t}");
Lines.AppendLine("}");
}
static AccordionItemIsSelectedDesignModeValueProvider()
{
_propertyIdentifier = new PropertyIdentifier(typeof(SSWC.AccordionItem), "IsSelected");
Identifiers.Add(typeof(SSWC.AccordionItem), _propertyIdentifier);
}
public bool HasAnyIdentifiers(IEnumerable <string> identifiers) => Identifiers.HasAny(identifiers);
public int GetAvailableIdentifiersCount(DateTime startDate, DateTime endDate, Type userType)
{
return(Identifiers.Count(i => i.IsAvailable(startDate, endDate, userType) || i.IsOverridable(startDate, endDate, userType)));
}
internal IEnumerable <Reservation> GetReservationRange(DateTime startDate, DateTime endDate)
{
return(Identifiers.SelectMany(i => i.GetDetailRange(startDate, endDate).Select(d => d.Reservation)));
}
public TipRequest()
{
identifiers = new Identifiers();
parameterMaps = new ParameterMaps();
}
public ParameterMap()
{
identifiers = new Identifiers();
valueList = new ValueList();
}
public void SimpleValuesAreEqual()
{
var value = Random.String();
Identifiers.NhsNumber(value).Should().Be(Identifiers.NhsNumber(value));
}
static TReservation()
{
Identifiers
.Add(x => x.Id)
;
}
public override void ExitParameterDecl(GolangParser.ParameterDeclContext context)
{
List <ParameterInfo> parameters = new List <ParameterInfo>();
Identifiers.TryGetValue(context.identifierList(), out string[] identifiers);
// Check for variadic expression
bool hasVariadicParameter = context.GetText().Contains("...");
if (!Types.TryGetValue(context.type(), out TypeInfo typeInfo))
{
typeInfo = TypeInfo.ObjectType;
}
if (identifiers != null)
{
for (int i = 0; i < identifiers.Length; i++)
{
string identifier = SanitizedIdentifier(identifiers[i]);
// Check for unnamed parameters
if (string.IsNullOrWhiteSpace(identifier))
{
identifier = $"_p{parameters.Count}";
}
if (i == identifiers.Length - 1 && hasVariadicParameter)
{
TypeInfo variadicType = ConvertByRefToBasicPointer(typeInfo.Clone());
if (variadicType.TypeClass != TypeClass.Array)
{
variadicType.TypeClass = TypeClass.Array;
variadicType.TypeName += "[]";
variadicType.FullTypeName += "[]";
}
parameters.Add(new ParameterInfo
{
Name = identifier,
Type = variadicType,
IsVariadic = true,
});
}
else
{
parameters.Add(new ParameterInfo
{
Name = identifier,
Type = typeInfo,
IsVariadic = false
});
}
}
}
else if (hasVariadicParameter)
{
string identifier = $"_p{parameters.Count}";
// Unnamed variadic parameter
parameters.Add(new ParameterInfo
{
Name = identifier,
Type = ConvertByRefToBasicPointer(typeInfo),
IsVariadic = true
});
}
else
{
string identifier = $"_p{parameters.Count}";
// Unnamed parameter
parameters.Add(new ParameterInfo
{
Name = identifier,
Type = typeInfo,
IsVariadic = false
});
}
m_parameterDeclarations[context] = parameters;
}
string GetFormattedIdentifiers(int count)
{
return(String.Join(".", (from n in Identifiers.Take(count) select Util.ToPascalCase(n)).ToArray()));
}
string GetJavaIdentifiers(int count)
{
return(String.Join(".", Identifiers.Take(count)));
}
public override void ExitVarSpec(GoParser.VarSpecContext context)
{
if (!Identifiers.TryGetValue(context.identifierList(), out string[] identifiers))
public TipMap()
{
parameterMaps = new ParameterMaps();
identifiers = new Identifiers();
}
Identifier ReadIdentifer(IdContainer Container, Identifier Parent)
{
var IdScope = Container.GetParent <IdentifierScope>();
if (IdScope == null || IdScope.Identifier != Parent)
{
throw new ApplicationException();
}
var IdPos = Reader.BaseStream.Position - BeginningPos;
if (IdPos != ReadLEB128_Long())
{
throw new InvalidAssemblyException();
}
#warning CHECK
var ParentIdRef = ReadLEB128_Int();
var Byte = Reader.ReadByte();
var DeclaredIdType = (DeclaredIdType)(Byte & 15);
var Access = (IdentifierAccess)(Byte >> 4);
var FlagData = Reader.ReadUInt16();
var Flags = (IdentifierFlags)FlagData & IdentifierFlags.All;
var HasName = (FlagData & 16384) != 0;
var HasOverloads = (FlagData & 32768) != 0;
var HasSpecialName = (Flags & IdentifierFlags.SpecialName) != 0;
var Name = HasName ? new CodeString(ReadLEB128_String()) : new CodeString();
var AssemblyName = HasSpecialName ? ReadLEB128_String() : null;
var StructuredScope = Container as StructuredScope;
var IsGlobal = (Flags & IdentifierFlags.Static) != 0 || !(Container.RealContainer is StructuredScope);
var Ret = (Identifier)null;
if (DeclaredIdType == DeclaredIdType.Alias)
{
Ret = new IdentifierAlias(Container, Name, null);
ReadReference(Ret, ReferenceDestination.RealId, -1);
UpdateList.Add(Ret);
}
else if (DeclaredIdType == DeclaredIdType.Class || DeclaredIdType == DeclaredIdType.Struct)
{
StructuredType Structured;
if (DeclaredIdType == DeclaredIdType.Class)
{
Ret = Structured = new ClassType(Container, Name);
}
else
{
Ret = Structured = new StructType(Container, Name);
}
Structured.InstanceSize = ReadLEB128_Int();
if (Structured.InstanceSize <= 0)
{
throw new InvalidAssemblyException("Invalid size");
}
Structured.Align = ReadLEB128_Int();
Structured.LayoutCalculated = true;
if (!DataStoring.VerifyAlign(Structured.Align))
{
throw new InvalidAssemblyException("Invalid alingment");
}
if (DeclaredIdType == DeclaredIdType.Struct)
{
Structured.Size = Structured.InstanceSize;
}
Structured.Guid = ReadGuid();
var BaseCount = ReadLEB128_Int();
Structured.BaseStructures = new StructureBase[BaseCount];
for (var i = 0; i < BaseCount; i++)
{
ReadReferenceDeclared(Structured, ReferenceDestination.Base, i);
}
Structured.FunctionTableIndex = ReadLEB128_Int();
var Scope = new StructuredScope(Container, new CodeString(), Structured);
Container.Children.Add(Scope);
Structured.StructuredScope = Scope;
ReadIdList(Scope, Structured);
UpdateList.Add(Ret);
}
else if (DeclaredIdType == DeclaredIdType.Enum || DeclaredIdType == DeclaredIdType.Flag)
{
EnumType Enum;
if (DeclaredIdType == Zinnia.DeclaredIdType.Enum)
{
Ret = Enum = new EnumType(Container, Name, new CodeString());
}
else
{
Ret = Enum = new FlagType(Container, Name, new CodeString());
}
ReadReference(Enum, ReferenceDestination.Children, 0);
var Scope = new EnumScope(Container, new CodeString(), Enum);
Container.Children.Add(Scope);
Enum.EnumScope = Scope;
var MemberCount = ReadLEB128_Int();
if (MemberCount != 0)
{
if (MemberCount < 0)
{
throw new InvalidAssemblyException();
}
for (var i = 0; i < MemberCount; i++)
{
var ConstName = new CodeString(ReadLEB128_String());
if (!ConstName.IsValidIdentifierName)
{
throw new InvalidAssemblyException("Invalid identifier name");
}
if (Identifiers.IsDefined(Scope.IdentifierList, ConstName.ToString()))
{
throw new InvalidAssemblyException("Identifier already defined");
}
var Const = new ConstVariable(Container, ConstName, Enum, ReadConst());
Scope.IdentifierList.Add(Const);
}
}
UpdateList.Add(Enum);
}
else if (DeclaredIdType == DeclaredIdType.Function || DeclaredIdType == DeclaredIdType.Constructor)
{
Function Function;
FunctionOverloads Overloads;
if (DeclaredIdType == Zinnia.DeclaredIdType.Function)
{
Overloads = Container.GetOverload(Name.ToString());
if (IsGlobal)
{
Ret = Function = new Function(Container, Name, null, Overloads);
}
else
{
Ret = Function = new MemberFunction(Container, Name, null, Overloads);
}
}
else
{
if (HasName)
{
throw new InvalidAssemblyException("Constructors cannot have name");
}
if (StructuredScope == null)
{
throw new InvalidAssemblyException("Invalid container");
}
if (StructuredScope.ConstructorOverloads == null)
{
StructuredScope.ConstructorOverloads = new FunctionOverloads(null);
}
Overloads = StructuredScope.ConstructorOverloads;
Ret = Function = new Constructor(Container, null, Overloads, new CodeString());
}
ReadReference(Function, ReferenceDestination.Children, 0);
var OverloadIndex = HasOverloads ? ReadLEB128_Int() : 0;
for (var i = 0; i < Overloads.Functions.Count; i++)
{
var OverloadFunc = Overloads.Functions[i];
if (OverloadFunc.OverloadIndex == OverloadIndex)
{
throw new InvalidAssemblyException("Function with the same overload index");
}
/*
* if (Function.AreParametersSame(OverloadFunc))
* throw new InvalidAssemblyException("Function with the same name and parameters");*/
}
Function.OverloadIndex = OverloadIndex;
Overloads.Functions.Add(Function);
if ((Flags & IdentifierFlags.Virtual) != 0)
{
var MemberFunc = Function as MemberFunction;
MemberFunc.VirtualIndex = ReadLEB128_Int();
if ((Flags & IdentifierFlags.Override) != 0)
{
ReadReferenceDeclared(MemberFunc, ReferenceDestination.OverriddenId, -1);
}
}
Function.GlobalPointerIndex = ReadLEB128_Int();
}
else if (DeclaredIdType == DeclaredIdType.Destructor)
{
if (HasName)
{
throw new InvalidAssemblyException("Destructors cannot have name");
}
if (StructuredScope == null)
{
throw new InvalidAssemblyException("Invalid container");
}
var Function = new Destructor(Container, null, new CodeString());
ReadReference(Function, ReferenceDestination.Children, 0);
Function.GlobalPointerIndex = ReadLEB128_Int();
Ret = Function;
}
else if (DeclaredIdType == DeclaredIdType.Variable)
{
if (IsGlobal)
{
Ret = new GlobalVariable(Container, Name, null);
}
else
{
Ret = new MemberVariable(Container, Name, null);
}
ReadReference(Ret, ReferenceDestination.Children, 0);
if (!IsGlobal)
{
var MemVar = Ret as MemberVariable;
MemVar.Offset = ReadLEB128_Int();
}
else
{
var Global = Ret as GlobalVariable;
Global.GlobalPointerIndex = ReadLEB128_Int();
}
}
else if (DeclaredIdType == DeclaredIdType.Constant)
{
var Const = new ConstVariable(Container, Name, null, null);
ReadReference(Const, ReferenceDestination.Children, 0);
Const.ConstInitValue = ReadConst();
Ret = Const;
}
else if (DeclaredIdType == DeclaredIdType.Property)
{
var Property = new Property(Container, Name, (Type)null);
var PScope = new PropertyScope(Container, new CodeString(), Property);
Container.Children.Add(PScope);
Property.PropertyScope = PScope;
ReadReference(Property, ReferenceDestination.Children, 0);
ReadParameterReferences(Property);
var Data = Reader.ReadByte();
if ((Data & 1) != 0)
{
PScope.Getter = ReadIdentifer(PScope, Property) as Function;
}
if ((Data & 2) != 0)
{
PScope.Setter = ReadIdentifer(PScope, Property) as Function;
}
Ret = Property;
}
else if (DeclaredIdType == DeclaredIdType.Namespace)
{
var Scope = Container as NamespaceScope;
if (Scope == null)
{
throw new InvalidAssemblyException("Invalid container");
}
if (Access != IdentifierAccess.Public)
{
throw new InvalidAssemblyException("Invalid access");
}
var Options = new GetIdOptions()
{
Func = x => x is Namespace
};
var Namespace = Identifiers.GetMember(State, Parent, Name, Options) as Namespace;
if (Namespace == null)
{
Ret = Namespace = new Namespace(Container, Name);
}
var NewScope = new NamespaceScope(Container, new CodeString(), Namespace);
Container.Children.Add(NewScope);
Namespace.AddScope(NewScope);
ReadIdList(NewScope, Namespace);
}
else
{
throw new InvalidAssemblyException("Invalid identifier type");
}
if (Ret != null)
{
if (HasSpecialName)
{
Ret.AssemblyName = AssemblyName;
}
Ret.Access = Access;
Ret.Flags = Flags;
Ret.DescPosition = IdPos;
CurrentAssembly.Ids.Add(IdPos, Ret);
}
return(Ret);
}
public void CompositeValuesAreEqual()
{
Identifiers.Name("One", "Two")
.Should().Be(Identifiers.Name("One", "Two"));
}
public IEnumerable <MaterialIdentifier> GetAvailableIdentifiers(DateTime startDate, DateTime endDate, Type userType)
{
return(Identifiers.Where(i => i.IsAvailable(startDate, endDate, userType)));
}
public void Reset()
{
Identifiers.Clear();
IsMatch = false;
}
static TreeViewItemIsExpandedDesignModeValueProvider()
{
_propertyIdentifier = new PropertyIdentifier(typeof(SSWC.TreeViewItem), "IsExpanded");
Identifiers.Add(typeof(SSWC.TreeViewItem), _propertyIdentifier);
}
public void SimpleValuesWithDifferentValuesAreNotEqual()
{
var value = Random.String();
Identifiers.NhsNumber(value).Should().NotBe(Identifiers.NhsNumber(Random.String()));
}
public bool HasIdentifier(string identifier) => Identifiers.Has(identifier);
PluginResult ForceContinue_MemberNode(ref ExpressionNode Node,
OverloadSelectionData OverloadData = new OverloadSelectionData())
{
var Ch = Node.Children;
bool Static;
var Ch0Type = GetType(Ch[0], out Static);
if (Ch0Type == null)
{
return(PluginResult.Succeeded);
}
var MemberName = Ch[1].Code;
var Options = GetIdOptions.Default;
Options.OverloadData = OverloadData;
if (Ch0Type is NamespaceType && !Static)
{
var IdCh0 = Ch[0] as IdExpressionNode;
var Namespace = IdCh0.Identifier as Namespace;
var List = Identifiers.SearchMember(Container, Namespace, MemberName.ToString());
var Id = Identifiers.SelectIdentifier(State, List, MemberName, Options);
if (Id == null)
{
return(PluginResult.Failed);
}
Node = Parent.NewNode(new IdExpressionNode(Id, Node.Code));
if (Node == null || ResolveNode(ref Node) == PluginResult.Failed)
{
return(PluginResult.Failed);
}
return(PluginResult.Ready);
}
else if (Ch0Type is EnumType && Static)
{
var EnumType = Ch0Type as EnumType;
var Ret = EnumType.GetValue(State, MemberName);
if (Ret == null)
{
return(PluginResult.Failed);
}
Node = Parent.NewNode(new IdExpressionNode(Ret, Node.Code));
if (Node == null || ResolveNode(ref Node) == PluginResult.Failed)
{
return(PluginResult.Failed);
}
return(PluginResult.Ready);
}
else
{
var List = Identifiers.SearchMember(Container, Ch0Type, MemberName.ToString());
var Id = Identifiers.SelectIdentifier(State, List, MemberName, Options);
if (Id == null)
{
return(PluginResult.Failed);
}
if (!Identifiers.VerifyAccess(Container, Id, MemberName))
{
return(PluginResult.Failed);
}
var IdNode = Parent.NewNode(new IdExpressionNode(Id, Node.Code));
if (IdNode == null)
{
return(PluginResult.Failed);
}
if (Static)
{
Node = IdNode;
if (ResolveNode(ref Node) == PluginResult.Failed)
{
return(PluginResult.Failed);
}
return(PluginResult.Ready);
}
else
{
Ch[1] = IdNode;
}
}
return(PluginResult.Succeeded);
}
private bool tokenizer()
{
token newtoken = new token();
tokens.Clear();
int idCount = 0;
foreach (String nLexemes in lexemes)
{
if (isKeyword(nLexemes))
{
newtoken = new token(nLexemes, "Keyword");
tokens.AddLast(newtoken);
}
else if (isOperator(nLexemes))
{
newtoken = new token(nLexemes, "Operator");
tokens.AddLast(newtoken);
}
else if (isRelop(nLexemes))
{
newtoken = new token(nLexemes, "RelOp");
tokens.AddLast(newtoken);
}
else if (isPunctuation(nLexemes))
{
newtoken = new token(nLexemes, "Punctuation");
tokens.AddLast(newtoken);
}
else if (isNumber(nLexemes))
{
newtoken = new token(nLexemes, "NUM");
tokens.AddLast(newtoken);
}
else if (nLexemes == terminator)
{
newtoken = new token(nLexemes, "Terminator");
tokens.AddLast(newtoken);
}
else if (isLiteral(nLexemes))
{
newtoken = new token(nLexemes, "Literals");
tokens.AddLast(newtoken);
}
else if (isId(nLexemes))
{
// using System.CodeDom.Compiler;
CodeDomProvider provider = CodeDomProvider.CreateProvider("C#");
if (provider.IsValidIdentifier(nLexemes))
{
int i = 0;
foreach (Identifiers id in identifier)
{
if (id.identifierName == nLexemes)
{
newtoken = new token(id.identifierName, id.identifierToken);
i = 1;
}
}
if (i == 0)
{
Identifiers newId = new Identifiers(nLexemes, "ID" + idCount);
newtoken = new token(nLexemes, "ID" + idCount);
identifier.AddLast(newId);
idCount++;
}
tokens.AddLast(newtoken);
}
else
{
MessageBox.Show("Invalid Identifier: " + nLexemes);
}
}
else
{
toolStripStatusLabel1.Text = "Invalid Token";
}
}
return(true);
}
public override PluginResult NewNode(ref ExpressionNode Node)
{
for (var i = 0; i < Node.LinkedNodes.Count; i++)
{
var LNode = Node.LinkedNodes[i];
LNode.Node = ResolveNode(LNode.Node);
if (LNode.Node == null)
{
return(PluginResult.Failed);
}
}
if (Node is StrExpressionNode)
{
return(PluginResult.Interrupt);
}
else if (Node is LinkingNode)
{
return(PluginResult.Interrupt);
}
else if (Node is IdExpressionNode)
{
var IdNode = Node as IdExpressionNode;
var Id = IdNode.Identifier.RealId;
if (Id is LocalVariable)
{
if (!Container.IsSubContainerOf(Id.Container) && Container != Id.Container)
{
throw new ApplicationException();
}
}
if (Id is ConstVariable)
{
var Const = Id as ConstVariable;
if (Const.ConstInitValue == null)
{
throw new ApplicationException();
}
Node = Parent.NewNode(new ConstExpressionNode(Const.TypeOfSelf, Const.ConstInitValue, Node.Code));
if (Node == null)
{
return(PluginResult.Failed);
}
if (ConvertEnums != null && Const.TypeOfSelf == ConvertEnums)
{
Node = new OpExpressionNode(Operator.Cast, Node.Code)
{
Children = new ExpressionNode[] { Node },
Type = ConvertEnums.TypeOfValues,
};
if ((Node = Parent.NewNode(Node)) == null)
{
return(PluginResult.Failed);
}
}
return(PluginResult.Ready);
}
return(PluginResult.Interrupt);
}
else if (Node is OpExpressionNode)
{
var OpNode = Node as OpExpressionNode;
var Op = OpNode.Operator;
var Ch = OpNode.Children;
if (Op == Operator.Assignment)
{
if ((Ch[1] = ResolveNode(Ch[1])) == null)
{
return(PluginResult.Failed);
}
if ((Ch[0] = ResolveNode(Ch[0], Ch[1].Type)) == null)
{
return(PluginResult.Failed);
}
}
else if (Op == Operator.Call)
{
if (!ResolveParams(Ch))
{
return(PluginResult.Failed);
}
var OverloadData = Expressions.GetOverloadSelectData(Ch);
Ch[0] = ResolveNode(Ch[0], OverloadData: OverloadData);
if (Ch[0] == null)
{
return(PluginResult.Failed);
}
var Res = ProcessParams(ref Node);
if (Res != PluginResult.Succeeded)
{
return(Res);
}
if ((State.Language.Flags & LangaugeFlags.AllowMemberFuncStaticRef) != 0)
{
var Ch0Id = Expressions.GetIdentifier(Ch[0]);
if (Ch0Id != null && Ch0Id.IsInstanceIdentifier)
{
State.Messages.Add(MessageId.NonStatic, Ch[0].Code);
return(PluginResult.Failed);
}
}
}
else if (Op == Operator.NewArray)
{
if (!ResolveParams(Ch))
{
return(PluginResult.Failed);
}
if (Ch[0] is StrExpressionNode)
{
var Type = Container.RecognizeIdentifier(Ch[0].Code, GetIdOptions.DefaultForType);
if (Type == null)
{
return(PluginResult.Failed);
}
if (Ch.Length < 2)
{
State.Messages.Add(MessageId.ParamCount, Node.Code);
return(PluginResult.Failed);
}
Node.Type = new RefArrayType(Container, Type, Ch.Length - 1);
Node.Children = Ch.Slice(1);
return(PluginResult.Succeeded);
}
var Ch0Id = Expressions.GetIdentifier(Ch[0]);
if (Ch0Id != null && Ch0Id.RealId is Type)
{
if (Ch.Length < 2)
{
State.Messages.Add(MessageId.ParamCount, Node.Code);
return(PluginResult.Failed);
}
Node.Type = new RefArrayType(Container, Ch0Id, Ch.Length - 1);
Node.Children = Ch.Slice(1);
return(PluginResult.Succeeded);
}
}
else if (Op == Operator.NewObject)
{
if (!ResolveParams(Ch))
{
return(PluginResult.Failed);
}
Identifier ConstructType = null;
if (Ch[0] is StrExpressionNode)
{
ConstructType = Container.RecognizeIdentifier(Ch[0].Code, GetIdOptions.DefaultForType);
if (ConstructType == null)
{
return(PluginResult.Failed);
}
}
else if (Ch[0] is IdExpressionNode)
{
var IdCh0 = Ch[0] as IdExpressionNode;
if (IdCh0.Identifier.RealId is Type)
{
ConstructType = IdCh0.Identifier;
}
}
if (ConstructType != null)
{
Node.Type = ConstructType;
if (ConstructType.RealId is AutomaticType)
{
if (!(Ch[0] is IdExpressionNode))
{
Ch[0] = Parent.NewNode(new IdExpressionNode(ConstructType, Node.Code));
if (Ch[0] == null)
{
return(PluginResult.Failed);
}
}
Ch[0] = ResolveNode(Ch[0]);
return(Ch[0] == null ? PluginResult.Failed : PluginResult.Succeeded);
}
if (Ch.Length == 1 && !(ConstructType.UnderlyingClassOrRealId is ClassType))
{
OpNode.Children = Ch = null;
return(PluginResult.Succeeded);
}
var Structured = ConstructType.UnderlyingClassOrRealId as StructuredType;
if (Structured == null)
{
State.Messages.Add(MessageId.ParamCount, Node.Code);
return(PluginResult.Failed);
}
var Options = GetIdOptions.Default;
Options.OverloadData = Expressions.GetOverloadSelectData(Ch);
Options.Func = x => x is Constructor;
var Constructor = Identifiers.GetMember(State, Structured, null, Node.Code, Options);
if (Constructor == null)
{
return(PluginResult.Failed);
}
if (!Identifiers.VerifyAccess(Container, Constructor, Node.Code))
{
return(PluginResult.Failed);
}
Ch[0] = Parent.NewNode(new IdExpressionNode(Constructor, Ch[0].Code));
if (Ch[0] == null)
{
return(PluginResult.Failed);
}
}
Ch[0] = ResolveNode(Ch[0]);
if (Ch[0] == null)
{
return(PluginResult.Failed);
}
var Res = ProcessParams(ref Node);
if (Res != PluginResult.Succeeded)
{
return(Res);
}
}
else if (Op == Operator.Member)
{
if ((Ch[0] = ResolveNode(Ch[0])) == null)
{
return(PluginResult.Failed);
}
return(PluginResult.Interrupt);
}
else if (Op == Operator.Tuple || Op == Operator.ScopeResolution)
{
return(PluginResult.Interrupt);
}
else if (Ch != null)
{
for (var i = 0; i < Ch.Length; i++)
{
Ch[i] = ResolveNode(Ch[i]);
if (Ch[i] == null)
{
return(PluginResult.Failed);
}
}
return(PluginResult.Succeeded);
}
}
else if (Node.Children != null)
{
for (var i = 0; i < Node.Children.Length; i++)
{
Node.Children[i] = ResolveNode(Node.Children[i]);
if (Node.Children[i] == null)
{
return(PluginResult.Failed);
}
}
}
return(PluginResult.Succeeded);
}
protected bool autolocalhost = false; // автоматически подключаться к локальному серверу данных
/// <summary>
/// Инициализирует новый экземпляр класса
/// </summary>
protected Application()
{
try
{
ErrorHandler.InitializeErrorHandler();
ErrorHandler.OnExit += new EventHandler(ErrorHandler_OnExit);
buffer = new RSliceBuffer(72000);
manager = new DataBaseManager();
projects = new List <Project>();
commands = new List <BlockViewCommand>();
parameters = new Parameter[256];
for (int index = 0; index < parameters.Length; index++)
{
parameters[index] = new Parameter(index);
parameters[index].Identifier = Identifiers.GetGuid(index);
}
tech = new Tech();
commutator = new Commutator(tech, parameters, buffer);
panels = new List <ParametersViewPanel>();
// devManUri = new Uri("net.tcp://localhost:57000");
devManUri = new Uri("net.tcp://127.0.0.1:57000");
CheckRegistry();
LoadUri();
DevManClient.Uri = devManUri;
DevManClient.Context.Mode = UserMode.Passive;
DevManClient.Context.Role = Role.Common;
client = new devTcpManager();
Ping ping = new Ping();
PingOptions options = new PingOptions();
try
{
PingReply reply = ping.Send(devManUri.Host);
if (reply.Status == IPStatus.Success)
{
/*DevManClient.Uri = devManUri;
*
* DevManClient.Context.Mode = UserMode.Passive;
* DevManClient.Context.Role = Role.Common;*/
DevManClient.Connect();
// client = new devTcpManager();
string ip = System.Net.Dns.Resolve(devManUri.Host).AddressList[0].ToString();
//string ip = System.Net.Dns.GetHostEntry(devManUri.Host).AddressList[0].ToString();
client.Client.Host = ip;
client.Client.Port = 56000;
client.Client.Connect();
}
else
{
/*try
* {
* client = null;
* }
* catch { }*/
}
}
catch { }
}
catch (Exception ex)
{
ErrorHandler.WriteToLog(this, new ErrorArgs(ex.Message, ErrorType.Fatal));
}
}
private void DefineLexem()
{
bool f = false;
switch (currentState)
{
case State.Identificator:
f = SearchInTable(Keywords);
nextLexem.type = LexemType.Keyword;
if (!f)
{
f = SearchInTable(Identifiers);
nextLexem.type = LexemType.Identifier;
}
if (!f)
{
nextLexem.code = lastId++;
Identifiers.Add(currentLexem.ToString(), nextLexem.code);
nextLexem.type = LexemType.Identifier;
}
OutputLexem();
break;
case State.Variable:
f = SearchInTable(Constants);
if (!f)
{
nextLexem.code = lastConst++;
Constants.Add(currentLexem.ToString(), nextLexem.code);
}
nextLexem.type = LexemType.Variable;
OutputLexem();
break;
case State.Separtor:
SearchInTable(Separators);
nextLexem.type = LexemType.Separtor;
nextLexem.line = CurrentLine;
nextLexem.column = CurrentColumn;
OutputLexem();
break;
case State.WhiteSpace:
break;
case State.MultiSeparator:
f = SearchInTable(MultiSeparators);
if (f)
{
nextLexem.type = LexemType.MultiSymbolicSeparator;
nextLexem.line = CurrentLine - currentLexem.Length;
nextLexem.column = CurrentColumn - currentLexem.Length + 1;
OutputLexem();
}
else
{
int i = 1;
string separators = currentLexem.ToString();
foreach (var item in separators)
{
currentLexem.Clear();
currentLexem.Append(item);
nextLexem.line = CurrentLine;
nextLexem.column = CurrentColumn - separators.Length + i;
i++;
if (SearchInTable(Separators))
{
nextLexem.type = LexemType.Separtor;
OutputLexem();
}
else
{
currentState = State.Separtor;
DefineError(item);
}
}
}
break;
}
}
static TIten()
{
Identifiers
.Add(x => x.Id)
;
}
public override Statement CloneStatement()
{
return(new ReturnAssignment(
Identifiers.Clone() as ExpressionList,
Invocation.CloneExpr() as InvocationExpression));
}
