public ArrayAdapter(IValue array) { _array = array; _list = array.ActualType.CreateGenericListInstance().As<IList>(); _listType = _list.GetType().ToCachedType(); _listType.InvokeAction("AddRange", _list, array.Instance); }
public ReadLineResult ReadLine(out SectionType secType, out string line, out string key, out IValue value) { secType = SectionType.None; line = string.Empty; key = string.Empty; value = null; if (streamReader == null) { return ReadLineResult.Error; } line = streamReader.ReadLine(); if (line == null) { return ReadLineResult.Null; } if (line == string.Empty) { return ReadLineResult.OK; } string trimmedLine = line.Trim(); if (trimmedLine == string.Empty) { secType = SectionType.Spaces; return ReadLineResult.OK; } // line = trimmedLine; return this.ParseLine(trimmedLine, ref secType, out key, out value); }
public void AddComponent(XmlElement parent, PropertyAuditingData propertyAuditingData, IValue value, ICompositeMapperBuilder mapper, string entityName, EntityXmlMappingData xmlMappingData, bool firstPass, bool insertable) { var propComponent = (Component) value; var componentMapper = mapper.AddComponent(propertyAuditingData.GetPropertyData(), propComponent.ComponentClassName); // The property auditing data must be for a component. var componentAuditingData = (ComponentAuditingData) propertyAuditingData; // Adding all properties of the component foreach (var property in propComponent.PropertyIterator) { var componentPropertyAuditingData = componentAuditingData.GetPropertyAuditingData(property.Name); // Checking if that property is audited if (componentPropertyAuditingData != null) { mainGenerator.AddValue(parent, property.Value, componentMapper, entityName, xmlMappingData, componentPropertyAuditingData, property.IsInsertable && insertable, firstPass); } } }
public void Send( IValue receiver, ValueSymbol selector, IList<IValue> args, VM vm, SourceInfo info ) { IValueFunc func = null; foreach (ValueSymbol klass in KlassList) { if (vm.Env.LookupMethod(klass, selector, out func)) { break; } } if (func == null) { throw new RheaException( string.Format( "invalid selector for {0}: {1}", receiver, selector.Name.ToIdentifier() ), info ); } List<IValue> newArgs = new List<IValue>(); newArgs.Add(receiver); newArgs.AddRange(args); func.Call(newArgs, vm, info); }
public static IPersistentValue MapValue(IValue value) { var component = value as Component; if(component != null) { return new PersistentComponent(MapProperties(component.PropertyIterator)); } var collection = value as Collection; if(collection != null) { return new PersistentCollection(MapValue(collection.Element)); } var toOne = value as ToOne; if(toOne != null) { return new PersistentToOne(toOne.ReferencedEntityName); } var oneToMany = value as OneToMany; if(oneToMany != null) { return new PersistentOneToMany(oneToMany.ReferencedEntityName); } return null; }
public ExceptionDialog(IThread thread) { InitializeComponent(); this.Icon = _icon; _exceptionValue = thread.CurrentException; _sourceLocation = thread.GetCurrentSourceRange(); // no need to hook to UILanguageChanged as this dialog will be closed // before the user gets any chance to update the UI language. var _componentMuiIdentifiers = new Dictionary<object, string>() { {this, "ExceptionDialog.Title"}, {headerLabel, "ExceptionDialog.ExceptionOccured"}, {fileLabel, "ExceptionDialog.File"}, {locationLabel, "ExceptionDialog.Location"}, {messageLabel, "ExceptionDialog.Message"}, {closeButton, "ExceptionDialog.Close"}, {goToFileButton, "ExceptionDialog.GoToFile"}, {detailsButton, "ExceptionDialog.Details"}, }; DebuggerBase.Instance.MuiProcessor.ApplyLanguageOnComponents(_componentMuiIdentifiers); fileTextBox.Text = _sourceLocation.FilePath.FullPath; locationTextBox.Text = DebuggerBase.Instance.MuiProcessor.GetString("ExceptionDialog.LocationFormat", "line=" + _sourceLocation.Line, "column=" + _sourceLocation.Column); messageTextBox.Text = _exceptionValue.ValueAsString(thread); }
public void ForceEarlyReturn(IValue returnValue) { Contract.Requires<ArgumentNullException>(returnValue != null, "returnValue"); Contract.Requires<VirtualMachineMismatchException>(this.GetVirtualMachine().Equals(returnValue.GetVirtualMachine())); throw new NotImplementedException(); }
private void AddCustomValue(XmlElement parent, PropertyAuditingData propertyAuditingData, IValue value, ISimpleMapperBuilder mapper, bool insertable, bool key) { if (parent != null) { XmlElement prop_mapping = MetadataTools.AddProperty(parent, propertyAuditingData.Name, null, insertable, key); //CustomType propertyType = (CustomType) value.getType(); XmlElement type_mapping = parent.OwnerDocument.CreateElement("type"); prop_mapping.AppendChild(type_mapping); type_mapping.SetAttribute("name", value.GetType().Name); if (value is SimpleValue) { IDictionary<string, string> typeParameters = ((SimpleValue)value).TypeParameters; if (typeParameters != null) { foreach (KeyValuePair<string,string> paramKeyValue in typeParameters) { XmlElement type_param = parent.OwnerDocument.CreateElement("param"); type_param.SetAttribute("name", (String) paramKeyValue.Key); type_param["name"].Value = paramKeyValue.Value; } } } MetadataTools.AddColumns(prop_mapping, (IEnumerator<ISelectable>)value.ColumnIterator); } if (mapper != null) { mapper.Add(propertyAuditingData.getPropertyData()); } }
//@SuppressWarnings({"unchecked"}) public void AddOneToOneNotOwning(PropertyAuditingData propertyAuditingData, IValue value, ICompositeMapperBuilder mapper, String entityName) { OneToOne propertyValue = (OneToOne)value; String owningReferencePropertyName = propertyValue.ReferencedPropertyName; // mappedBy EntityConfiguration configuration = mainGenerator.EntitiesConfigurations[entityName]; if (configuration == null) { throw new MappingException("An audited relation to a non-audited entity " + entityName + "!"); } IdMappingData ownedIdMapping = configuration.IdMappingData; if (ownedIdMapping == null) { throw new MappingException("An audited relation to a non-audited entity " + entityName + "!"); } String lastPropertyPrefix = MappingTools.createToOneRelationPrefix(owningReferencePropertyName); String referencedEntityName = propertyValue.ReferencedEntityName; // Generating the id mapper for the relation IIdMapper ownedIdMapper = ownedIdMapping.IdMapper.PrefixMappedProperties(lastPropertyPrefix); // Storing information about this relation mainGenerator.EntitiesConfigurations[entityName].AddToOneNotOwningRelation( propertyAuditingData.Name, owningReferencePropertyName, referencedEntityName, ownedIdMapper); // Adding mapper for the id PropertyData propertyData = propertyAuditingData.getPropertyData(); mapper.AddComposite(propertyData, new OneToOneNotOwningMapper(owningReferencePropertyName, referencedEntityName, propertyData)); }
public void CreateAssignment(IValueRegister targetRegister, IValue value) { JavaScriptRegister registerToUse = targetRegister as JavaScriptRegister; JavaScriptValue valueToUse = value as JavaScriptValue; AppendFormatLine("{0} = {1};", registerToUse.Expression, valueToUse.Expression); }
internal MethodExitEventArgs(VirtualMachine virtualMachine, SuspendPolicy suspendPolicy, EventRequest request, ThreadReference thread, Location location, IValue returnValue) : base(virtualMachine, suspendPolicy, request, thread, location) { Contract.Requires<ArgumentNullException>(returnValue != null, "returnValue"); _returnValue = returnValue; }
public void CreateAssignment(IValueRegister targetRegister, IValue value) { JavaScriptRegister registerToUse = targetRegister as JavaScriptRegister; JavaScriptValue valueToUse = value as JavaScriptValue; AppendFormatLine("{0} = {1};", registerToUse.Expression, valueToUse.Expression.Replace("\n", "\n" + new String('\t', IndentationLevel))); }
public override void CallAsFunction(int methodNumber, IValue[] arguments, out IValue retValue) { if (methodNumber == 0) retValue = ValueFactory.Create(this.Count()); else retValue = null; }
private static void AddCustomValue(XmlElement parent, PropertyAuditingData propertyAuditingData, IValue value, ISimpleMapperBuilder mapper, bool insertable, bool key, System.Type typeOfUserImplementation) { if (parent != null) { var prop_mapping = MetadataTools.AddProperty(parent, propertyAuditingData.Name, null, insertable, key); MetadataTools.AddColumns(prop_mapping, value.ColumnIterator.OfType<Column>()); var typeElement = parent.OwnerDocument.CreateElement("type"); typeElement.SetAttribute("name", typeOfUserImplementation.AssemblyQualifiedName); var simpleValue = value as SimpleValue; if (simpleValue != null) { var typeParameters = simpleValue.TypeParameters; if (typeParameters != null) { foreach (var paramKeyValue in typeParameters) { var type_param = typeElement.OwnerDocument.CreateElement("param"); type_param.SetAttribute("name", paramKeyValue.Key); type_param.InnerText = paramKeyValue.Value; typeElement.AppendChild(type_param); } } } prop_mapping.AppendChild(typeElement); } if (mapper != null) { mapper.Add(propertyAuditingData.GetPropertyData()); } }
/// <summary> /// Constructor /// </summary> /// <param name="variable"></param> /// <param name="previousValue"></param> /// <param name="newValue"></param> public Change(IVariable variable, IValue previousValue, IValue newValue) { Variable = variable; PreviousValue = previousValue; NewValue = newValue; Applied = false; }
public static ObjectNodeBase CreateDeserializable(string name, IValue @object, INode parent, Context context, CachedMember member = null) { var type = @object.SpecifiedType; var kind = GetTypeKind(type, context.Options); if (kind == TypeKind.Simple) { if (parent == null) throw new TypeNotSupportedException("simple type", @object.SpecifiedType, Mode.Deserialize, "complex types"); return new ValueNode(context, name, @object, member, parent); } Func<object> factory = () => ObjectFactory.CreateInstance(type, context.Options.Deserialization.ObjectFactory, parent.MapOrDefault(x => x.Value)); if (member == null || parent == null) @object.Instance = factory(); else @object = ValueFactory.Create(@object, factory); switch (kind) { case TypeKind.Dictionary: return new DictionaryNode(context, name, @object, member, parent); case TypeKind.Enumerable: return new EnumerableNode(context, name, @object, member, parent); default: return new ObjectNode(context, name, @object, member, parent); } }
public MemberDefinition(CachedMember member, string name, IValue value) { Name = name; Value = value; Member = member; IsNodeType = value.SpecifiedType.Type.CanBeCastTo<INode>(); }
public static IVariable Create(IValue val) { return new Variable() { _val = val }; }
//@SuppressWarnings({"unchecked"}) public void AddComponent(XmlElement parent, PropertyAuditingData propertyAuditingData, IValue value, ICompositeMapperBuilder mapper, String entityName, EntityXmlMappingData xmlMappingData, bool firstPass) { Component prop_component = (Component) value; ICompositeMapperBuilder componentMapper = mapper.AddComponent(propertyAuditingData.getPropertyData(), prop_component.ComponentClassName); // The property auditing data must be for a component. ComponentAuditingData componentAuditingData = (ComponentAuditingData) propertyAuditingData; // Adding all properties of the component IEnumerator<Property> properties = (IEnumerator<Property>) prop_component.PropertyIterator.GetEnumerator(); while (properties.MoveNext()) { Property property = properties.Current; PropertyAuditingData componentPropertyAuditingData = componentAuditingData.getPropertyAuditingData(property.Name); // Checking if that property is audited if (componentPropertyAuditingData != null) { mainGenerator.AddValue(parent, property.Value, componentMapper, entityName, xmlMappingData, componentPropertyAuditingData, property.IsInsertable, firstPass); } } }
public bool AddBasic(XmlElement parent, PropertyAuditingData propertyAuditingData, IValue value, ISimpleMapperBuilder mapper, bool insertable, bool key) { var type = value.Type; var custType = type as CustomType; var compType = type as CompositeCustomType; if (type is ImmutableType || type is MutableType) { AddSimpleValue(parent, propertyAuditingData, value, mapper, insertable, key); } else if (custType != null) { AddCustomValue(parent, propertyAuditingData, value, mapper, insertable, key, custType.UserType.GetType()); } else if (compType != null) { AddCustomValue(parent, propertyAuditingData, value, mapper, insertable, key, compType.UserType.GetType()); } else { return false; } return true; }
private IValue doFunctionCall(ParserRuleContext context, string targetFunctionName, List<IValue> parameters, IValue target, ClepsType targetType, bool allowVoidReturn) { IValue dereferencedTarget = target == null? null : GetDereferencedRegisterOrNull(target); BasicClepsType dereferencedType = target == null? targetType as BasicClepsType : dereferencedTarget.ExpressionType as BasicClepsType; if (dereferencedType == null) { string errorMessage = String.Format("Could not dereference expression on type {0}", targetType.GetClepsTypeString()); Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage)); //just return something to avoid stalling return CodeGenerator.CreateByte(0); } ClepsClass targetClepsClass = ClassManager.GetClass(dereferencedType.GetClepsTypeString()); List<ClepsVariable> functionOverloads; bool isStatic; if (targetClepsClass.StaticMemberMethods.ContainsKey(targetFunctionName)) { isStatic = true; functionOverloads = targetClepsClass.StaticMemberMethods[targetFunctionName]; } else if (target != null && targetClepsClass.MemberMethods.ContainsKey(targetFunctionName)) { isStatic = false; functionOverloads = targetClepsClass.MemberMethods[targetFunctionName]; } else { string errorMessage = String.Format("Class {0} does not contain a {1}static function called {2}.", targetClepsClass.FullyQualifiedName, target == null? "" : "member or ",targetFunctionName); Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage)); //Just return something to avoid stalling compilation return CodeGenerator.CreateByte(0); } int matchedPosition; string fnMatchErrorMessage; if (!FunctionOverloadManager.FindMatchingFunctionType(TypeManager, functionOverloads, parameters, out matchedPosition, out fnMatchErrorMessage)) { Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, fnMatchErrorMessage)); //Just return something to avoid stalling compilation return CodeGenerator.CreateByte(0); } FunctionClepsType chosenFunctionType = functionOverloads[matchedPosition].VariableType as FunctionClepsType; if (!allowVoidReturn && chosenFunctionType.ReturnType == VoidClepsType.GetVoidType()) { string errorMessage = String.Format("Function {0} does not return a value", targetFunctionName); Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage)); //Just return something to avoid stalling compilation return CodeGenerator.CreateByte(0); } IValue returnValue = CodeGenerator.GetFunctionCallReturnValue(isStatic? null : dereferencedTarget, dereferencedType, targetFunctionName, chosenFunctionType, parameters); return returnValue; }
/// <summary> /// Checks the return value for a conversion to EFS type /// </summary> /// <param name="value"></param> /// <param name="type"></param> public void CheckReturnValue(IValue value, Type type) { if (value == null) { throw new FaultException<EFSServiceFault>( new EFSServiceFault("Cannot convert to EFS value " + DisplayValue() + " for type " + type.FullName)); } }
public MemberValue(IValue value, CachedMember member, Func<CachedType, bool> useActualType) { _value = value; _member = member; var type = member.Type; SpecifiedType = useActualType(type) && Instance != null ? Instance.ToCachedType() : type; IsReadonly = _member.IsReadonly; }
public void SetValue(ILocalVariable variable, IValue value) { Contract.Requires<ArgumentNullException>(variable != null, "variable"); Contract.Requires<VirtualMachineMismatchException>(this.GetVirtualMachine().Equals(variable.GetVirtualMachine())); Contract.Requires<VirtualMachineMismatchException>(value == null || this.GetVirtualMachine().Equals(value.GetVirtualMachine())); throw new NotImplementedException(); }
public int CompareTo(IValue other) { GuidWrapper otherUuid = other.GetRawValue() as GuidWrapper; if (otherUuid == null) throw RuntimeException.ComparisonNotSupportedException(); return _value.CompareTo(otherUuid._value); }
public void TestCombineDifInitial(IDeclaredParameter loopVarName, IValue ivalSize, IValue initialValue1, IValue initialValue2) { var p1 = new StatementForLoop(loopVarName, ivalSize, initialValue1); var p2 = new StatementForLoop(loopVarName, ivalSize, initialValue2); var r = p1.TryCombineStatement(p2, new dummyOpt()); Assert.IsFalse(r, "Should always be equal"); }
public EntityValueSetState(Guid metadataDefinitionIdentity, MetadataDefinitionName name, IDataType dataType, string regex, IValue supplied) { MetadataDefinitionIdentity = metadataDefinitionIdentity; Name = name; DataType = dataType; Regex = regex; Values = supplied; }
public HttpRequestBodyString(string body, IValue encoding = null) { _data = body; if (encoding == null) _encoding = new UTF8Encoding(true); else _encoding = TextEncodingEnum.GetEncoding(encoding); }
public void SetValue(IField field, IValue value) { Contract.Requires<ArgumentNullException>(field != null, "field"); Contract.Requires<VirtualMachineMismatchException>(this.GetVirtualMachine().Equals(field.GetVirtualMachine())); Contract.Requires<VirtualMachineMismatchException>(value == null || this.GetVirtualMachine().Equals(value.GetVirtualMachine())); throw new NotImplementedException(); }
public static COMWrapperContext Create(string progId, IValue[] arguments) { var type = Type.GetTypeFromProgID(progId, true); object instance = Activator.CreateInstance(type, MarshalArguments(arguments)); return InitByInstance(type, instance); }
public virtual void SetPropValue(int propNum, IValue newVal) { throw new NotImplementedException(); }
public void InjectGlobalProperty(string name, IValue value, bool readOnly) { _env.InjectGlobalProperty(value, name, readOnly); }
public void Delete(IValue Column) { Column = Column.GetRawValue(); _columns.Remove(GetColumnByIIndex(Column)); }
public override void SetPropValue(int propNum, IValue newVal) { throw new RuntimeException("Свойство только для чтения"); }
/// <summary> /// Constructor for this class. /// </summary> /// <param name="value">The parameter value associated with the instruction. The type of the value depends on the loader instruction it is connected with</param> /// <param name="textLength">The length (character count) of the value in the source code it was parsed from</param> public LoaderInstructionParameters(IValue value, int textLength) { mValue = value; mTextLength = textLength; }
internal static IValue Compare(List <IValue> list, Scope scope) { IValue first = list.First(); return(first.MetaType.Compare.Invoke(list, scope).First()); }
public void SetParameter(string ParametrName, IValue ParametrValue) { _parameters.Insert(ParametrName, ParametrValue); }
public bool Equal(IValue value) => ReferenceEquals(this, value);
bool IEquatable <IValue> .Equals(IValue other) => other is Null;
public ValueBuilderImpl(IValue value) : this(_ => value) { }
/// <inheritdoc/> public override bool CanParseLiteral(IValue value) => true;
/// <inheritdoc/> public override object ParseLiteral(IValue value) => value.Value;
/// <summary> /// Given two IValue's, do the expression conversion. /// </summary> /// <param name="renames"></param> /// <param name="p1"></param> /// <param name="p2"></param> /// <returns></returns> public static Tuple <bool, IEnumerable <Tuple <string, string> > > RequireForEquivForExpression(this Tuple <bool, IEnumerable <Tuple <string, string> > > renames, IValue p1, IValue p2) { return(renames .RequireForEquivForExpression(p1.RawValue, p1.Dependants.Select(p => p.RawValue), p2.RawValue, p2.Dependants.Select(p => p.RawValue))); }
public IParseResult Parse(IEnumerator <string> args) { bool first = true; TClass parsedClass = new(); List <Error> errors = new(); HashSet <IOption <TClass> > optionsRemaining = new(allOptions); HashSet <ISwitch <TClass> > switchesRemaining = new(allSwitches); List <string> multiValuesFound = new(); int valuesFound = 0; while (args.MoveNext()) { string a = args.Current; // If the user asks for help, immediately stop parsing if (config.StringComparer.Equals(a, config.ShortHelpSwitch) || config.StringComparer.Equals(a, config.LongHelpSwitch)) { errors.Add(new Error(ErrorCode.HelpRequested, string.Empty)); return(new FailedParseWithVerb <TClass>(this, errors)); } // It is POSSIBLE for the user to set up a verb with arguments that also has a sub-verb as much as I hate that idea // So only allow the first argument to be the verb. It should be interpreted as a value or whatever if found elsewhere. // If it happens to be a verb, we just hand over the parsing if (first && verbsByName.TryGetValue(a, out IVerb? verb)) { return(verb.Parse(args)); } if (allOptionsByName.TryGetValue(a, out IOption <TClass>?oval)) { if (args.MoveNext()) { a = args.Current; // The option might only have a short or long name. However if both return false, that means we already saw it. if (optionsRemaining.Remove(oval)) { Error error = oval.SetValue(parsedClass, a); if (error.ErrorCode != ErrorCode.Ok) { errors.Add(error); } } else { errors.Add(new Error(ErrorCode.DuplicateOption, "An Option appeared twice: " + a)); } } else { errors.Add(new Error(ErrorCode.OptionMissingValue, "An Option was missing a value: " + a)); } } else if (allSwitchesByName.TryGetValue(a, out ISwitch <TClass>?sval)) { // The switch might only have a short or long name. However if both return false, that means we already saw it. if (switchesRemaining.Remove(sval)) { Error error = sval.SetValue(parsedClass, string.Empty); if (error.ErrorCode != ErrorCode.Ok) { errors.Add(error); } } else { errors.Add(new Error(ErrorCode.DuplicateSwitch, "A Switch appeared twice: " + a)); } } // Might be a Value else if (valuesFound < AllValues.Count) { Error error = AllValues[valuesFound++].SetValue(parsedClass, a); if (error.ErrorCode != ErrorCode.Ok) { errors.Add(error); } } // Might be a MultiValue, unless it starts with something that should be ignored else if (MultiValue != null) // && !MultiValue.HasIgnoredPrefix(arg)) { multiValuesFound.Add(a); } // It's something unrecognized else { errors.Add(new Error(ErrorCode.UnexpectedArgument, "Found an unexpected argument: " + a)); } first = false; } // Set all remaining values to default for (int i = valuesFound; i < AllValues.Count; i++) { Error error = AllValues[i].SetValue(parsedClass, null); if (error.ErrorCode != ErrorCode.Ok) { errors.Add(error); } } bool gotMultiValue = false; // Set the MultiValue if (MultiValue != null) { Error error = MultiValue.SetValue(parsedClass, multiValuesFound); gotMultiValue = true; if (error.ErrorCode != ErrorCode.Ok) { errors.Add(error); } } // Set all remaining options and switches to their default values foreach (IOption <TClass> opt in optionsRemaining) { Error error = opt.SetValue(parsedClass, null); if (error.ErrorCode != ErrorCode.Ok) { errors.Add(error); } } foreach (ISwitch <TClass> sw in switchesRemaining) { Error error = sw.SetValue(parsedClass, null); if (error.ErrorCode != ErrorCode.Ok) { errors.Add(error); } } // Make sure all of the stuff we've set so far is good, if not then bail out if (errors.Count > 0) { return(new FailedParseWithVerb <TClass>(this, errors)); } // Evaluate dependencies; we know we got the value if it doesn't appear in our lists of remaining stuff foreach (IOption <TClass> opt in allOptions) { Error error = opt.EvaluateDependencies(parsedClass, !optionsRemaining.Contains(opt)); if (error.ErrorCode != ErrorCode.Ok) { errors.Add(error); } } foreach (ISwitch <TClass> sw in allSwitches) { Error error = sw.EvaluateDependencies(parsedClass, !switchesRemaining.Contains(sw)); if (error.ErrorCode != ErrorCode.Ok) { errors.Add(error); } } // As for values, we can use the valuesFound variable for (int i = 0; i < allValues.Count; i++) { IValue <TClass> val = allValues[i]; Error error = val.EvaluateDependencies(parsedClass, valuesFound > i); if (error.ErrorCode != ErrorCode.Ok) { errors.Add(error); } } if (MultiValue != null) { Error error = MultiValue.EvaluateDependencies(parsedClass, gotMultiValue); if (error.ErrorCode != ErrorCode.Ok) { errors.Add(error); } } if (errors.Count > 0) { return(new FailedParseWithVerb <TClass>(this, errors)); } string?errMsg = ValidateObject?.Invoke(parsedClass); if (string.IsNullOrEmpty(errMsg)) { return(new SuccessfulParse <TClass>(this, parsedClass)); } else { errors.Add(new Error(ErrorCode.ObjectFailedValidation, errMsg)); return(new FailedParseWithVerb <TClass>(this, errors)); } }
public override Completion InternalCall(IValue thisValue, IReadOnlyList <IValue> arguments) { throw new NotImplementedException("Array(...) is not implemented"); }
public static byte[] Encode(this IValue value) { var codec = new Codec(); return(codec.Encode(value)); }
static IValue _OptimizeIValue(IValue n) { n = ExpressionConverterVisitor.Visit(n); return(n); }
public virtual object?ParseLiteral(IValue value) => value switch {
protected override object VisitReturnStatement(ReturnStatementSyntax node) { IValue v = node.Expression == null ? null : _VisitExpression(node.Expression); return(new ReturnStatement(v)); }
public MPair(IValue a, IValue b) { First = a; Rest = b; }
public override IValue GetIndexedValue(IValue index) { return(GetColumnByIIndex(index)); }
IValue Parse(string aExpression) { aExpression = aExpression.Trim(); int index = aExpression.IndexOf('('); while (index >= 0) { SubstitudeBracket(ref aExpression, index); index = aExpression.IndexOf('('); } if (aExpression.Contains(',')) { string[] parts = aExpression.Split(','); List <IValue> exp = new List <IValue>(parts.Length); for (int i = 0; i < parts.Length; i++) { string s = parts[i].Trim(); if (!string.IsNullOrEmpty(s)) { exp.Add(Parse(s)); } } return(new MultiParameterList(exp.ToArray())); } else if (aExpression.Contains('+')) { string[] parts = aExpression.Split('+'); List <IValue> exp = new List <IValue>(parts.Length); for (int i = 0; i < parts.Length; i++) { string s = parts[i].Trim(); if (!string.IsNullOrEmpty(s)) { exp.Add(Parse(s)); } } if (exp.Count == 1) { return(exp[0]); } return(new OperationSum(exp.ToArray())); } else if (aExpression.Contains('-')) { string[] parts = aExpression.Split('-'); List <IValue> exp = new List <IValue>(parts.Length); if (!string.IsNullOrEmpty(parts[0].Trim())) { exp.Add(Parse(parts[0])); } for (int i = 1; i < parts.Length; i++) { string s = parts[i].Trim(); if (!string.IsNullOrEmpty(s)) { exp.Add(new OperationNegate(Parse(s))); } } if (exp.Count == 1) { return(exp[0]); } return(new OperationSum(exp.ToArray())); } else if (aExpression.Contains('*')) { string[] parts = aExpression.Split('*'); List <IValue> exp = new List <IValue>(parts.Length); for (int i = 0; i < parts.Length; i++) { exp.Add(Parse(parts[i])); } if (exp.Count == 1) { return(exp[0]); } return(new OperationProduct(exp.ToArray())); } else if (aExpression.Contains('/')) { string[] parts = aExpression.Split('/'); List <IValue> exp = new List <IValue>(parts.Length); if (!string.IsNullOrEmpty(parts[0].Trim())) { exp.Add(Parse(parts[0])); } for (int i = 1; i < parts.Length; i++) { string s = parts[i].Trim(); if (!string.IsNullOrEmpty(s)) { exp.Add(new OperationReciprocal(Parse(s))); } } return(new OperationProduct(exp.ToArray())); } else if (aExpression.Contains('^')) { int pos = aExpression.IndexOf('^'); var val = Parse(aExpression.Substring(0, pos)); var pow = Parse(aExpression.Substring(pos + 1)); return(new OperationPower(val, pow)); } int pPos = aExpression.IndexOf("&"); if (pPos > 0) { string fName = aExpression.Substring(0, pPos); foreach (var M in m_Funcs) { if (fName == M.Key) { var inner = aExpression.Substring(M.Key.Length); var param = Parse(inner); var multiParams = param as MultiParameterList; IValue[] parameters; if (multiParams != null) { parameters = multiParams.Parameters; } else { parameters = new IValue[] { param } }; return(new CustomFunction(M.Key, M.Value, parameters)); } } } foreach (var C in m_Consts) { if (aExpression == C.Key) { return(new CustomFunction(C.Key, (p) => C.Value(), null)); } } int index2a = aExpression.IndexOf('&'); int index2b = aExpression.IndexOf(';'); if (index2a >= 0 && index2b >= 2) { var inner = aExpression.Substring(index2a + 1, index2b - index2a - 1); int bracketIndex; if (int.TryParse(inner, out bracketIndex) && bracketIndex >= 0 && bracketIndex < m_BracketHeap.Count) { return(Parse(m_BracketHeap[bracketIndex])); } else { throw new ParseException("Can't parse substitude token"); } } double doubleValue; if (double.TryParse(aExpression, out doubleValue)) { return(new Number(doubleValue)); } if (ValidIdentifier(aExpression)) { if (m_Context.Parameters.ContainsKey(aExpression)) { return(m_Context.Parameters[aExpression]); } var val = new Parameter(aExpression); m_Context.Parameters.Add(aExpression, val); return(val); } throw new ParseException("Reached unexpected end within the parsing tree"); }
public void setParent(IValue parent) { return; }
public virtual void CallAsFunction(int methodNumber, IValue[] arguments, out IValue retValue) { throw new NotImplementedException(); }
public override object ParseLiteral(IValue value) => throw new System.NotImplementedException();
public virtual IValue GetIndexedValue(IValue index) { throw new NotImplementedException(); }
/// <summary> /// After applying the renames, make sure the two statements are the same. /// </summary> /// <param name="renames"></param> /// <param name="p1"></param> /// <param name="p2"></param> /// <returns></returns> public static Tuple <bool, IEnumerable <Tuple <string, string> > > RequireAreSame(this Tuple <bool, IEnumerable <Tuple <string, string> > > renames, IValue p1, IValue p2) { return(renames .RequireAreSame(p1.RawValue, p2.RawValue)); }
public virtual void SetIndexedValue(IValue index, IValue val) { throw new NotImplementedException(); }
public If(IValue condition, Program scope1) { this.condition = condition; this.scope1 = scope1; }
public IValueBuilder If(IValue condition) => Create(this, new ValueBuilderImpl(condition), (l, r) => r.IsTrue() ? l : null, (l, r) => $"{r}.IsTrue ? {l} : null");