internal static void DisplayMainWindow(ProgramContext programContext)
{
program = programContext;
frmMain = new FrmMain();
frmMain.FormClosed += new FormClosedEventHandler(OnMainFormClosed);
frmMain.Show();
}
private async Task AddCompRepsFromSearch()
{
await ProgramContext.AddCompRepsFromSearch(selectedCompReps, ProgrammeId);
this.StateHasChanged();
UpdateCrModal();
this.StateHasChanged();
await GetCompanyReps();
}
private async Task RemoveStudentFromProgram(Student student)
{
List <Student> toRemove = new List <Student>();
toRemove.Add(student);
await ProgramContext.RemoveStudentsFromProgram(toRemove, ProgrammeId);
await GetStudents();
}
private async Task AddCoursesToProgram()
{
await ProgramContext.AddCoursesFromSearch(selectedCourses, ProgrammeId);
this.StateHasChanged();
UpdateCourseModal();
this.StateHasChanged();
await GetCourses();
}
//For Program
public ActionResult Index()
{
if (Session["Email"] != null)
{
ProgramContext context = new ProgramContext();
List <Programs> programs = context.Programs.ToList();
return(View(programs));
}
return(RedirectToAction("Index", "Home"));
}
private async Task RemoveCompanyRepFromProgram(CompRep compRep)
{
List <CompRep> repToRemove = new List <CompRep>();
repToRemove.Add(compRep);
await ProgramContext.RemoveCompRepsFromProgram(repToRemove, ProgrammeId);
StateHasChanged();
await GetCompanyReps();
}
public override object VisitProgram(ProgramContext context)
{
var StatethisntList = context.statement();
var result = "";
foreach (var item in StatethisntList)
{
result += VisitStatement(item);
}
return(result);
}
internal SkryptEngine CreateGlobals()
{
var block = ProgramContext.block();
foreach (var v in block.LexicalEnvironment.Variables)
{
GlobalEnvironment.AddVariable(v.Value);
}
return(this);
}
private async Task AddStudentsFromSearch()
{
UpdateStudentModal();
await ProgramContext.AddStudentsFromSearch(selectedStudents, ProgrammeId);
await GetStudents();
StateHasChanged();
searchedStudents.Clear();
selectedStudents.Clear();
}
public static void Main(string[] args)
{
var filename = args[0];
Console.WriteLine("Input file: "+filename);
var context = new ProgramContext();
var parser = new FileParser(new StreamReader(filename, Encoding.UTF8),
context);
parser.ParseFile();
Console.WriteLine("OK");
}
public override object VisitProgram([NotNull] ProgramContext context)
{
var list = context.statement();
var result = "";
foreach (var item in list)
{
result += VisitStatement(item);
}
return(result);
}
static void Main(string[] args)
{
var programContext = new ProgramContext();
programContext.ShowAllOptions();
Console.Write("Enter option:");
var option = Convert.ToInt32(Console.ReadLine());
programContext.RunWith(option);
Console.ReadKey();
}
internal static void DisplayLoginWindow(ProgramContext programContext)
{
program = programContext;
if (frmLogin == null)
{
frmLogin = new FrmLogin();
frmLogin.FormClosed += new FormClosedEventHandler(OnLoginFormClosed);
}
frmLogin.Show();
}
public void ToEdit(IValueProvider valueProvider)
{
var htmlFiles = valueProvider.GetFiles(Entities.FileType.Html);
List <FileContext> files = new List <FileContext>();
var searcher = new HtmlJsFileSearcher();
foreach (var item in htmlFiles)
{
var list = searcher.Search(item.Tree);
files.AddRange(list);
}
var uniqFiles = files.Distinct();
File commonFile = new File();
commonFile.FileName = IO.Path.GetRandomFileName();
commonFile.SearchName = commonFile.FileName;
commonFile.Type = FileType.Js;
ProgramContext program = new ProgramContext(null, 0);
SourceElementsContext elems = new SourceElementsContext(program, 0);
foreach (var item in uniqFiles)
{
var tree = item.File.Tree as ProgramContext;
var treeElems = tree.sourceElements().sourceElement();
foreach (var elem in treeElems)
{
elems.AddChild(elem);
}
valueProvider.RemoveFile(item.File.FileName);
}
program.AddChild(elems);
commonFile.Tree = program;
valueProvider.AddFile(commonFile);
HtmlAddScriptEditor htmlAdsScript = new HtmlAddScriptEditor();
foreach (var item in htmlFiles)
{
htmlAdsScript.Add(item.Tree, new File[] { commonFile });
}
foreach (var item in files)
{
item.Context.Remove();
}
}
public static dynamic GetProgramListAsJSON()
{
using (var db = new ProgramContext())
{
var programs = from p in db.Programs
select new
{
Name = p.ProgramName
};
var serializer = new JavaScriptSerializer();
return(serializer.Serialize(programs));
}
}
public ProgramContext program()
{
ProgramContext _localctx = new ProgramContext(Context, State);
EnterRule(_localctx, 0, RULE_program);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 21;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
while (_la == T__0)
{
{
{
State = 18; macroDefinition();
}
}
State = 23;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
}
State = 27;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__6) | (1L << ID) | (1L << WORD))) != 0))
{
{
{
State = 24; line();
}
}
State = 29;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
}
State = 30; Match(Eof);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public void SetDispatcherFor(ProgramContext context)
{
// Return existing one, or make a new one for it:
if (mapping.ContainsKey(context))
{
CurrentDispatcher = mapping[context];
return;
}
KOSGameEventDispatcher newDispatcher = new KOSGameEventDispatcher(Shared);
mapping.Add(context, newDispatcher);
CurrentDispatcher = newDispatcher;
}
private void Controller()
{
int menu;
using (var db = new ProgramContext())
{
menu = SelectOption();
do
{
switch (menu)
{
case 1:
db.Products.Add(Product());
db.SaveChanges();
break;
case 2:
db.Customers.Add(Client());
db.SaveChanges();
break;
case 3:
db.Manufacturers.Add(Manufacturer());
db.SaveChanges();
break;
case 4:
ShowProducts();
break;
case 5:
ShowCustomers();
break;
case 6:
ShowManufacturers();
break;
case 7:
Environment.Exit(0);
break;
default:
Console.WriteLine("Key error, introduce 1/2/3/4/5/6/7");
break;
}
menu = SelectOption();
} while (menu != 7);
}
}
public override void EnterProgram(ProgramContext context)
{
AppendLine("using System;");
AppendLine("class Program {");
AppendLine("static void readln<T>(ref T arg) {");
AppendLine(" arg = (T)Convert.ChangeType(Console.ReadLine(), typeof(T));");
AppendLine("}");
AppendLine("static void writeln(params object[] args) {");
AppendLine(" Console.WriteLine(string.Join(string.Empty, args));");
AppendLine("}");
AppendLine("static void write(params object[] args) {");
AppendLine(" Console.Write(string.Join(string.Empty, args));");
AppendLine("}");
}
public void Give_immediately_below_instruction_index_after_execution(
int currentInstructionIndex,
int expectedNextInstructionIndex)
{
// Given
var programContext = new ProgramContext(0, currentInstructionIndex);
var instruction = new AccumulatorInstruction(0);
// When
var executionResult = instruction.Execute(programContext);
var actualNextInstructionIndex = executionResult.NextInstructionIndex;
// Then
Assert.Equal(expectedNextInstructionIndex, actualNextInstructionIndex);
}
public override ASTN VisitProgram([NotNull] ProgramContext context)
{
ProgNode node = new ProgNode(context)
{
classes = new List <ClassNode>()
//classes = GenerateTypeBasic(context)
};
foreach (var classdef in context.classDefine())
{
node.classes.Add(VisitClassDefine(classdef) as ClassNode);
}
return(node);
}
public void RemoveDispatcherFor(ProgramContext context)
{
// First, unset the current dispatcher if the context
// being removed is for the current dispatcher:
KOSGameEventDispatcher contextDispatcher;
mapping.TryGetValue(context, out contextDispatcher);
if (contextDispatcher == CurrentDispatcher)
{
CurrentDispatcher = null;
}
// Then get rid of the mapping for this context:
mapping.Remove(context);
}
public void Increase_or_decrease_accumulator_by_argument_value(
int initialAccumulatorValue,
int instructionArgument,
int expectedAccumulatorValue)
{
// Given
var programContext = new ProgramContext(initialAccumulatorValue, 0);
var instruction = new AccumulatorInstruction(instructionArgument);
// When
var executionResult = instruction.Execute(programContext);
var actualAccumulatorValue = executionResult.AccumulatorValue;
// Then
Assert.Equal(expectedAccumulatorValue, actualAccumulatorValue);
}
public void Give_next_instruction_index_based_on_argument_value(
int currentInstructionIndex,
int instructionArgumentValue,
int expectedNextInstructionIndex)
{
// Given
var programContext = new ProgramContext(0, currentInstructionIndex);
var instruction = new JumpInstruction(instructionArgumentValue);
// When
var executionResult = instruction.Execute(programContext);
var actualNextInstructionIndex = executionResult.NextInstructionIndex;
// Then
Assert.Equal(expectedNextInstructionIndex, actualNextInstructionIndex);
}
public MainVM()
{
AddInRoutes();
using (ProgramContext context = new ProgramContext())
{
Routes = CollectionViewSource.GetDefaultView(context.Routes.ToList <Route>());
try
{
Routes = CollectionViewSource.GetDefaultView(context.Routes.ToList <Route>());
}
catch
{
Routes = null;
}
}
Routes.Filter = FilterRoute;
}
public ProgramContext program()
{
ProgramContext _localctx = new ProgramContext(Context, State);
EnterRule(_localctx, 0, RULE_program);
int _la;
try
{
EnterOuterAlt(_localctx, 1);
{
State = 18; type();
State = 19; Match(T__0);
State = 20; Match(T__1);
State = 21; Match(T__2);
State = 22; Match(T__3);
State = 24;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
do
{
{
{
State = 23; statement();
}
}
State = 26;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
} while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__9) | (1L << T__10) | (1L << T__11))) != 0));
State = 28; Match(T__4);
State = 29; Match(Eof);
}
}
catch (RecognitionException re)
{
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally
{
ExitRule();
}
return(_localctx);
}
/// <summary>
/// Add a program package to the database via Entityframework
/// </summary>
/// <param name="val"></param>
/// <param name="db"></param>
private static void AddProgramPackageToDatabase(XMLClasses.feedEntry val, ProgramContext db)
{
var program = new EF_Program {
ProgramName = val.title.Value
};
if (program.ProgramVersions == null)
{
program.ProgramVersions = new List <EF_ProgramVersion>();
}
program.ProgramVersions.Add(new EF_ProgramVersion {
Program = program, Version = val.properties.Version
});
db.Programs.Add(program);
}
public SkryptObject GetValue(string name)
{
var block = ProgramContext?.block();
if (block?.LexicalEnvironment.Variables.ContainsKey(name) == true)
{
return(block.LexicalEnvironment.Variables[name].Value);
}
else if (GlobalEnvironment.Variables.ContainsKey(name))
{
return(GlobalEnvironment.Variables[name].Value);
}
else
{
throw new VariableNotFoundException($"A variable with the name {name} was not found.");
}
}
public ActionResult Create(FormCollection formCollection)
{
if (Session["Email"] != null)
{
Programs programs = new Programs();
ProgramContext context = new ProgramContext();
programs.Name = formCollection["Name"];
programs.Type = formCollection["Type"];
context.Programs.Add(programs);
context.SaveChanges();
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index", "Home"));
}
public ActionResult Delete(int?id)
{
if (Session["Email"] != null)
{
if (id != null)
{
ProgramContext context = new ProgramContext();
Programs program = context.Programs.Single(pro => pro.Id == id);
return(View(program));
}
else
{
return(RedirectToAction("Index", "Program"));
}
}
return(RedirectToAction("Index", "Home"));
}
private void MainForm_Load(object sender, EventArgs e)
{
new Thread(() =>
{
this.UpdateStatusAsync("正在初始化...");
try
{
ProgramContext.Initialize();
this.UpdateStatusAsync("初始化完成");
this.UpdateRecognitionMenuItemsAsync(true);
}
catch (Exception error)
{
this.ShowMessagesAsync(error.Message, "初始化异常");
}
}).Start();
}
private void PopContext()
{
SafeHouse.Logger.Log("Popping context " + contexts.Count);
if (contexts.Any())
{
// remove the last context
var contextRemove = contexts.Last();
contexts.Remove(contextRemove);
contextRemove.DisableActiveFlyByWire(shared.BindingMgr);
SafeHouse.Logger.Log("Removed Context " + contextRemove.GetCodeFragment(0).FirstOrDefault());
if (contexts.Any())
{
currentContext = contexts.Last();
currentContext.EnableActiveFlyByWire(shared.BindingMgr);
RestorePointers();
SafeHouse.Logger.Log("New current context " + currentContext.GetCodeFragment(0).FirstOrDefault());
}
else
{
currentContext = null;
}
if (contexts.Count == 1)
{
shared.Interpreter.SetInputLock(false);
}
}
}
public FileParser(StreamReader stream, ProgramContext context)
{
this.tokenParser = new TokenParser(stream);
this.context = context;
}
private void PushInterpreterContext()
{
var interpreterContext = new ProgramContext(true);
// initialize the context with an empty program
interpreterContext.AddParts(new List<CodePart>());
PushContext(interpreterContext);
}
private void PushContext(ProgramContext context)
{
SafeHouse.Logger.Log("Pushing context staring with: " + context.GetCodeFragment(0).FirstOrDefault());
SaveAndClearPointers();
contexts.Add(context);
currentContext = contexts.Last();
if (contexts.Count > 1)
{
shared.Interpreter.SetInputLock(true);
}
}
public void RunProgram(List<Opcode> program, bool silent)
{
if (!program.Any()) return;
var newContext = new ProgramContext(false, program) { Silent = silent };
PushContext(newContext);
}
public void Boot()
{
// break all running programs
currentContext = null;
contexts.Clear();
PushInterpreterContext();
currentStatus = Status.Running;
currentTime = 0;
timeWaitUntil = 0;
maxUpdateTime = 0.0;
maxTriggersTime = 0.0;
maxExecutionTime = 0.0;
// clear stack (which also orphans all local variables so they can get garbage collected)
stack.Clear();
// clear global variables
globalVariables.Variables.Clear();
// clear interpreter
if (shared.Interpreter != null) shared.Interpreter.Reset();
// load functions
if (shared.FunctionManager != null) shared.FunctionManager.Load();
// load bindings
if (shared.BindingMgr != null) shared.BindingMgr.Load();
// Booting message
if (shared.Screen != null)
{
shared.Screen.ClearScreen();
string bootMessage = string.Format("kOS Operating System\n" + "KerboScript v{0}\n \n" + "Proceed.\n", Core.VersionInfo);
List<string> nags = Debug.GetPendingNags();
if (nags.Count > 0)
{
bootMessage +=
"##################################################\n" +
"# NAG MESSAGES #\n" +
"##################################################\n" +
"# Further details about these important messages #\n" +
"# can be found in the KSP error log. If you see #\n" +
"# this, then read the error log. It's important.#\n" +
"--------------------------------------------------\n";
bootMessage = nags.Aggregate(bootMessage, (current, msg) => current + (msg + "\n"));
bootMessage += "##################################################\n";
}
shared.Screen.Print(bootMessage);
}
if (shared.VolumeMgr == null) { SafeHouse.Logger.Log("No volume mgr"); }
else if (!shared.VolumeMgr.CheckCurrentVolumeRange(shared.Vessel)) { SafeHouse.Logger.Log("Boot volume not in range"); }
else if (shared.VolumeMgr.CurrentVolume == null) { SafeHouse.Logger.Log("No current volume"); }
else if (shared.ScriptHandler == null) { SafeHouse.Logger.Log("No script handler"); }
else
{
string filename = shared.Processor.BootFilename;
// Check to make sure the boot file name is valid, and then that the boot file exists.
if (string.IsNullOrEmpty(filename)) { SafeHouse.Logger.Log("Boot file name is empty, skipping boot script"); }
else if (filename.Equals("None", StringComparison.InvariantCultureIgnoreCase)) { SafeHouse.Logger.Log("Boot file name is \"None\", skipping boot script"); }
else if (shared.VolumeMgr.CurrentVolume.GetByName(filename) == null) { SafeHouse.Logger.Log(string.Format("Boot file \"{0}\" is missing, skipping boot script", filename)); }
else
{
var bootContext = "program";
var bootCommand = string.Format("run {0}.", filename);
var options = new CompilerOptions
{
LoadProgramsInSameAddressSpace = true,
FuncManager = shared.FunctionManager,
IsCalledFromRun = false
};
shared.ScriptHandler.ClearContext(bootContext);
List<CodePart> parts = shared.ScriptHandler.Compile(
"sys:boot", 1, bootCommand, bootContext, options);
var programContext = SwitchToProgramContext();
programContext.Silent = true;
programContext.AddParts(parts);
}
}
}
