private static object GetVar(string varName) { if (Vars.ContainsKey(varName)) { return(Vars[varName]); } return(null); }
//***** Var/Flag accessors public string GetVar(string varName) { if (Vars.ContainsKey(varName)) { return(Vars[varName]); } return(null); }
public TjsVarType GetSlotType(short slot) { if (Vars.ContainsKey(slot)) { return(Vars[slot].VarType); } return(TjsVarType.Null); }
private Node FindName(Lexeme nameToken) { if (Vars.ContainsKey(nameToken.Value)) { return(Vars[nameToken.Value]); } return(Parent?.FindName(nameToken)); }
public string GetVar(string varName) { if (Vars.ContainsKey(varName)) { if (Vars[varName] is string s) { return(s); } return(Vars[varName]?.ToString()); } return(null); }
private static void WriteVar(string varName, object value) { if (value == null) { if (Vars.ContainsKey(varName)) { Vars.Remove(varName); } return; } if (Vars[varName] == null) { Vars.Add(varName, value); } else { Vars[varName] = value; } }
private static string ParseVariables(Vars vars, string line) { var result = line; while (true) { var match = VariableRegex.Match(result); if (match.Success) { var key = match.Groups[0].Value.Substring(1); var value = vars.ContainsKey(key) ? vars[key] : Environment.GetEnvironmentVariable(key); result = Replace(result, match.Index, match.Length, value); } else { break; } } return(result); }
void GenerateInstruction(Instruction i, Function func, Args args, Function old) { switch (i.Func.Function) { /* * Handle Blocks */ case "_ !block": // Handle the block Generate(new Function { // Keep the name (because of variables). Name = func.Name, // Copy the instructions Instructions = ((IBlock)i).List, // Return nothing Ret = new Return(), // Take no arguments Arguments = new Args { // Because Arguments = new List <Variable>() } }, null, func); break; /* * Define new variable from constant */ case "new": // Check if it has valid arguments if (i.Func.Arguments.Arguments.Count == 1 && i.Func.Arguments.Arguments[0].isConst) { byte[] x; // Check if it's a number or string if (i.Func.Arguments.Arguments[0].isNum) { // Number x = BitConverter.GetBytes(int.Parse(i.Func.Arguments.Arguments[0].Name)); } else { // String x = Encoding.ASCII.GetBytes(i.Func.Arguments.Arguments[0].Name); } // Define the variable int var = AddVariable(x); // Assign the value to the variable if (i.Op?.Type == "=") { // Check if it's valid if (i.Var?.isConst == false) { // Is it direct? (starts with x) if (i.Var.Name.ToLower().StartsWith("x")) { // Directly move Move(int.Parse(i.Var.Name.ToLower().TrimStart('x')), var); } else { // Define if not already defined if (!Vars.ContainsKey(func.Name + i.Var.Name)) { Vars.Add(func.Name + i.Var.Name, var); } else { // Change if already defined Vars[func.Name + i.Var.Name] = var; } } } } // Throw an exception } else { throw new Exception("Invalid arguments in `new`."); } break; /* * Multiply two numbers */ case "proc_Mul": // Check for valid size of arguments. if (i.Func.Arguments.Arguments.Count == 2) { Mul(GetArgument(i, func, 0), GetArgument(i, func, 1)); } else { throw new Exception("Invalid arguments in `proc_Mul`."); } break; /* * Divide two numbers */ case "proc_Div": // Check for valid size of arguments. if (i.Func.Arguments.Arguments.Count == 2) { Div(GetArgument(i, func, 0), GetArgument(i, func, 1)); } else { throw new Exception("Invalid arguments in `proc_Div`."); } break; /* * Subtract two numbers */ case "proc_Sub": // Check for valid size of arguments. if (i.Func.Arguments.Arguments.Count == 2) { Sub(GetArgument(i, func, 0), GetArgument(i, func, 1)); } else { throw new Exception("Invalid arguments in `proc_Sub`."); } break; /* * Add two numbers */ case "proc_Add": // Check for valid size of arguments. if (i.Func.Arguments.Arguments.Count == 2) { Add(GetArgument(i, func, 0), GetArgument(i, func, 1)); } else { // Thow an exception throw new Exception("Invalid arguments in `proc_Add`."); } break; /* * Create a label */ case "label": if (i.Func.Arguments.Arguments.Count == 1 && !i.Func.Arguments.Arguments[0].isConst) { int var = AddVariable(BitConverter.GetBytes(++LabelID)); Label(var); if (i.Func.Arguments.Arguments[0].Name.ToLower().StartsWith("x")) { // Directly move Move(int.Parse(i.Func.Arguments.Arguments[0].Name.ToLower().TrimStart('x')), var); } else { // Define if not already defined if (!Vars.ContainsKey(func.Name + i.Func.Arguments.Arguments[0].Name)) { Vars.Add(func.Name + i.Func.Arguments.Arguments[0].Name, var); } else { // Change if already defined Vars[func.Name + i.Func.Arguments.Arguments[0].Name] = var; } } } else { throw new Exception("Invalid arguments in `label`."); } break; case "goto": if (i.Func.Arguments.Arguments.Count == 2 && !i.Func.Arguments.Arguments[0].isConst && !i.Func.Arguments.Arguments[1].isConst) { // 30 Lines less xD Goto(GetArgument(i, func, 0), GetArgument(i, func, 1)); } else { throw new Exception("Invalid arguments in `goto`."); } break; /* * Clear Value */ case "clear": // Check for the arguments count. if (i.Func.Arguments.Arguments.Count == 1) { // Clear the variable. ClearVar(GetArgument(i, func, 0)); } else { throw new Exception("Invalid arguments in `clear`."); } break; /* * Move Functions */ case "address": if (i.Func.Arguments.Arguments.Count == 2) { Move(GetArgument(i, func, 0), GetArgument(i, func, 1)); } break; case "content": if (i.Func.Arguments.Arguments.Count == 2) { MoveC(GetArgument(i, func, 0), GetArgument(i, func, 1)); } break; /* * Compiler Functions */ case "set_label": if (i.Func.Arguments.Arguments.Count == 1 && i.Func.Arguments.Arguments[0].isNum) { CurrentVar = int.Parse(16 + i.Func.Arguments.Arguments[0].Name); } else { throw new Exception("Invalid arguments in `set_label`."); } break; case "set_variable": if (i.Func.Arguments.Arguments.Count == 1 && i.Func.Arguments.Arguments[0].isNum) { LabelID = int.Parse(i.Func.Arguments.Arguments[0].Name); } else { throw new Exception("Invalid arguments `in set_variable`."); } break; /* * Get value */ case "get": // Check for the arguments count if (i.Func.Arguments.Arguments.Count == 1) { int var = GetArgument(i, func, 0); // Check if sould assign if (i.Op?.Type == "=") { // Check if the variable is valid if (i.Var?.isConst == false) { // If it starts with "x", directly put into the variable if (i.Var.Name.ToLower().StartsWith("x")) { // Move. Move(int.Parse(i.Var.Name.ToLower().TrimStart('x')), var); } else { // If the variable isn't defined, define it. if (!Vars.ContainsKey(func.Name + i.Var.Name)) { Vars.Add(func.Name + i.Var.Name, var); } else { // Change the variable Vars[func.Name + i.Var.Name] = var; } } } } } else { // Throw the exception throw new Exception("Incorrect amount of arguments in `get`."); } break; /* * The Is function. */ case "is": // Default size is 4 int mSize = 4; // If there is a second argument if (i.Func.Arguments.Arguments.Count == 2) { // And it's a number if (i.Func.Arguments.Arguments[1].isNum) { // Set the size to that number mSize = int.Parse(i.Func.Arguments.Arguments[1].Name); } else { // If not, thow an exception throw new Exception("Invalid argument in `is`."); } } // Select the old variable int oldVar = 0; // Create the new variable int newVar = AddVariable(new byte[mSize]); // Get your sources if (i.Func.Arguments.Arguments[0].isConst == false) { // Check if it is an address if (i.Func.Arguments.Arguments[0].Name.ToLower().StartsWith("x")) { // Set the oldVar address to that address. oldVar = int.Parse(i.Func.Arguments.Arguments[0].Name.ToLower().TrimStart('x')); } else { // Find a predefined variable. oldVar = Vars[func.Name + i.Func.Arguments.Arguments[0].Name]; } } else { throw new Exception("Invalid argument in `is`."); } // Where to assign if (i.Op?.Type == "=") { // Check if the variable is valid if (i.Var?.isConst == false) { // If it starts with "x", directly put into the variable if (i.Var.Name.ToLower().StartsWith("x")) { // Move. newVar = int.Parse(i.Var.Name.ToLower().TrimStart('x')); } else { // If the variable isn't defined, define it. if (!Vars.ContainsKey(func.Name + i.Var.Name)) { Vars.Add(func.Name + i.Var.Name, newVar); } else { // Change the variable Vars[func.Name + i.Var.Name] = newVar; } } } } MoveC(newVar, oldVar); break; /* * Interrupt */ case "int": // Check if the arguments are correct & interrupt if (i.Func.Arguments.Arguments.Count == 1 && i.Func.Arguments.Arguments[0].isNum) { int x = int.Parse(i.Func.Arguments.Arguments[0].Name); // Interrupt Interrupt((byte)x); } else { // Thow the exception throw new Exception("Interrupt can only accept bytes as arguments."); } break; /* * Execute Function */ default: // Find the function Function f = find(i.Func.Namespace, i.Func.Function); // Set the function name to something unique to the namespace f.Name = i.Func.Namespace + " " + i.Func.Function + " "; // Generate the function, and return. Generate(f, i.Func.Arguments, func); // Return if it's a variable if (f.Ret?.Type == TokenType.Variable) { int var; // Check if should return address. if (f.Ret.Value.ToLower().StartsWith("x")) { // Get direct address. var = int.Parse(f.Ret.Value.ToLower().TrimStart('x')); } else { // Get variable. var = Vars[f.Name + f.Ret.Value]; } // Check if should assign if (i.Op?.Type == "=") { if (i.Var?.isConst == false) { // Check if it's a direct address if (i.Var.Name.ToLower().StartsWith("x")) { // Move the data** MoveC(int.Parse(i.Var.Name.ToLower().TrimStart('x')), var); } else { // Define the variable if it's not already defined if (!Vars.ContainsKey(func.Name + i.Var.Name)) { // Define Variable Vars.Add(func.Name + i.Var.Name, var); } else { // Change Variable Vars[func.Name + i.Var.Name] = var; } } } } } else { // Make sure that it's an invalid return and not a void if (f.Ret?.Type == TokenType.Number || f.Ret.Type == TokenType.String) { throw new Exception("Functions can only return variables!"); } } // Collect the garbadge (if not in block) if ((old != null) && (old.Name == func.Name)) { CollectGarbadge(f.Name); } break; } }
public bool HasVar(string varName) { return(Vars.ContainsKey(varName)); }