static Array FromFields(INSGenerator generator, Parameters parameters, bool readOnly, bool setting, bool overriding, Func <Value, Value> map) { var iterator = new NSIterator(generator); var array = new Array(); var start = 0; var actualParameters = parameters.GetParameters(); var length = actualParameters.Length; var assignments = new Hash <string, Value>(); var assignedParameters = new Hash <string, Parameter>(); for (var i = start; i < length; i++) { start = i; var parameter = actualParameters[i]; var value = iterator.Next(); if (value.IsNil) { break; } assignments[parameter.Name] = value; assignedParameters[parameter.Name] = parameter; array[parameter.Name] = value; } if (start <= length - 1) { var innerArray = new Array { array[parameters[start].Name] }; for (var i = start; i < MAX_LOOP; i++) { var value = iterator.Next(); if (value.IsNil) { break; } innerArray.Add(value); } if (innerArray.Length > 0) { var value = map(innerArray); assignments[parameters[start].Name] = value; assignedParameters[parameters[start].Name] = parameters[start]; array[parameters[start].Name] = value; } } foreach (var(key, value) in assignments) { if (assignedParameters.If(key, out var parameter)) { parameter.Assign(value, readOnly, setting, overriding); } } return(array); }
public static object ToType(this Value value, string type, bool isArray) { if (isArray) { if (value.IsArray) { value = value.SourceArray; var array = (Array)value; return(array.Values.Select(v => v.ToType(type, false)).ToArray()); } var newArray = new Array(Runtime.State.FieldPattern.Split(value.Text)); return(ToType(newArray, type, true)); } return(type switch { "system.int32" => value.Number, "system.int64" => value.Number, "system.int16" => value.Number, "system.byte" => value.Number, "system.double" => value.Number, "system.single" => value.Number, "system.boolean" => value.IsTrue, "system.string" => value.Text, _ => throw $"Didn't understand type {type}".Throws() });
public Runtime(string text = "", IFileCache fileCache = null) { Sys = new Sys(); stack = new ValueStack(); blockManager = new BlockManager(); printBuffer = new Buffer(); patternManager = new PatternManager(); Regions = new RegionManager(Sys, text); expressionManager = new ExpressionManager(); FieldPattern = (Pattern)(STRING_BEGIN_PATTERN + "+" + STRING_END_PATTERN); RecordPattern = (Pattern)(STRING_BEGIN_PATTERN + "'`r`n' | '`r' | '`n'" + STRING_END_PATTERN); FieldSeparator = (String)" "; RecordSeparator = (String)"\r\n"; seed = DateTime.Now.Millisecond; random = new Random(seed); valueStacks = new Stack <ValueStack>(); FileCache = fileCache ?? new StandardFileCache(); takeArray = new Array(); defaultParameterNames = new Stack <DefaultParameterNames>(); defaultParameterNames.Push(new DefaultParameterNames(true)); buffer = new Buffer(); ArgumentDepth = 0; invokeables = new Hash <string, IInvokeable>(); extenders = new Hash <string, InvokeableReference>(); Parser.InClassDefinition = false; consoleManager = new ConsoleManager(); indent = ""; }
public static Array ReplacePlaceholders(Block block) { var array = new Array(); foreach (var verb in block.AsAdded) { Value value; switch (verb) { case Push push: value = push.Value; break; case PushArrayLiteral pushArrayLiteral: value = pushArrayLiteral.Array; break; default: continue; } if (value is Variable variable) { var name = variable.Name; value = name == "_" ? (Value) new Any() : new Placeholder(name); } array.Add(value); } return(array); }
public void SetValues(Block actualArguments, Block executable, bool resolveArguments) { Runtime.State.SetLocal(Runtime.VAR_ARGUMENTS, actualArguments); Array values = resolveArguments ? actualArguments.ToActualArguments() : actualArguments.ToDefinedArguments(); int min = Math.Min(variableNames.Count, values.Length); for (var i = 0; i < min; i++) { Value value = values[i]; Runtime.State.SetLocal(variableNames[i], value.AssignmentValue()); } Runtime.State.SetLocal(Runtime.VAR_BLOCK, executable ?? new NullBlock()); Array variables = values; if (resolveArguments) { variables = actualArguments.ToDefinedArguments(); } for (var i = 0; i < min; i++) { Value value = variables[i]; Runtime.State.SetLocal(Runtime.VAR_INDIRECT + i, value.IsVariable ? ((Variable)value).Name : ""); } }
protected static Value tabs(Value[] values) { return(values.Length switch { 0 => "\t", _ => "\t".Repeat(values[0].Int) });
void findMissing(Hash <string, string> missing, string[] messages, Func <string, bool> func, string interfaceName) { foreach (string message in messages.Where(m => !func(m))) { missing[message] = interfaceName; } }
protected static Value put(Value[] values) { foreach (var value in values) { State.ConsoleManager.Put(ValueAsString(value)); } return(null); }
static Array fromValue(Value source, int count) { var array = new Array(); for (var i = 0; i < count; i++) { array.Add(source); } return(array); }
public ParallelZip(Array arrayOfArrays) { this.arrayOfArrays = arrayOfArrays; index = -1; maxLength = -1; foreach (var value in this.arrayOfArrays.Select(item => item.Value)) { value.IsArray.Must().BeTrue().OrThrow(LOCATION, () => $"Item {value} in array of arrays not an array"); var array = (Array)value.SourceArray; maxLength = Max(maxLength, array.Length); } }
public ParallelZip(Array arrayOfArrays) { this.arrayOfArrays = arrayOfArrays; index = -1; maxLength = -1; foreach (var value in this.arrayOfArrays.Select(item => item.Value)) { Assert(value.IsArray, LOCATION, $"Item {value} in array of arrays not an array"); var array = (Array)value.SourceArray; maxLength = Max(maxLength, array.Length); } }
bool compareArrayNone(Array x, Array y) { var length = Math.Min(x.Length, y.Length); for (var i = 0; i < length; i++) { if (Compare(x[i].Compare(y[i]))) { return(false); } } return(true); }
public static string FixText(string text, string input, ref string needle, ref char[] needleChars) { if (State.IgnoreCase) { text = text.ToLower(); input = input.ToLower(); } needle ??= Expand(text); needleChars ??= needle.ToCharArray(); return(input); }
public Value Next() { if (++index >= maxLength) { return(new Nil()); } var newArray = new Array(); foreach (var array in arrayOfArrays.Select(item => (Array)item.Value)) { newArray.Add(array[index]); } return(newArray); }
bool compareArrayOne(Value x, Array y) { var found = false; foreach (var _ in y.Where(item => Compare(x.Compare(item.Value)))) { if (found) { return(false); } found = true; } return(found); }
bool compareArrayOne(Array x, Value y) { var found = false; foreach (var _ in x.Where(item => Compare(item.Value.Compare(y)))) { if (found) { return(false); } found = true; } return(found); }
static Array fromValue(Value source, INSGenerator count) { var countSource = (Array)count.Array(); var array = new Array(); var outerCount = countSource[0].Int; var innerCount = countSource[1].Int; for (var i = 0; i < outerCount; i++) { array.Add(fromValue(source, innerCount)); } return(array); }
protected static Value peek(Value[] values) { switch (values.Length) { case 1: State.ConsoleManager.ConsolePrintln(ValueAsString(values[0])); return(values[0]); case 2: State.ConsoleManager.ConsolePrintln(ValueAsString(values[0])); return(values[1]); default: return(NilValue); } }
public static object ToType(this Value value, string type, bool isArray) { if (isArray) { if (value.IsArray) { value = value.SourceArray; var array = (Array)value; return(array.Values.Select(v => v.ToType(type, false)).ToArray()); } var newArray = new Array(Runtime.State.FieldPattern.Split(value.Text)); return(ToType(newArray, type, true)); } switch (type) { case "system.int32": return((int)value.Number); case "system.int64": return((long)value.Number); case "system.int16": return((short)value.Number); case "system.byte": return((byte)value.Number); case "system.double": return(value.Number); case "system.single": return((float)value.Number); case "system.boolean": return(value.IsTrue); case "system.string": return(value.Text); default: throw $"Didn't understand type {type}".Throws(); } }
protected static Value write(Value[] values) { switch (values.Length) { case 0: return(null); case 1: var asString = ValueAsRep(values[0]); State.ConsoleManager.ConsolePrint(asString); return(null); default: var text = values.Select(ValueAsRep).ToString(""); State.ConsoleManager.ConsolePrint(text); return(null); } }
bool compareArrayOne(Array x, Array y) { var found = false; var length = Math.Min(x.Length, y.Length); for (var i = 0; i < length; i++) { if (!Compare(x[i].Compare(y[i]))) { continue; } if (found) { return(false); } found = true; } return(found); }
public static Array ToArray(INSGenerator generator) { var array = new Array(); var iterator = new NSIterator(generator); iterator.Reset(); for (var i = 0; i < MAX_ARRAY; i++) { var next = iterator.Next(); if (next.IsNil) { break; } array.Add(next); } return(array); }
public override Value Evaluate() { var stack = State.Stack; var value = stack.Pop(true, LOCATION); var keyValue = stack.Pop(false, LOCATION); if (keyValue.IsArray && value.IsArray) { var keys = (Array)keyValue.Resolve().SourceArray; var values = (Array)value.SourceArray; var maxLength = Math.Max(keys.Length, values.Length); var array = new Array(); for (var i = 0; i < maxLength; i++) { array[keys[i].Text] = values[i]; } return(array); } var key = keyValue.Text; return(new KeyedValue(key, value)); }
public static void SetMultipleParameters(Parameters parameters, Array array) { Assign.FromFieldsLocal(array, parameters); }
public void SetBreakOnParameters(Array array, string key, int index) { Regions.SetLocal(names.ArrayVariable, array); Regions.SetLocal(names.KeyVariable, key); Regions.SetLocal(names.IndexVariable, index); }
public static Block ConvertBlocks(Parameters parameters, Block finalValue, Block checkExpresion, Block invariant, Block increment, Array test = null) { var builder = new CodeBuilder(); builder.Define(VAR_ACCUM); builder.Assign(); builder.Parenthesize(finalValue); builder.End(); builder.Push(); builder.Push(); builder.Exit(); var ifThen = builder.Pop(); builder.If(checkExpresion, ifThen); builder.Variable(VAR_ACCUM); builder.Assign(); builder.Parenthesize(invariant); builder.End(); var setup = true; var parameterIndex = 0; foreach (var verb in increment) { if (setup) { var length = parameters.VariableNames.Length; Assert(parameterIndex < length, LOCATION, "No more parameters"); builder.Define(VAR_MANGLE + parameters[parameterIndex++].Name); builder.Assign(); setup = false; } if (verb is AppendToArray) { builder.End(); setup = true; } else { builder.Verb(verb); } } builder.End(); foreach (var variableName in parameters.VariableNames) { builder.Variable(variableName); builder.Assign(); builder.Variable(VAR_MANGLE + variableName); builder.End(); } var actions = builder.Pop(); builder.Push(); if (test == null) { builder.Value(true); } else { builder.Variable(parameters[0].Name); builder.Verb(new When()); builder.Value(test); } var whileCondition = builder.Pop(); builder.While(whileCondition, actions); builder.End(); builder.Return(); if (finalValue.Count == 1) { if (NameFromVariable(finalValue[0]).IsSome) { builder.Parenthesize(finalValue); } else { builder.Variable(VAR_ACCUM); } } else { builder.Variable(VAR_ACCUM); } builder.End(); return(builder.Block); }
public override Verb CreateVerb(string[] tokens) { var isAbstract = tokens[2].IsNotEmpty(); var type = tokens[3].Trim(); var className = tokens[4]; var parameterBegin = tokens[5]; ClassName = className; EnumerationValue = -1; CurrentVisibility = Object.VisibilityType.Public; Color(position, tokens[1].Length, Whitespaces); Color(tokens[2].Length, KeyWords); Color(tokens[3].Length, KeyWords); Color(className.Length, Types); Color(parameterBegin.Length, Structures); Parameters parameters; int index; if (parameterBegin == "(" && type != "module") { Color(parameterBegin.Length, Structures); index = position + length; var parametersParser = new ParametersParser(); var parsed = parametersParser.Parse(source, index); if (!parsed.If(out parameters, out index)) { return(null); } if (type == "enum") { parameters.Unshift(new Parameter("name")); parameters.Unshift(new Parameter("value")); } } else if (type == "enum") { parameters = new Parameters(new[] { new Parameter("value"), new Parameter("name") }); index = position + length; } else { parameters = new Parameters(); index = position + length; } (var superClass, var superParameters, var traits, var newIndex) = Ancestors(source, index); index = newIndex; var endParser = new EndParser(); if (endParser.Scan(source, index)) { index = endParser.Position; } Block objectBlock; InClassDefinition = true; EnumerationMappingCode = new CodeBuilder(); try { if (type == "enum") { addEnumerationSupport(className); } LockedDown = type == "view"; if (GetBlock(source, index, true, InClass).If(out var block, out newIndex)) { objectBlock = block; index = newIndex; if (type == "enum") { addEnumerationInstanceSupport(ref objectBlock); } } else { objectBlock = new Block(); } } finally { InClassDefinition = false; if (EnumerationMappingCode != null) { AddStaticBlock(EnumerationMappingCode.Block); } EnumerationMappingCode = null; LockedDown = false; } var checker = new InheritanceChecker(className, objectBlock, parameters, superClass, isAbstract, traits); var passes = checker.Passes(); Assert(passes.IsSuccessful, LOCATION, () => passes.Exception.Message); var cls = new Class(parameters, objectBlock, GetStaticBlock(), superClass, traits, superParameters, type == "view"); CompilerState.RegisterClass(ClassName, cls); result.Value = cls; overridePosition = index; ClassName = ""; switch (type) { case "module": return(new CreateModule(className, cls, true) { Index = position }); case "extend": return(new CreateExtender(className, cls)); default: var verb = new CreateClass(className, cls) { HelperFunctions = HelperFunctions, HelperBlock = HelperBlock, Index = position }; HelperFunctions = null; HelperBlock = null; return(verb); } }
public static object[] GetArguments(this Value[] arguments, string[] types) { var matcher = new Matcher(); return(types.Select((t, i) => t.GetArgument(arguments[i], matcher)).ToArray()); }
static Array FromFields(INSGenerator generator, Parameters parameters, bool readOnly, bool setting, bool _override, Func <Value, Value> map) { var iterator = new NSIterator(generator); var array = new Array(); var start = 0; var actuals = parameters.GetParameters(); var length = actuals.Length; var assignments = new Hash <string, Value>(); var assignedParameters = new Hash <string, Parameter>(); for (var i = start; i < length; i++) { start = i; var parameter = actuals[i]; var value = iterator.Next(); if (value.IsNil) { break; } assignments[parameter.Name] = value; assignedParameters[parameter.Name] = parameter; array[parameter.Name] = value; } if (start <= length - 1) { var innerArray = new Array { array[parameters[start].Name] }; for (var i = start; i < MAX_LOOP; i++) { var value = iterator.Next(); if (value.IsNil) { break; } innerArray.Add(value); } if (innerArray.Length > 0) { var value = map(innerArray); assignments[parameters[start].Name] = value; assignedParameters[parameters[start].Name] = parameters[start]; array[parameters[start].Name] = value; } } // ReSharper disable once LoopCanBePartlyConvertedToQuery foreach (var item in assignments) { if (assignedParameters.If(item.Key, out var parameter)) { parameter.Assign(item.Value, readOnly, setting, _override); } } return(array); }
public static object[] GetArguments(this Value[] arguments) => arguments.Select(a => a.GetArgument()).ToArray();