public void ApplySignatureToProcedure(Address addr, ProcedureSignature sig, Procedure proc) { proc.Signature = sig; int i = 0; var stmts = proc.EntryBlock.Succ[0].Statements; var linAddr = addr.ToLinear(); foreach (var param in sig.Parameters) { var starg = param.Storage as StackArgumentStorage; if (starg != null) { proc.Frame.EnsureStackArgument( starg.StackOffset + sig.ReturnAddressOnStack, param.DataType, param.Name); } else { var paramId = proc.Frame.EnsureIdentifier(param.Storage); paramId.DataType = param.DataType; // Need to take an extra step with parameters being passed // in a register. It's perfectly possible for a user to // create a variable which they want to call 'r2' but which // the calling convention of the machine wants to call 'r1'. // To avoid this, we create a temporary identifier for // the formal parameter, and inject an copy statement in the // entry block that moves the parameter value into the // register. stmts.Insert(i, linAddr, NewMethod(param, paramId)); ++i; } } }
public void Test_Constructor_Procedure() { Procedure procedure = new Procedure(); InterpretationStep procedureStep = new InterpretationStep(procedure); Assert.IsNull(procedureStep.ReportPart); }
public IEnumerable<Parameter> GetParameters(Procedure storedProcedure) { var list = new List<Parameter>(); using (var connection = _connectionProvider.CreateConnection()) { connection.Open(); var command = connection.CreateCommand(); command.CommandType = CommandType.Text; command.CommandText = string.Format("SELECT * FROM information_schema.parameters WHERE SPECIFIC_NAME = '{0}';", storedProcedure.Name); using (var reader = command.ExecuteReader()) { while (reader.Read()) { list.Add(new Parameter ( reader["PARAMETER_NAME"].ToString(), SqlTypeResolver.GetClrType(reader["DATA_TYPE"].ToString()), GetParameterDirection(reader["PARAMETER_MODE"].ToString()), MysqlColumnInfo.GetDbType(reader["DATA_TYPE"].ToString()), Convert.IsDBNull(reader["CHARACTER_MAXIMUM_LENGTH"]) ? -1 : Convert.ToInt32(reader["CHARACTER_MAXIMUM_LENGTH"]) )); } } connection.Close(); return list; } }
public void Test_Name() { Procedure procedure = new Procedure(); InterpretationStep procedureStep = new InterpretationStep(procedure); Assert.AreEqual("Interpretation", procedureStep.Name); }
protected void TryAutoTerminateProcedureSteps(Procedure procedure, DateTime? time, IWorkflow workflow) { foreach (var mps in procedure.ModalityProcedureSteps) { // if the MPS is not terminated and has some MPPS if(!mps.IsTerminated && !mps.PerformedSteps.IsEmpty) { var allMppsDiscontinued = CollectionUtils.TrueForAll(mps.PerformedSteps, (PerformedProcedureStep pps) => pps.State == PerformedStepStatus.DC); var allMppsTerminated = CollectionUtils.TrueForAll(mps.PerformedSteps, (PerformedProcedureStep pps) => pps.IsTerminated); if (allMppsDiscontinued) { // discontinue MPS, since all MPPS are discontinued mps.Discontinue(time); } else if (allMppsTerminated) { // all MPPS are terminated, and at least one MPPS must be completed, so complete MPS mps.Complete(time); } } } }
public SegmentedAccessClassifier(Procedure proc, SsaIdentifierCollection ssaIds) { this.proc = proc; this.ssaIds = ssaIds; assocs = new Dictionary<Identifier,Identifier>(); consts = new Dictionary<Identifier, Constant>(); }
public void DisplayProcedure(Procedure proc) { if (proc == null) return; ShowWindow("codeViewerWindow", "Code Viewer", pane); pane.DisplayProcedure(proc); }
public void Test_CanApprove() { Procedure procedure = new Procedure(); Protocol protocol = new Protocol(procedure); ProtocolAssignmentStep procedureStep = new ProtocolAssignmentStep(protocol); Assert.AreEqual(ProtocolStatus.PN, procedureStep.Protocol.Status); Assert.IsFalse(procedureStep.CanApprove); protocol.SubmitForApproval(); Assert.AreEqual(ActivityStatus.SC, procedureStep.State); Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status); Assert.IsTrue(procedureStep.CanApprove); procedureStep.Start(new Staff()); Assert.AreEqual(ActivityStatus.IP, procedureStep.State); Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status); Assert.IsTrue(procedureStep.CanApprove); procedureStep.Suspend(); Assert.AreEqual(ActivityStatus.SU, procedureStep.State); Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status); Assert.IsFalse(procedureStep.CanApprove); procedureStep.Complete(); Assert.AreEqual(ActivityStatus.CM, procedureStep.State); Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status); Assert.IsFalse(procedureStep.CanApprove); // TODO : test all other Protocol state conditions }
public void CollectTypes() { desc.MeetDataType(program.Globals, factory.CreatePointer( factory.CreateStructureType(), program.Platform.PointerType.Size)); CollectSegmentTypes(); foreach (Procedure p in program.Procedures.Values) { proc = p; CollectProcedureSignature(p); foreach (Statement stm in p.Statements) { if (eventListener.IsCanceled()) return; try { stm.Instruction.Accept(this); } catch (Exception ex) { eventListener.Error( eventListener.CreateStatementNavigator(program, stm), ex, "An error occurred while processing the statement {0}.", stm); } } } }
private void Given_Procedure(uint address) { var m = new ProcedureBuilder("fnTest"); m.Return(); this.proc = m.Procedure; this.program.Procedures[Address.Ptr32(address)] = this.proc; }
public Cmd_EditSignature(IServiceProvider services, Program program, Procedure procedure, Address addr) : base(services) { this.program = program; this.procedure = procedure; this.address = addr; }
public void Transform(Procedure proc) { foreach (var stm in proc.Statements) { stm.Instruction.Accept(this); } }
public void Cmasp_Do() { var addr = Address.SegPtr(0x0C20, 0); var proc = new Procedure("foo", null); var progaddr = new ProgramAddress(program, addr); var dc = mr.Stub<IDecompiler>(); var dcSvc = mr.Stub<IDecompilerService>(); var brSvc = mr.Stub<IProjectBrowserService>(); dcSvc.Decompiler = dc; sc.AddService<IDecompilerService>(dcSvc); sc.AddService<IProjectBrowserService>(brSvc); sc.AddService<IDecompilerShellUiService>(new FakeShellUiService()); dc.Expect(d => d.ScanProcedure(progaddr)).IgnoreArguments().Return(proc); brSvc.Expect(b => b.Reload()); mr.ReplayAll(); var locations = new[] { new ProgramAddress(program, addr) }; var cmd = new Cmd_MarkProcedures(sc, locations); cmd.DoIt(); mr.VerifyAll(); Assert.AreEqual(1, program.User.Procedures.Count); var uproc = program.User.Procedures.Values[0]; Assert.AreEqual("0C20:0000", uproc.Address); }
public IEnumerable<Parameter> GetParameters(Procedure storedProcedure) { var parameters = _sqlReflection.ProcedureArguments .Where(p => p.Item1.InvariantEquals(storedProcedure.Name)) .Select(p => new Parameter(p.Item2, p.Item3, p.Item4)); return parameters; }
private string GuessName(Procedure_v1 userProc, Procedure proc = null) { if (userProc != null) { if (!string.IsNullOrEmpty(userProc.Name)) return userProc.Name; if (!string.IsNullOrEmpty(userProc.CSignature)) { int i = userProc.CSignature.IndexOf('('); if (i > 0) { var name = userProc.CSignature.Remove(i); do { --i; } while (i > 0 && (char.IsLetterOrDigit(name[i]) || name[i] == '_')); return name.Substring(i + 1); } } } if (proc != null) { return proc.Name; } else { return null; } }
public LiveCopyInserter(Procedure proc, SsaIdentifierCollection ssaIds) { this.proc = proc; this.ssaIds = ssaIds; this.sla = new SsaLivenessAnalysis(proc, ssaIds); this.doms = proc.CreateBlockDominatorGraph(); }
public Prior(Report r, Procedure rp, ProcedureType pt, Order o) { this.Report = r; this.Procedure = rp; this.ProcedureType = pt; this.Order = o; }
public static Schema.KRPC.Services GetServices() { var services = new Schema.KRPC.Services (); foreach (var serviceSignature in Services.Instance.Signatures.Values) { var service = new Schema.KRPC.Service (); service.Name = serviceSignature.Name; foreach (var procedureSignature in serviceSignature.Procedures.Values) { var procedure = new Procedure (); procedure.Name = procedureSignature.Name; if (procedureSignature.HasReturnType) { procedure.HasReturnType = true; procedure.ReturnType = TypeUtils.GetTypeName (procedureSignature.ReturnType); } foreach (var parameterSignature in procedureSignature.Parameters) { var parameter = new Parameter (); parameter.Name = parameterSignature.Name; parameter.Type = TypeUtils.GetTypeName (parameterSignature.Type); if (parameterSignature.HasDefaultArgument) { parameter.HasDefaultArgument = true; parameter.DefaultArgument = parameterSignature.DefaultArgument; } procedure.Parameters.Add (parameter); } foreach (var attribute in procedureSignature.Attributes) { procedure.Attributes.Add (attribute); } if (procedureSignature.Documentation != "") procedure.Documentation = procedureSignature.Documentation; service.Procedures.Add (procedure); } foreach (var clsSignature in serviceSignature.Classes.Values) { var cls = new Class (); cls.Name = clsSignature.Name; if (clsSignature.Documentation != "") cls.Documentation = clsSignature.Documentation; service.Classes.Add (cls); } foreach (var enmSignature in serviceSignature.Enumerations.Values) { var enm = new Enumeration (); enm.Name = enmSignature.Name; if (enmSignature.Documentation != "") enm.Documentation = enmSignature.Documentation; foreach (var enmValueSignature in enmSignature.Values) { var enmValue = new EnumerationValue (); enmValue.Name = enmValueSignature.Name; enmValue.Value = enmValueSignature.Value; if (enmValueSignature.Documentation != "") enmValue.Documentation = enmValueSignature.Documentation; enm.Values.Add (enmValue); } service.Enumerations.Add (enm); } if (serviceSignature.Documentation != "") service.Documentation = serviceSignature.Documentation; services.Services_.Add (service); } return services; }
public void Test_IsPreStep() { Procedure procedure = new Procedure(); DocumentationProcedureStep procedureStep = new DocumentationProcedureStep(procedure); Assert.IsFalse(procedureStep.IsPreStep); }
public void Test_Constructor() { Procedure procedure = new Procedure(); DocumentationProcedureStep procedureStep = new DocumentationProcedureStep(procedure); Assert.AreEqual(procedure, procedureStep.Procedure); }
// call public static CodeAddress call1 (Procedure p, int argc) { #if HAS_PERFORMANCE_COUNTERS if (Call.schemeCallCounter != null) Call.schemeCallCounter.Increment(); #endif throw new SchemeCallException (p, argc); }
public void Test_Name() { Procedure procedure = new Procedure(); DocumentationProcedureStep procedureStep = new DocumentationProcedureStep(procedure); Assert.AreEqual("Documentation", procedureStep.Name); }
protected void DumpSsaInfo(Procedure proc, SsaState ssa, TextWriter writer) { writer.WriteLine("// {0} ////////////////////////////////", proc.Name); DumpSsaTypes(ssa, writer); proc.Write(false, writer); writer.WriteLine(); }
///<summary>Inserts one Procedure into the database. Returns the new priKey.</summary> internal static long Insert(Procedure procedure) { if(DataConnection.DBtype==DatabaseType.Oracle) { procedure.ProcNum=DbHelper.GetNextOracleKey("procedurelog","ProcNum"); int loopcount=0; while(loopcount<100){ try { return Insert(procedure,true); } catch(Oracle.DataAccess.Client.OracleException ex){ if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){ procedure.ProcNum++; loopcount++; } else{ throw ex; } } } throw new ApplicationException("Insert failed. Could not generate primary key."); } else { return Insert(procedure,false); } }
public void Setup() { mr = new MockRepository(); program = new Program(); proc = new Procedure("testProc", new Frame(PrimitiveType.Word32)); block = proc.AddBlock("l00100000"); trace = new RtlTrace(0x00100000); r0 = new Identifier("r0", PrimitiveType.Word32, new RegisterStorage("r0", 0, 0, PrimitiveType.Word32)); r1 = new Identifier("r1", PrimitiveType.Word32, new RegisterStorage("r1", 1, 0, PrimitiveType.Word32)); r2 = new Identifier("r2", PrimitiveType.Word32, new RegisterStorage("r2", 2, 0, PrimitiveType.Word32)); sp = new Identifier("sp", PrimitiveType.Word32, new RegisterStorage("sp", 15, 0, PrimitiveType.Word32)); grf = proc.Frame.EnsureFlagGroup(Registers.eflags, 3, "SCZ", PrimitiveType.Byte); var sc = new ServiceContainer(); var listener = mr.Stub<DecompilerEventListener>(); scanner = mr.StrictMock<IScanner>(); arch = mr.Stub<IProcessorArchitecture>(); program.Architecture = arch; program.SegmentMap = new SegmentMap( Address.Ptr32(0x00100000), new ImageSegment( ".text", new MemoryArea(Address.Ptr32(0x00100000), new byte[0x20000]), AccessMode.ReadExecute)); arch.Replay(); program.Platform = new DefaultPlatform(null, arch); arch.BackToRecord(); arch.Stub(s => s.StackRegister).Return((RegisterStorage)sp.Storage); arch.Stub(s => s.PointerType).Return(PrimitiveType.Pointer32); scanner.Stub(s => s.Services).Return(sc); sc.AddService<DecompilerEventListener>(listener); }
public virtual IEnumerable<Parameter> GetParameters(Procedure storedProcedure) { var parameters = Reflector.ProcedureArguments .Where(p => p.Item1.InvariantEquals(storedProcedure.Name) && p.Item5.InvariantEquals(storedProcedure.Schema)) .Select(p => new Parameter(p.Item2, p.Item3, p.Item4)); return parameters; }
public bool BuildSignature(Address addr, Procedure proc) { Procedure_v1 userProc; if (program.User.Procedures.TryGetValue(addr, out userProc)) { var sProc = DeserializeSignature(userProc, proc); if (sProc != null) { var ser = program.CreateProcedureSerializer(); var sig = ser.Deserialize(sProc.Signature, proc.Frame); if (sig != null) { proc.Name = sProc.Name; ApplySignatureToProcedure(addr, sig, proc); return true; } } } if (proc.Signature.ParametersValid) { ApplySignatureToProcedure(addr, proc.Signature, proc); return true; } return false; }
Image GetImageFromGoogleCharts(Dimensions dimensions) { var chl = "&chl=" + Uri.EscapeDataString(GetValue<string>("text")); var chs = string.Format("&chs={0}x{1}", dimensions.Width, dimensions.Height); var choe = "&choe=" + GetEncodingString(); var chld = string.Format("&chld={0}|{1}", GetValue<string>("error_correction"), GetValue<int>("margin")); var url = "http://chart.apis.google.com/chart?cht=qr" + chl + chs + choe + chld; var procedure = new Procedure("file-uri-load"); try { var returnArgs = procedure.Run(url, url); return returnArgs[0] as Image; } catch (GimpSharpException e) { new Message(e.Message); return null; } }
protected void Page_Init(object sender, EventArgs e) { ctx = new AriClinicContext("AriClinicContext"); // security control, it must be a user logged if (Session["User"] == null) Response.Redirect("Default.aspx"); else { user = CntAriCli.GetUser((Session["User"] as User).UserId, ctx); Process proc = (from p in ctx.Processes where p.Code == "procedure" select p).FirstOrDefault<Process>(); per = CntAriCli.GetPermission(user.UserGroup, proc, ctx); btnAccept.Visible = per.Modify; } // if (Request.QueryString["ProcedureId"] != null) { procedureId = Int32.Parse(Request.QueryString["ProcedureId"]); proc = CntAriCli.GetProcedure(procedureId, ctx); LoadData(proc); } // Allways read parameter parameter = CntAriCli.GetParameter(ctx); }
public void Add(Procedure proc) { ++procCount; Program.Procedures[Address.Ptr32(procCount * 0x1000u)] = proc; Program.CallGraph.AddProcedure(proc); nameToProcedure[proc.Name] = proc; }
public ControlFlowGraphCleaner(Procedure proc) { this.proc = proc; }
///<summary>Returns null if there is no DFT defined for the enabled HL7Def.</summary> public static MessageHL7 GenerateDFT(List <Procedure> procList, EventTypeHL7 eventType, Patient pat, Patient guar, long aptNum, string pdfDescription, string pdfDataString) //add event (A04 etc) parameters later if needed //In \\SERVERFILES\storage\OPEN DENTAL\Programmers Documents\Standards (X12, ADA, etc)\HL7\Version2.6\V26_CH02_Control_M4_JAN2007.doc //On page 28, there is a Message Construction Pseudocode as well as a flowchart which might help. { Provider prov = Providers.GetProv(Patients.GetProvNum(pat)); Appointment apt = Appointments.GetOneApt(aptNum); MessageHL7 messageHL7 = new MessageHL7(MessageTypeHL7.DFT); HL7Def hl7Def = HL7Defs.GetOneDeepEnabled(); if (hl7Def == null) { return(null); } //find a DFT message in the def HL7DefMessage hl7DefMessage = null; for (int i = 0; i < hl7Def.hl7DefMessages.Count; i++) { if (hl7Def.hl7DefMessages[i].MessageType == MessageTypeHL7.DFT) { hl7DefMessage = hl7Def.hl7DefMessages[i]; //continue; break; } } if (hl7DefMessage == null) //DFT message type is not defined so do nothing and return { return(null); } for (int s = 0; s < hl7DefMessage.hl7DefSegments.Count; s++) { int countRepeat = 1; if (hl7DefMessage.hl7DefSegments[s].SegmentName == SegmentNameHL7.FT1) { countRepeat = procList.Count; } //for example, countRepeat can be zero in the case where we are only sending a PDF of the TP to eCW, and no procs. for (int repeat = 0; repeat < countRepeat; repeat++) //FT1 is optional and can repeat so add as many FT1's as procs in procList //if(hl7DefMessage.hl7DefSegments[s].SegmentName==SegmentNameHL7.FT1) { { if (hl7DefMessage.hl7DefSegments[s].SegmentName == SegmentNameHL7.FT1 && procList.Count > repeat) { prov = Providers.GetProv(procList[repeat].ProvNum); } SegmentHL7 seg = new SegmentHL7(hl7DefMessage.hl7DefSegments[s].SegmentName); seg.SetField(0, hl7DefMessage.hl7DefSegments[s].SegmentName.ToString()); for (int f = 0; f < hl7DefMessage.hl7DefSegments[s].hl7DefFields.Count; f++) { string fieldName = hl7DefMessage.hl7DefSegments[s].hl7DefFields[f].FieldName; if (fieldName == "") //If fixed text instead of field name just add text to segment { seg.SetField(hl7DefMessage.hl7DefSegments[s].hl7DefFields[f].OrdinalPos, hl7DefMessage.hl7DefSegments[s].hl7DefFields[f].FixedText); } else { //seg.SetField(hl7DefMessage.hl7DefSegments[s].hl7DefFields[f].OrdinalPos, //FieldConstructor.GenerateDFT(hl7Def,fieldName,pat,prov,procList[repeat],guar,apt,repeat+1,eventType,pdfDescription,pdfDataString)); Procedure proc = null; if (procList.Count > repeat) //procList could be an empty list { proc = procList[repeat]; } seg.SetField(hl7DefMessage.hl7DefSegments[s].hl7DefFields[f].OrdinalPos, FieldConstructor.GenerateDFT(hl7Def, fieldName, pat, prov, proc, guar, apt, repeat + 1, eventType, pdfDescription, pdfDataString)); } } messageHL7.Segments.Add(seg); } } return(messageHL7); }
public SsaState(Procedure proc) { this.Procedure = proc; this.Identifiers = new SsaIdentifierCollection(); }
public CompoundConditionCoalescer(Procedure proc) { this.proc = proc; this.m = new ExpressionEmitter(); }
public TailReturnRemover(Procedure proc) { this.proc = proc; }
public ProcedureNavigator(Program program, Procedure proc, IServiceProvider sp) { this.program = program; this.Procedure = proc; this.sp = sp; }
public NeoValue Call(NeoValue[] arguments) { var scope = new Scope(ParentScope); var level = scope.Level; var pargs = new List <NeoValue>(); foreach (var arg in arguments) { if (arg is NeoSpreadValue va) { for (var i = 0; i < va.Array.Count; i++) { pargs.Add(va.Array[i]); } } else { pargs.Add(arg); } } var varargs = new NeoArray(); var extraArgs = pargs.Count - Procedure.Parameters.Length; if (extraArgs > 0) { for (var i = 0; i < extraArgs; i++) { varargs.Insert(pargs[Procedure.Parameters.Length + i]); } } for (var i = 0; i < Procedure.Parameters.Length; i++) { var name = Procedure.Parameters[i].Name; scope.Declare(name, VariableFlags.NONE); var value = i < pargs.Count ? pargs[i] : NeoNil.NIL; if (Procedure.Parameters[i].Frozen) { value = value.Frozen(); } scope.Set(name, value); } var code = Procedure.Instructions; var ip = 4; var stack = new Stack <NeoValue>(); var rootScopeLevel = scope.Level; var openUps = new Dictionary <string, UpValue>(); var defers = new Stack <NeoProcedure>(); byte ReadByte() => code[ip++]; OpCode ReadOpCode() => (OpCode)ReadByte(); short ReadShort() => (short)(ReadByte() | (ReadByte() << 8)); int ReadInt() => ReadByte() | (ReadByte() << 8) | (ReadByte() << 16) | (ReadByte() << 24); NeoValue ReadConstant() => Procedure.Constants[ReadInt()]; while (ip < code.Length) { var op = ReadOpCode(); try { switch (op) { case OpCode.NOP: break; case OpCode.INC: { stack.Push(stack.Pop().Inc()); } break; case OpCode.DEC: { stack.Push(stack.Pop().Dec()); } break; case OpCode.ADD: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Add(b)); } break; case OpCode.SUB: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Sub(b)); } break; case OpCode.MUL: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Mul(b)); } break; case OpCode.DIV: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Div(b)); } break; case OpCode.POW: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Pow(b)); } break; case OpCode.MOD: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Mod(b)); } break; case OpCode.LSH: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Lsh(b)); } break; case OpCode.RSH: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Rsh(b)); } break; case OpCode.BIT_NOT: { stack.Push(stack.Pop().BitNot()); } break; case OpCode.BIT_AND: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.BitAnd(b)); } break; case OpCode.BIT_OR: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.BitOr(b)); } break; case OpCode.BIT_XOR: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.BitXor(b)); } break; case OpCode.NOT: { stack.Push(stack.Pop().Not()); } break; case OpCode.NEG: { stack.Push(stack.Pop().Neg()); } break; case OpCode.CONCAT: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Concat(b)); } break; case OpCode.LENGTH: { stack.Push(stack.Pop().Length()); } break; case OpCode.ARRAY_NEW: { stack.Push(new NeoArray()); } break; case OpCode.ARRAY_ADD: { var element = stack.Pop(); var array = stack.Pop().CheckArray(); array.Insert(element); } break; case OpCode.OBJECT_NEW: { stack.Push(new NeoObject()); } break; case OpCode.OBJECT_INDEX: { var index = stack.Pop().CheckInt(); var obj = stack.Pop().CheckObject(); stack.Push(obj.Index(index.Value)); stack.Push(obj.Get(obj.Index(index.Value))); } break; case OpCode.GET: { var key = stack.Pop(); var obj = stack.Pop(); stack.Push(obj.Get(key)); } break; case OpCode.SET: { var value = stack.Pop(); var key = stack.Pop(); var obj = stack.Pop(); obj.Set(key, value); } break; case OpCode.SLICE: { var end = stack.Pop(); var start = stack.Pop(); stack.Push(stack.Pop().Slice(start, end)); } break; case OpCode.EQ: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Eq(b)); } break; case OpCode.NE: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Ne(b)); } break; case OpCode.DEEP_EQ: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.DeepEq(b)); } break; case OpCode.DEEP_NE: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.DeepNe(b)); } break; case OpCode.LT: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Lt(b)); } break; case OpCode.GT: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Gt(b)); } break; case OpCode.LTE: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Lte(b)); } break; case OpCode.GTE: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(a.Gte(b)); } break; case OpCode.CMP: { var b = stack.Pop(); var a = stack.Pop(); stack.Push(NeoInt.ValueOf(a.Compare(b))); } break; case OpCode.JUMP: { ip = ReadInt(); } break; case OpCode.JUMP_IF: { var addr = ReadInt(); if (stack.Pop().CheckBool().Value) { ip = addr; } } break; case OpCode.CALL: { var line = Procedure.FindLine(ip); var nargs = ReadShort(); var args = new NeoValue[nargs]; for (var i = nargs - 1; i >= 0; i--) { args[i] = stack.Pop(); } var callee = stack.Pop(); if (callee.IsProcedure) { var proc = callee.CheckProcedure(); VM.PushFrame(proc.ChunkName(), proc.Name(), line); stack.Push(proc.Call(args)); VM.PopFrame(); } else { VM.PushFrame("<unknown>", "<unknown>", line); stack.Push(callee.Call(args)); VM.PopFrame(); } } break; case OpCode.RETURN: { foreach (var up in openUps.Values) { up.Close(); } NeoValue rvalue = null; if (ReadByte() == 1) { rvalue = stack.Pop(); } else { if (stack.Count > 0) { throw new Exception("VM error: stack not empty"); } rvalue = NeoNil.NIL; } while (defers.Count > 0) { defers.Pop().Call(new NeoValue[0]); } return(rvalue); } case OpCode.DEFER: { defers.Push(stack.Pop().CheckProcedure()); } break; case OpCode.VARARGS: { if (!Procedure.Varargs) { stack.Push(NeoNil.NIL); } else { stack.Push(varargs); } } break; case OpCode.PUSH_TRUE: { stack.Push(NeoBool.TRUE); } break; case OpCode.PUSH_FALSE: { stack.Push(NeoBool.FALSE); } break; case OpCode.PUSH_NIL: { stack.Push(NeoNil.NIL); } break; case OpCode.PUSH_CONSTANT: { stack.Push(ReadConstant()); } break; case OpCode.DUP: { var a = stack.Pop(); stack.Push(a); stack.Push(a); } break; case OpCode.SWAP: { var a = stack.Pop(); var b = stack.Pop(); stack.Push(a); stack.Push(b); } break; case OpCode.POP: { stack.Pop(); } break; case OpCode.CLOSURE: { var name = ReadConstant().CheckString().Value; var proc = Procedure.Procedures.First(p => p.Name == name); var upvalues = new UpValue[proc.UpValues.Length]; for (var i = 0; i < upvalues.Length; i++) { var pop = ReadOpCode(); if (pop != OpCode.GET_LOCAL && pop != OpCode.GET_UPVALUE) { throw new Exception(pop.ToString()); } var upname = ReadConstant().CheckString().Value; switch (pop) { case OpCode.GET_LOCAL: { if (!openUps.ContainsKey(upname)) { openUps[upname] = new UpValue(scope, upname); } upvalues[i] = openUps[upname]; } break; case OpCode.GET_UPVALUE: { upvalues[i] = this.upvalues.First(up => up.Name == upname); } break; } } stack.Push(new NeoBackendProcedure(VM, VM.Interpreter.Compile(scope, Chunk, proc, upvalues))); } break; case OpCode.CLOSE: { var name = ReadConstant().CheckString().Value; if (openUps.ContainsKey(name)) { openUps[name].Close(); openUps.Remove(name); } } break; case OpCode.GET_LOCAL: {; stack.Push(scope.Get(ReadConstant().CheckString().Value)); } break; case OpCode.SET_LOCAL: { var name = ReadConstant().CheckString().Value; var value = stack.Pop(); scope.Set(name, value); } break; case OpCode.GET_GLOBAL: { stack.Push(ParentScope.Get(ReadConstant().CheckString().Value)); } break; case OpCode.SET_GLOBAL: { ParentScope.Set(ReadConstant().CheckString().Value, stack.Pop()); } break; case OpCode.GET_UPVALUE: { var name = ReadConstant().CheckString().Value; var up = upvalues.First(u => u.Name == name); stack.Push(up.Get()); } break; case OpCode.SET_UPVALUE: { var name = ReadConstant().CheckString().Value; var index = 0; for (var i = 0; i < upvalues.Length; i++) { if (upvalues[i].Name == name) { index = i; break; } } upvalues[index].Set(stack.Pop()); } break; case OpCode.SPREAD: { stack.Push(new NeoSpreadValue(stack.Pop().CheckArray())); } break; case OpCode.FROZEN: { stack.Push(stack.Pop().Frozen()); } break; case OpCode.TRY: { var @catch = stack.Pop().CheckProcedure(); var @try = stack.Pop().CheckProcedure(); NeoValue r; try { r = @try.Call(new NeoValue[0]); } catch (NeoError e) { r = @catch.Call(new[] { NeoString.ValueOf(e.Message) }); } if (!r.IsNil) { foreach (var up in openUps.Values) { up.Close(); } while (defers.Count > 0) { defers.Pop().Call(new NeoValue[0]); } return(r); } } break; case OpCode.THROW: { var line = Procedure.FindLine(ip); throw new NeoError(stack.Pop().CheckString().Value, line); } case OpCode.DECLARE: { var name = ReadConstant().CheckString().Value; var flags = ReadByte(); scope.Declare(name, (VariableFlags)flags); } break; case OpCode.PUSH_SCOPE: { scope = new Scope(scope); } break; case OpCode.POP_SCOPE: { scope = scope.Parent; } break; default: { throw new Exception($"Unexpected opcode: {op}"); } } } catch (NeoError e) { if (e.Line == -1) { e.Line = Procedure.FindLine(ip); } throw e; } } throw new Exception("VM error"); }
public IEnumerable <Parameter> GetParameters(Procedure storedProcedure) { return(_mysqlSchemaDataProvider.GetParameters(storedProcedure)); }
/// <summary> /// Converts all registers and stack accesses to SSA variables. /// </summary> /// <param name="proc"></param> /// <returns>The SsaTransform for the procedure.</returns> public SsaTransform ConvertToSsa(Procedure proc) { if (program.NeedsSsaTransform) { // Transform the procedure to SSA state. When encountering 'call' // instructions, they can be to functions already visited. If so, // they have a "ProcedureFlow" associated with them. If they have // not been visited, or are computed destinations (e.g. vtables) // they will have no "ProcedureFlow" associated with them yet, in // which case the the SSA treats the call as a "hell node". var sst = new SsaTransform(program, proc, sccProcs !, dynamicLinker, this.ProgramDataFlow); var ssa = sst.Transform(); DumpWatchedProcedure("ssa", "After SSA", ssa.Procedure); // Merge unaligned memory accesses. var fuser = new UnalignedMemoryAccessFuser(ssa); fuser.Transform(); // After value propagation expressions like (x86) // mem[esp_42+4] will have been converted to mem[fp - 30]. // We also hope that procedure constants // kept in registers are propagated to the corresponding call // sites. var vp = new ValuePropagator(program.SegmentMap, ssa, program.CallGraph, dynamicLinker, eventListener); vp.Transform(); DumpWatchedProcedure("vp", "After first VP", ssa.Procedure); // Fuse additions and subtractions that are linked by the carry flag. var larw = new LongAddRewriter(ssa, eventListener); larw.Transform(); // Propagate condition codes and registers. var cce = new ConditionCodeEliminator(program, ssa, eventListener); cce.Transform(); vp.Transform(); DumpWatchedProcedure("cce", "After CCE", ssa.Procedure); // Now compute SSA for the stack-based variables as well. That is: // mem[fp - 30] becomes wLoc30, while // mem[fp + 30] becomes wArg30. // This allows us to compute the dataflow of this procedure. sst.RenameFrameAccesses = true; sst.Transform(); DumpWatchedProcedure("ssaframe", "After SSA frame accesses", ssa.Procedure); var icrw = new IndirectCallRewriter(program, ssa, eventListener); while (!eventListener.IsCanceled() && icrw.Rewrite()) { vp.Transform(); sst.RenameFrameAccesses = true; sst.Transform(); } var fpuGuesser = new FpuStackReturnGuesser(ssa, eventListener); fpuGuesser.Transform(); // By placing use statements in the exit block, we will collect // reaching definitions in the use statements. sst.AddUsesToExitBlock(); sst.RemoveDeadSsaIdentifiers(); // Backpropagate stack pointer from procedure return. var spBackpropagator = new StackPointerBackpropagator(ssa, eventListener); spBackpropagator.BackpropagateStackPointer(); DumpWatchedProcedure("spbp", "After SP BP", ssa.Procedure); // Propagate those newly created stack-based identifiers. vp.Transform(); DumpWatchedProcedure("vp2", "After VP2", ssa.Procedure); return(sst); } else { // We are assuming phi functions are already generated. var sst = new SsaTransform(program, proc, sccProcs !, dynamicLinker, this.ProgramDataFlow); return(sst); } }
//查询 protected void ASPxGridView1_CustomCallback(object sender, DevExpress.Web.ASPxGridView.ASPxGridViewCustomCallbackEventArgs e) { if (txtLSH1.Text.Trim() == "") { ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail"); ASPxGridView1.JSProperties.Add("cpCallbackRet", "起始流水号不能为空!"); return; } else if (txtLSH2.Text.Trim() == "") { ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail"); ASPxGridView1.JSProperties.Add("cpCallbackRet", "截止流水号不能为空!"); return; } int lsh1 = Convert.ToInt32(txtLSH1.Text.Trim()); int lsh2 = Convert.ToInt32(txtLSH2.Text.Trim()); string Chsql1 = "select * from DATA_PRODUCT where SN='" + txtLSH1.Text.Trim() + "' "; DataTable Chdt1 = dc.GetTable(Chsql1); if (Chdt1.Rows.Count <= 0) { ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail"); ASPxGridView1.JSProperties.Add("cpCallbackRet", "起始流水号不存在,请您重新输入!"); return; } string Chsql2 = "select * from DATA_PRODUCT where SN='" + txtLSH2.Text.Trim() + "' "; DataTable Chdt2 = dc.GetTable(Chsql2); if (Chdt2.Rows.Count <= 0) { ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail"); ASPxGridView1.JSProperties.Add("cpCallbackRet", "截止流水号不存在,请您重新输入!"); return; } if (lsh1 > lsh2) { ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail"); ASPxGridView1.JSProperties.Add("cpCallbackRet", "起始流水号应小于截止流水号!"); return; } string ZD1 = txtSCode.Text.Trim(); string sql = "", sn = ""; if (ZD1 != "") { sql = " select sn from DATA_SN_BOM where STATION_NAME='" + ZD1 + "' AND SN>='" + txtLSH1.Text.Trim() + "' and SN <='" + txtLSH2.Text.Trim() + "' " + "union select sn from DATA_SN_BOM_TEMP where STATION_NAME='" + ZD1 + "' AND SN>='" + txtLSH1.Text.Trim() + "' and SN <='" + txtLSH2.Text.Trim() + "'order by SN"; } else { sql = " select sn from DATA_SN_BOM where SN>='" + txtLSH1.Text.Trim() + "' and SN <='" + txtLSH2.Text.Trim() + "' " + " union select sn from DATA_SN_BOM where SN>='" + txtLSH1.Text.Trim() + "' and SN <='" + txtLSH2.Text.Trim() + "'order by SN"; } DataTable dt = dc.GetTable(sql); for (int i = 0; i < dt.Rows.Count; i++) { if (i == 0) { dc.ExeSql("delete from DATA_SCAN_ITEM where machinename='" + MachineName + "'"); } sn = dt.Rows[i][0].ToString(); //下边调用存储过程生成一个中间表,保存发动机的实际扫描零件清单 PL_INSERT_SJZJQD sp = new PL_INSERT_SJZJQD() { SN1 = sn, MACHINENAME1 = MachineName }; Procedure.run(sp); } setCondition(); ASPxGridView1.Selection.UnselectAll(); }
public override void Update(Procedure proc) { appl.Procedure = new ProcedureConstant(PrimitiveType.Pointer32, proc); }
private void butGenerateClaims_Click(object sender, EventArgs e) { if (gridMain.SelectedIndices.Count() < 1) { MsgBox.Show(this, "Please select the rows for which you would like to create procedures and claims."); return; } if (!MsgBox.Show(this, MsgBoxButtons.YesNo, "Are you sure you want to generate claims and procedures for all patients and insurance plans?")) { return; } List <long> listPlanNums = new List <long>(); List <long> listPatPlanNums = new List <long>(); List <long> listInsSubNums = new List <long>(); for (int i = 0; i < gridMain.SelectedIndices.Count(); i++) { DataRow rowCur = (DataRow)gridMain.Rows[gridMain.SelectedIndices[i]].Tag; listPlanNums.Add(PIn.Long(rowCur["PlanNum"].ToString())); listPatPlanNums.Add(PIn.Long(rowCur["PatPlanNum"].ToString())); listInsSubNums.Add(PIn.Long(rowCur["InsSubNum"].ToString())); } List <InsPlan> listSelectedInsPlans = InsPlans.GetPlans(listPlanNums); List <PatPlan> listSelectedPatPlans = PatPlans.GetPatPlans(listPatPlanNums); List <InsSub> listSelectedInsSubs = InsSubs.GetMany(listInsSubNums); List <DataRow> rowsSucceeded = new List <DataRow>(); int rowsFailed = 0; List <Benefit> listBenefitsAll = Benefits.Refresh(listSelectedPatPlans, listSelectedInsSubs); for (int i = 0; i < gridMain.SelectedIndices.Count(); i++) { try { DataRow rowCur = (DataRow)gridMain.Rows[gridMain.SelectedIndices[i]].Tag; long patNumCur = PIn.Long(rowCur["PatNum"].ToString()); Patient patCur = Patients.GetPat(patNumCur); PatientNote patNoteCur = PatientNotes.Refresh(patNumCur, patCur.Guarantor); long codeNumCur = PIn.Long(rowCur["AutoCodeNum"].ToString()); long provNumCur = PIn.Long(rowCur["ProvNum"].ToString()); long clinicNumCur = PIn.Long(rowCur["ClinicNum"].ToString()); long insPlanNumCur = PIn.Long(rowCur["PlanNum"].ToString()); long patPlanNumCur = PIn.Long(rowCur["PatPlanNum"].ToString()); long insSubNumCur = PIn.Long(rowCur["InsSubNum"].ToString()); int monthsTreat = PIn.Int(rowCur["MonthsTreat"].ToString()); DateTime dateDue = PIn.Date(rowCur["OrthoAutoNextClaimDate"].ToString()); //for each selected row //create a procedure //Procedures.CreateProcForPat(patNumCur,codeNumCur,"","",ProcStat.C,provNumCur); Procedure proc = Procedures.CreateOrthoAutoProcsForPat(patNumCur, codeNumCur, provNumCur, clinicNumCur, dateDue); InsPlan insPlanCur = InsPlans.GetPlan(insPlanNumCur, listSelectedInsPlans); PatPlan patPlanCur = listSelectedPatPlans.FirstOrDefault(x => x.PatPlanNum == patPlanNumCur); InsSub insSubCur = listSelectedInsSubs.FirstOrDefault(x => x.InsSubNum == insSubNumCur); List <Benefit> benefitList = listBenefitsAll.FindAll(x => x.PatPlanNum == patPlanCur.PatPlanNum || x.PlanNum == insSubCur.PlanNum); //create a claimproc List <ClaimProc> listClaimProcs = new List <ClaimProc>(); Procedures.ComputeEstimates(proc, patNumCur, ref listClaimProcs, true, new List <InsPlan> { insPlanCur }, new List <PatPlan> { patPlanCur }, benefitList, null, null, true, patCur.Age, new List <InsSub> { insSubCur }, isForOrtho: true); //make the feebilled == the insplan feebilled or patplan feebilled double feebilled = patPlanCur.OrthoAutoFeeBilledOverride == -1 ? insPlanCur.OrthoAutoFeeBilled : patPlanCur.OrthoAutoFeeBilledOverride; //create a claim with that claimproc string claimType = ""; switch (patPlanCur.Ordinal) { case 1: claimType = "P"; break; case 2: claimType = "S"; break; } DateTimeOD dateTMonthsRem = new DateTimeOD(PIn.Date(rowCur["DateBanding"].ToString()).AddMonths(PIn.Int(rowCur["MonthsTreat"].ToString())), DateTimeOD.Today); Claims.CreateClaimForOrthoProc(claimType, patPlanCur, insPlanCur, insSubCur, ClaimProcs.GetForProcWithOrdinal(proc.ProcNum, patPlanCur.Ordinal), proc, feebilled, PIn.Date(rowCur["DateBanding"].ToString()), PIn.Int(rowCur["MonthsTreat"].ToString()), ((dateTMonthsRem.YearsDiff * 12) + dateTMonthsRem.MonthsDiff)); PatPlans.IncrementOrthoNextClaimDates(patPlanCur, insPlanCur, monthsTreat, patNoteCur); rowsSucceeded.Add(rowCur); SecurityLogs.MakeLogEntry(Permissions.ProcComplCreate, patCur.PatNum , Lan.g(this, "Automatic ortho procedure and claim generated for") + " " + dateDue.ToShortDateString()); } catch (Exception) { rowsFailed++; } } string message = Lan.g(this, "Done.") + " " + Lan.g(this, "There were") + " " + rowsSucceeded.Count + " " + Lan.g(this, "claim(s) generated and") + " " + rowsFailed + " " + Lan.g(this, "failures") + "."; MessageBox.Show(message); foreach (DataRow row in rowsSucceeded) { _tableOutstandingAutoClaims.Rows.Remove(row); } FillGrid(); }
public abstract void Update(Procedure proc);
public override void Update(Procedure proc) { ci.Callee = new ProcedureConstant(PrimitiveType.Word32, proc); }
/// <summary> /// Выполняет работу с записями о выполнении задачи /// </summary> /// <param name="sender"></param> /// <param name="e"></param> protected override void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e) { backgroundWorker.ReportProgress(50); Invoke(new Action(() => listViewCompliance.Items.Clear())); if (_currentDirective == null) { e.Cancel = true; return; } List <AbstractPerformanceRecord> lastRecords = new List <AbstractPerformanceRecord>(); List <NextPerformance> nextPerformances = new List <NextPerformance>(); if (_openPubAudits == null) { _openPubAudits = new CommonCollection <Audit>(); } _openPubAudits.Clear(); //_openPubAudits.AddRange(GlobalObjects.CasEnvironment.Loader.GetWorkPackages(_currentDirective.ParentBaseDetail.ParentAircraft, WorkPackageStatus.Opened, true)); //_openPubAudits.AddRange(GlobalObjects.CasEnvironment.Loader.GetWorkPackages(_currentDirective.ParentBaseDetail.ParentAircraft, WorkPackageStatus.Published, true)); _openPubAudits.AddRange(GlobalObjects.AuditCore.GetAuditsLite(_currentDirective.ParentOperator, WorkPackageStatus.Opened)); _openPubAudits.AddRange(GlobalObjects.AuditCore.GetAuditsLite(_currentDirective.ParentOperator, WorkPackageStatus.Published)); CommonCollection <Audit> allWorkPackagesIncludedTask = new CommonCollection <Audit>(); CommonCollection <Audit> openPubWorkPackages = new CommonCollection <Audit>(); CommonCollection <Audit> closedWorkPackages = new CommonCollection <Audit>(); //Поиск и заполнение просроченных директив и записей о перемещении //Объекты для в которые будет извлекаться информация //из записеи о перемещении //прогнозируемый ресурс ForecastData forecastData = null; Aircraft parentAircraft = null; if (_currentDirective.ParentOperator != null) { ////если известна родительская деталь данной директивы, ////то ее текущая наработка и средняя утилизация ////используются в качестве ресурсов прогноза ////для расчета всех просроченных выполнений //forecastData = new ForecastData(DateTime.Now, // _currentDirective.ParentBaseDetail.AverageUtilization, // GlobalObjects.CasEnvironment.Calculator.GetLifelength(_currentDirective.ParentBaseDetail)); //parentAircraft = _currentDirective.ParentBaseDetail.ParentAircraft; } //расчет след. выполнений директивы. //если известен ресурс прогноза, то будут расчитаны все просрочнные выполнения //если неизвестне, то только первое GlobalObjects.PerformanceCalculator.GetNextPerformance(_currentDirective, forecastData); nextPerformances.AddRange(_currentDirective.NextPerformances); lastRecords.AddRange(_currentDirective.PerformanceRecords.ToArray()); //////////////////////////////////////////// //загрузка рабочих пакетов для определения //перекрытых ими выполнений задач //_openPubWorkPackages.AddRange(GlobalObjects.CasEnvironment.Loader.GetWorkPackages(parentAircraft, WorkPackageStatus.Opened, true)); //_openPubWorkPackages.AddRange(GlobalObjects.CasEnvironment.Loader.GetWorkPackages(parentAircraft, WorkPackageStatus.Published, true)); CommonCollection <Procedure> includedTasks = new CommonCollection <Procedure>(new[] { _currentDirective }); allWorkPackagesIncludedTask.AddRange(GlobalObjects.AuditCore.GetAuditsLite(_currentDirective.ParentOperator, WorkPackageStatus.All, includedTasks)); includedTasks.Clear(); #region Добавление в список просроченных выполнений //и сравнение их с открытыми и опубликованными рабочими пакетами openPubWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Opened || wp.Status == WorkPackageStatus.Published)); //сбор всех записей рабочих пакетов для удобства фильтрации List <AuditRecord> openPubWpRecords = openPubWorkPackages.SelectMany(wp => wp.AuditRecords).ToList(); //LINQ запрос для сортировки записей по дате List <NextPerformance> sortNextRecords = (from record in nextPerformances orderby GetDate(record) descending select record).ToList(); for (int i = 0; i < sortNextRecords.Count; i++) { if (backgroundWorker.CancellationPending) { allWorkPackagesIncludedTask.Clear(); openPubWorkPackages.Clear(); closedWorkPackages.Clear(); e.Cancel = true; return; } //поиск записи в рабочих пакетах по данному чеку //чей номер группы выполнения (по записи) совпадает с расчитанным Procedure directive = (Procedure)sortNextRecords[i].Parent; //номер выполнения int parentCountPerf; if (directive.LastPerformance != null) { parentCountPerf = directive.LastPerformance.PerformanceNum <= 0 ? 1 : directive.LastPerformance.PerformanceNum; } else { parentCountPerf = 0; } parentCountPerf += directive.NextPerformances.IndexOf(sortNextRecords[i]); parentCountPerf += 1; AuditRecord wpr = openPubWpRecords.FirstOrDefault(r => r.PerformanceNumFromStart == parentCountPerf && r.AuditItemTypeId == directive.SmartCoreObjectType.ItemId && r.DirectiveId == directive.ItemId); if (wpr != null) { Audit wp = openPubWorkPackages.GetItemById(wpr.AuditId); //запись о выполнении блокируется найденым пакетом sortNextRecords[i].BlockedByPackage = wp; //последующие записи о выполнении так же должны быть заблокированы for (int j = i - 1; j >= 0; j--) { //блокировать нужно все рабочие записи, или до первой записи, //заблокированной другим рабочим пакетом if (sortNextRecords[j].BlockedByPackage != null || sortNextRecords[j].Condition != ConditionState.Overdue) { break; } if (sortNextRecords[j].Parent == directive) { sortNextRecords[j].BlockedByPackage = wp; Invoke(new Action <int, Color>(SetItemColor), new object[] { j, Color.FromArgb(Highlight.GrayLight.Color) }); } } } Invoke(new Action <NextPerformance>(AddListViewItem), sortNextRecords[i]); } #endregion #region Добавление в список записей о произведенных выполнениях //и сравнение их с закрытыми рабочими пакетами closedWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Closed)); //LINQ запрос для сортировки записей по дате List <AbstractPerformanceRecord> sortLastRecords = (from record in lastRecords orderby record.RecordDate descending select record).ToList(); //////////////////////////////////////////// for (int i = 0; i < sortLastRecords.Count(); i++) { if (backgroundWorker.CancellationPending) { allWorkPackagesIncludedTask.Clear(); openPubWorkPackages.Clear(); closedWorkPackages.Clear(); e.Cancel = true; return; } DirectiveRecord directiveRecord = (DirectiveRecord)sortLastRecords[i]; Audit workPackage = closedWorkPackages.FirstOrDefault(wp => wp.ItemId == directiveRecord.DirectivePackageId); if (workPackage != null) { Invoke(new Action <AbstractPerformanceRecord, Audit, MaintenanceCheckRecord>(AddListViewItem), new object[] { sortLastRecords[i], workPackage, null }); } else if (directiveRecord.MaintenanceCheckRecordId > 0) { MaintenanceCheckRecord mcr = GlobalObjects.CasEnvironment.NewLoader.GetObject <DirectiveRecordDTO, MaintenanceCheckRecord>(new Filter("ItemId", directiveRecord.MaintenanceCheckRecordId)); if (mcr != null) { mcr.ParentCheck = GlobalObjects.CasEnvironment.NewLoader.GetObjectById <MaintenanceCheckDTO, MaintenanceCheck>(mcr.ParentId); } Invoke(new Action <AbstractPerformanceRecord, Audit, MaintenanceCheckRecord>(AddListViewItem), new object[] { sortLastRecords[i], workPackage, mcr }); } else { Invoke(new Action <AbstractPerformanceRecord, Audit>(AddListViewItem), new object[] { sortLastRecords[i], workPackage }); } } #endregion allWorkPackagesIncludedTask.Clear(); openPubWorkPackages.Clear(); closedWorkPackages.Clear(); backgroundWorker.ReportProgress(100); }
public static void Remove(Procedure p) { var uvr = new UnusedSymbolRemover(p); foreach (var bb in p.cfg.nodes) { foreach (var si in bb.statements) { uvr.visit(si.statementId); } } foreach (var ft in p.parentScope.functionTemplates) { ft.signature.resultType.visit(uvr); foreach (var at in ft.signature.argumentTypes) { at.visit(uvr); } } foreach (var v in p.parentScope.locals) { v.type.visit(uvr); } foreach (var v in p.locals) { v.type.visit(uvr); } foreach (var v in p.inputs) { v.type.visit(uvr); } foreach (var v in p.outputs) { v.type.visit(uvr); } // foreach (var e in ( from ft in p.parentScope.functionTemplates where ft.fae!=null select ft.fae)) // e.visitI(uvr); var deleted = new HashSet <StatementId>(); foreach (var f in uvr.functionOccurences) { if (f.Value.Count == 1 && !ExpressionSymbolCounter.isInterpreted(f.Key) && !deleted.Contains(f.Value.First().Value)) { Expression e = f.Value.First().Key.expression; // Console.WriteLine("Function {0} has one occurence: {1}", f.Key, e.ToString()); Expression qe = e; while (qe is QuantifiedTypeExpression) { qe = (qe as QuantifiedTypeExpression).expression; } while (qe is QuantifiedExpression) { qe = (qe as QuantifiedExpression).expression; } var fae = qe as FAE; if (fae != null) { if (BFunction.isEquality(fae.function) || BFunction.isEquivalence(fae.function) || BFunction.isImplication(fae.function)) { var a0fae = fae.arguments[0] as FAE; while (a0fae != null && (BFunction.isMapRead(a0fae.function) || BFunction.isCoerce(a0fae.function) || (a0fae.arguments.count == 1 && a0fae.function.name != f.Key))) { a0fae = a0fae.arguments[0] as FAE; } var a1fae = fae.arguments[1] as FAE; while (a1fae != null && (BFunction.isMapRead(a1fae.function) || BFunction.isCoerce(a1fae.function) || (a1fae.arguments.count == 1 && a1fae.function.name != f.Key))) { a1fae = a1fae.arguments[0] as FAE; } if ((a0fae != null && a0fae.function.name == f.Key) ^ (a1fae != null && a1fae.function.name == f.Key)) { // Console.WriteLine("\tDefinition - can be removed safely"); uvr.unusedFunctions.Add(f.Key); deleted.Add(f.Value.First().Value); f.Value.First().Value.delete(); } } } } } /////////////////////////////////////////////////////////// foreach (var v in uvr.unusedVariables) { if (p.tryFindVariable(v) != null) { p.removeVariable(v); } else { p.parentScope.removeVariable(v); } } foreach (var f in uvr.unusedFunctions) { p.removeFunctionTemplate(f); } foreach (var tc in uvr.unusedTypeConstructors) { p.removeTypeConstructor(tc); } foreach (var ts in uvr.unusedTypeSynonyms) { p.removeTypeSynonym(ts); } // return uvr; }
public AtomicActionInfo(Procedure proc, Ensures ensures, MoverType moverType, int layerNum, int availableUptoLayerNum) : base(proc, layerNum, availableUptoLayerNum) { this.ensures = ensures; this.moverType = moverType; this.gate = new List <AssertCmd>(); this.action = ensures.Condition as CodeExpr; this.thisGate = new List <AssertCmd>(); this.thisInParams = new List <Variable>(); this.thisOutParams = new List <Variable>(); this.thatGate = new List <AssertCmd>(); this.thatInParams = new List <Variable>(); this.thatOutParams = new List <Variable>(); this.hasAssumeCmd = false; this.thisMap = new Dictionary <Variable, Expr>(); this.thatMap = new Dictionary <Variable, Expr>(); foreach (Block block in this.action.Blocks) { block.Cmds.ForEach(x => this.hasAssumeCmd = this.hasAssumeCmd || x is AssumeCmd); } foreach (Block block in this.action.Blocks) { if (block.TransferCmd is ReturnExprCmd) { block.TransferCmd = new ReturnCmd(block.TransferCmd.tok); } } var cmds = this.action.Blocks[0].Cmds; for (int i = 0; i < cmds.Count; i++) { AssertCmd assertCmd = cmds[i] as AssertCmd; if (assertCmd == null) { break; } this.gate.Add(assertCmd); cmds[i] = new AssumeCmd(assertCmd.tok, Expr.True); } foreach (Variable x in proc.InParams) { Variable thisx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "this_" + x.Name, x.TypedIdent.Type), true, x.Attributes); this.thisInParams.Add(thisx); this.thisMap[x] = Expr.Ident(thisx); Variable thatx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), true, x.Attributes); this.thatInParams.Add(thatx); this.thatMap[x] = Expr.Ident(thatx); } foreach (Variable x in proc.OutParams) { Variable thisx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "this_" + x.Name, x.TypedIdent.Type), false, x.Attributes); this.thisOutParams.Add(thisx); this.thisMap[x] = Expr.Ident(thisx); Variable thatx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), false, x.Attributes); this.thatOutParams.Add(thatx); this.thatMap[x] = Expr.Ident(thatx); } List <Variable> thisLocVars = new List <Variable>(); List <Variable> thatLocVars = new List <Variable>(); foreach (Variable x in this.action.LocVars) { Variable thisx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "this_" + x.Name, x.TypedIdent.Type), false); thisMap[x] = Expr.Ident(thisx); thisLocVars.Add(thisx); Variable thatx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), false); thatMap[x] = Expr.Ident(thatx); thatLocVars.Add(thatx); } Contract.Assume(proc.TypeParameters.Count == 0); Substitution thisSubst = Substituter.SubstitutionFromHashtable(this.thisMap); Substitution thatSubst = Substituter.SubstitutionFromHashtable(this.thatMap); foreach (AssertCmd assertCmd in this.gate) { this.thisGate.Add((AssertCmd)Substituter.Apply(thisSubst, assertCmd)); this.thatGate.Add((AssertCmd)Substituter.Apply(thatSubst, assertCmd)); } this.thisAction = new CodeExpr(thisLocVars, SubstituteBlocks(this.action.Blocks, thisSubst, "this_")); this.thatAction = new CodeExpr(thatLocVars, SubstituteBlocks(this.action.Blocks, thatSubst, "that_")); { VariableCollector collector = new VariableCollector(); collector.Visit(this.action); this.actionUsedGlobalVars = new HashSet <Variable>(collector.usedVars.Where(x => x is GlobalVariable)); } List <Variable> modifiedVars = new List <Variable>(); foreach (Block block in this.action.Blocks) { block.Cmds.ForEach(cmd => cmd.AddAssignedVariables(modifiedVars)); } this.modifiedGlobalVars = new HashSet <Variable>(modifiedVars.Where(x => x is GlobalVariable)); { VariableCollector collector = new VariableCollector(); this.gate.ForEach(assertCmd => collector.Visit(assertCmd)); this.gateUsedGlobalVars = new HashSet <Variable>(collector.usedVars.Where(x => x is GlobalVariable)); } }
private void AddPerformance() { if (listViewCompliance.SelectedItems.Count == 0) { return; } DirectiveComplianceDialog dlg; DirectiveRecord record; NextPerformance np; if (listViewCompliance.SelectedItems[0].Tag is NextPerformance) { //if (_currentDirective.MaintenanceCheck != null) //{ // MessageBox.Show("This MPD is binded to maintenance check '" + _currentDirective.MaintenanceCheck.Name + "'." + // "\nPerformance for this item introduced by performance of maintenance check.", // (string)new GlobalTermsProvider()["SystemName"], // MessageBoxButtons.OK, // MessageBoxIcon.Warning, // MessageBoxDefaultButton.Button1); // return; //} np = (NextPerformance)listViewCompliance.SelectedItems[0].Tag; if (np.Condition != ConditionState.Overdue || np.PerformanceDate > DateTime.Now) { MessageBox.Show("You can not enter a record for not delayed performance", (string)new GlobalTermsProvider()["SystemName"], MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1); return; } if (np.BlockedByPackage != null) { MessageBox.Show("Perform of the task:" + listViewCompliance.SelectedItems[0].Text + "\nblocked by Package:" + "\n" + np.BlockedByPackage.Title, (string)new GlobalTermsProvider()["SystemName"], MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1); return; } dlg = new DirectiveComplianceDialog(np.Parent, np) { Text = "Add new compliance for " + np.WorkType }; dlg.ShowDialog(); if (dlg.DialogResult == DialogResult.OK) { InvokeComplianceAdded(null); } } else if (listViewCompliance.SelectedItems[0].Tag is DirectiveRecord) { record = (DirectiveRecord)listViewCompliance.SelectedItems[0].Tag; IDirective directive = record.Parent; if (directive is Procedure) { Procedure parentDirective = (Procedure)directive; dlg = new DirectiveComplianceDialog(record.Parent, record) { Text = "Edit exist compliance for " + parentDirective.ProcedureType }; dlg.ShowDialog(); if (dlg.DialogResult == DialogResult.OK) { InvokeComplianceAdded(null); } } else if (directive is ComponentDirective) { ComponentDirective parentDirective = (ComponentDirective)directive; dlg = new DirectiveComplianceDialog(record.Parent, record) { Text = "Edit exist compliance for " + parentDirective.DirectiveType + " of " + parentDirective.ParentComponent.Description }; dlg.ShowDialog(); if (dlg.DialogResult == DialogResult.OK) { InvokeComplianceAdded(null); } } } else { return; } }
public override Procedure VisitProcedure(Procedure node) { node.Attributes = RemoveLayerAttribute(node.Attributes); return(base.VisitProcedure(node)); }
public void TypeCheck() { foreach (var proc in program.Procedures) { if (!QKeyValue.FindBoolAttribute(proc.Attributes, "pure")) { continue; } if (QKeyValue.FindBoolAttribute(proc.Attributes, "yields")) { Error(proc, "Pure procedure must not yield"); continue; } if (QKeyValue.FindBoolAttribute(proc.Attributes, "layer")) { Error(proc, "Pure procedure must not have layers"); continue; } if (proc.Modifies.Count > 0) { Error(proc, "Pure procedure must not modify a global variable"); continue; } procToAtomicProcedureInfo[proc] = new AtomicProcedureInfo(); } foreach (var proc in program.Procedures) { if (QKeyValue.FindBoolAttribute(proc.Attributes, "yields")) { continue; } var procLayerNums = FindLayers(proc.Attributes); if (procLayerNums.Count == 0) { continue; } foreach (IdentifierExpr ie in proc.Modifies) { if (!globalVarToSharedVarInfo.ContainsKey(ie.Decl)) { Error(proc, "Atomic procedure cannot modify a global variable without layer numbers"); continue; } } int lower, upper; if (procLayerNums.Count == 1) { lower = procLayerNums[0]; upper = procLayerNums[0]; } else if (procLayerNums.Count == 2) { lower = procLayerNums[0]; upper = procLayerNums[1]; if (lower >= upper) { Error(proc, "Lower layer must be less than upper layer"); continue; } } else { Error(proc, "Atomic procedure must specify a layer range"); continue; } LayerRange layerRange = new LayerRange(lower, upper); procToAtomicProcedureInfo[proc] = new AtomicProcedureInfo(layerRange); } if (errorCount > 0) { return; } foreach (Implementation impl in program.Implementations) { if (!procToAtomicProcedureInfo.ContainsKey(impl.Proc)) { continue; } var atomicProcedureInfo = procToAtomicProcedureInfo[impl.Proc]; if (atomicProcedureInfo.isPure) { this.enclosingImpl = impl; (new PurityChecker(this)).VisitImplementation(impl); } else { this.enclosingImpl = impl; this.sharedVarsAccessed = new HashSet <Variable>(); (new PurityChecker(this)).VisitImplementation(impl); LayerRange upperBound = FindLayerRange(); LayerRange lowerBound = atomicProcedureInfo.layerRange; if (!lowerBound.Subset(upperBound)) { Error(impl, "Atomic procedure cannot access global variable"); } this.sharedVarsAccessed = null; } } if (errorCount > 0) { return; } foreach (var proc in program.Procedures) { if (!QKeyValue.FindBoolAttribute(proc.Attributes, "yields")) { continue; } int createdAtLayerNum; // must be initialized by the following code, otherwise it is an error int availableUptoLayerNum = int.MaxValue; List <int> attrs = FindLayers(proc.Attributes); if (attrs.Count == 1) { createdAtLayerNum = attrs[0]; } else if (attrs.Count == 2) { createdAtLayerNum = attrs[0]; availableUptoLayerNum = attrs[1]; } else { Error(proc, "Incorrect number of layers"); continue; } foreach (Ensures e in proc.Ensures) { MoverType moverType = GetMoverType(e); if (moverType == MoverType.Top) { continue; } CodeExpr codeExpr = e.Condition as CodeExpr; if (codeExpr == null) { Error(e, "An atomic action must be a CodeExpr"); continue; } if (procToActionInfo.ContainsKey(proc)) { Error(proc, "A procedure can have at most one atomic action"); continue; } if (availableUptoLayerNum <= createdAtLayerNum) { Error(proc, "Creation layer number must be less than the available upto layer number"); continue; } sharedVarsAccessed = new HashSet <Variable>(); enclosingProc = proc; enclosingImpl = null; base.VisitEnsures(e); LayerRange upperBound = FindLayerRange(); LayerRange lowerBound = new LayerRange(createdAtLayerNum, availableUptoLayerNum); if (lowerBound.Subset(upperBound)) { procToActionInfo[proc] = new AtomicActionInfo(proc, e, moverType, createdAtLayerNum, availableUptoLayerNum); } else { Error(e, "A variable being accessed in this action is unavailable"); } sharedVarsAccessed = null; } if (errorCount > 0) { continue; } if (!procToActionInfo.ContainsKey(proc)) { if (availableUptoLayerNum < createdAtLayerNum) { Error(proc, "Creation layer number must be no more than the available upto layer number"); continue; } else { procToActionInfo[proc] = new ActionInfo(proc, createdAtLayerNum, availableUptoLayerNum); } } } if (errorCount > 0) { return; } foreach (var impl in program.Implementations) { if (!procToActionInfo.ContainsKey(impl.Proc)) { continue; } ActionInfo actionInfo = procToActionInfo[impl.Proc]; procToActionInfo[impl.Proc].hasImplementation = true; if (actionInfo.isExtern) { Error(impl.Proc, "Extern procedure cannot have an implementation"); } } if (errorCount > 0) { return; } foreach (Procedure proc in procToActionInfo.Keys) { for (int i = 0; i < proc.InParams.Count; i++) { Variable v = proc.InParams[i]; var layer = FindLocalVariableLayer(proc, v, procToActionInfo[proc].createdAtLayerNum); if (layer == int.MinValue) { continue; } localVarToLocalVariableInfo[v] = new LocalVariableInfo(layer); } for (int i = 0; i < proc.OutParams.Count; i++) { Variable v = proc.OutParams[i]; var layer = FindLocalVariableLayer(proc, v, procToActionInfo[proc].createdAtLayerNum); if (layer == int.MinValue) { continue; } localVarToLocalVariableInfo[v] = new LocalVariableInfo(layer); } } foreach (Implementation node in program.Implementations) { if (!procToActionInfo.ContainsKey(node.Proc)) { continue; } foreach (Variable v in node.LocVars) { var layer = FindLocalVariableLayer(node, v, procToActionInfo[node.Proc].createdAtLayerNum); if (layer == int.MinValue) { continue; } localVarToLocalVariableInfo[v] = new LocalVariableInfo(layer); } for (int i = 0; i < node.Proc.InParams.Count; i++) { Variable v = node.Proc.InParams[i]; if (!localVarToLocalVariableInfo.ContainsKey(v)) { continue; } var layer = localVarToLocalVariableInfo[v].layer; localVarToLocalVariableInfo[node.InParams[i]] = new LocalVariableInfo(layer); } for (int i = 0; i < node.Proc.OutParams.Count; i++) { Variable v = node.Proc.OutParams[i]; if (!localVarToLocalVariableInfo.ContainsKey(v)) { continue; } var layer = localVarToLocalVariableInfo[v].layer; localVarToLocalVariableInfo[node.OutParams[i]] = new LocalVariableInfo(layer); } } if (errorCount > 0) { return; } this.VisitProgram(program); if (errorCount > 0) { return; } YieldTypeChecker.PerformYieldSafeCheck(this); new LayerEraser().VisitProgram(program); }
public MapWriteRemover(Procedure procedure, TypeInstanceCollector tic) : base(procedure) { this.tic = tic; }
public static void remove(Procedure procedure, TypeInstanceCollector tic) { new MapWriteRemover(procedure, tic).remove(); }
public void Claims_CalculateAndUpdate_Allowed1Allowed2CompletedProcedures() { string suffix = "8"; Patient pat = PatientT.CreatePatient(suffix); long patNum = pat.PatNum; long feeSchedNum1 = FeeSchedT.CreateFeeSched(FeeScheduleType.Normal, suffix); long feeSchedNum2 = FeeSchedT.CreateFeeSched(FeeScheduleType.Normal, suffix + "b"); //Standard Fee long codeNum = ProcedureCodes.GetCodeNum("D2750"); Fee fee = Fees.GetFee(codeNum, 53, 0, 0); if (fee == null) { fee = new Fee(); fee.CodeNum = codeNum; fee.FeeSched = 53; fee.Amount = 1200; Fees.Insert(fee); } else { fee.Amount = 1200; Fees.Update(fee); } //PPO fees fee = new Fee(); fee.CodeNum = codeNum; fee.FeeSched = feeSchedNum1; fee.Amount = 600; Fees.Insert(fee); fee = new Fee(); fee.CodeNum = codeNum; fee.FeeSched = feeSchedNum2; fee.Amount = 800; Fees.Insert(fee); //Carrier Carrier carrier = CarrierT.CreateCarrier(suffix); long planNum1 = InsPlanT.CreateInsPlanPPO(carrier.CarrierNum, feeSchedNum1).PlanNum; long planNum2 = InsPlanT.CreateInsPlanPPO(carrier.CarrierNum, feeSchedNum2).PlanNum; InsSub sub1 = InsSubT.CreateInsSub(pat.PatNum, planNum1); long subNum1 = sub1.InsSubNum; InsSub sub2 = InsSubT.CreateInsSub(pat.PatNum, planNum2); long subNum2 = sub2.InsSubNum; BenefitT.CreateCategoryPercent(planNum1, EbenefitCategory.Crowns, 50); BenefitT.CreateCategoryPercent(planNum2, EbenefitCategory.Crowns, 50); BenefitT.CreateAnnualMax(planNum1, 1000); BenefitT.CreateAnnualMax(planNum2, 1000); PatPlanT.CreatePatPlan(1, patNum, subNum1); PatPlanT.CreatePatPlan(2, patNum, subNum2); Procedure proc = ProcedureT.CreateProcedure(pat, "D2750", ProcStat.TP, "8", Fees.GetAmount0(codeNum, 53)); //crown on 8 long procNum = proc.ProcNum; //Lists List <ClaimProc> claimProcs = ClaimProcs.Refresh(patNum); Family fam = Patients.GetFamily(patNum); List <InsSub> subList = InsSubs.RefreshForFam(fam); List <InsPlan> planList = InsPlans.RefreshForSubList(subList); List <PatPlan> patPlans = PatPlans.Refresh(patNum); List <Benefit> benefitList = Benefits.Refresh(patPlans, subList); List <Procedure> procList = Procedures.Refresh(patNum); //Set complete and attach to claim ProcedureT.SetComplete(proc, pat, planList, patPlans, claimProcs, benefitList, subList); claimProcs = ClaimProcs.Refresh(patNum); List <Procedure> procsForClaim = new List <Procedure>(); procsForClaim.Add(proc); Claim claim = ClaimT.CreateClaim("P", patPlans, planList, claimProcs, procList, pat, procsForClaim, benefitList, subList); //Validate Assert.AreEqual(500, claim.WriteOff); }
protected void ASPxGridView1_CustomCallback(object sender, DevExpress.Web.ASPxGridView.ASPxGridViewCustomCallbackEventArgs e) { if (ASPxDateEdit1.Date.AddDays(31) < ASPxDateEdit2.Date) { ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail"); ASPxGridView1.JSProperties.Add("cpCallbackRet", "选择日期范围不能超过30天,请重新选择!"); return; } //判断是否改制发动机 if (txtSN.Text.Trim() != "") { string gzsql = "select a.plan_type from data_plan a left join data_plan_sn b on a.plan_code=b.plan_code where b.sn='" + txtSN.Text.Trim() + "'"; string type = dc.GetValue(gzsql); if (type != "C" || type != "D") { //弹出提示框不是改制流水号 ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail"); ASPxGridView1.JSProperties.Add("cpCallbackRet", "该流水号不是改制流水号,请您重新输入!"); return; } //下边程序动态生成一个中间表,保存发动机的实际扫描零件清单 dc.ExeSql("delete from DATA_SCAN_ITEM where machinename='" + MachineName + "'"); PL_INSERT_SJZJQD sp = new PL_INSERT_SJZJQD() { SN1 = txtSN.Text.Trim(), MACHINENAME1 = MachineName }; Procedure.run(sp); } else { string datetime = ASPxDateEdit2.Date.ToShortDateString() + " 23:59:59"; string sql = " select sn from DATA_SN_BOM where sn in( select b.sn from data_plan a left join data_plan_sn b on a.plan_code=b.plan_code where (a.plan_type='C' or a.plan_type='D')) "; if (ASPxDateEdit1.Text.Trim() != "") { sql = sql + " and CREATE_TIME>=to_date('" + ASPxDateEdit1.Text.Trim() + "','yyyy-mm-dd hh24:mi:ss')"; } if (ASPxDateEdit2.Text.Trim() != "") { sql = sql + " and CREATE_TIME<=to_date('" + datetime + "','yyyy-mm-dd hh24:mi:ss')"; } sql = sql + "union select sn from DATA_SN_BOM_TEMP where sn in( select sn from data_record )"; if (ASPxDateEdit1.Text.Trim() != "") { sql = sql + " and CREATE_TIME>=to_date('" + ASPxDateEdit1.Text.Trim() + "','yyyy-mm-dd hh24:mi:ss')"; } if (ASPxDateEdit2.Text.Trim() != "") { sql = sql + " and CREATE_TIME<=to_date('" + datetime + "','yyyy-mm-dd hh24:mi:ss')"; } sql = sql + " order by SN"; DataTable dt = dc.GetTable(sql); for (int i = 0; i < dt.Rows.Count; i++) { //if (i == 0) { dc.ExeSql("delete from DATA_SCAN_ITEM where machinename='" + MachineName + "'"); } string sn = dt.Rows[i][0].ToString(); //下边调用存储过程生成一个中间表,保存发动机的实际扫描零件清单 PL_INSERT_SJZJQD sp = new PL_INSERT_SJZJQD() { SN1 = sn, MACHINENAME1 = MachineName }; Procedure.run(sp); } } setCondition(); }
public IntroductionAction(Procedure proc, Implementation impl, LayerRange layerRange) : base(proc, impl, layerRange) { }
///<summary>Most of the logic for breaking an appointment. Pass in the brokenFee (the number the user enters in the brokenAppointment window), ///Optionally pass in if the brokenappointment procedure is being deleted. Returns the broken procedure that was created.</summary> public static Procedure BreakAppointment(Appointment appt, Patient pat, ProcedureCode procCode, double feeOverride, bool isDeleteBrokenProc = false) { //suppressHistory is true due to below logic creating a log with a specific HistAppointmentAction instead of the generic changed. DateTime datePrevious = appt.DateTStamp; bool suppressHistory = false; if (procCode != null) { suppressHistory = procCode.ProcCode == "D9986" || procCode.ProcCode == "D9987"; } Appointments.SetAptStatus(appt, ApptStatus.Broken, suppressHistory); //Appointments S-Class handles Signalods if (appt.AptStatus != ApptStatus.Complete) //seperate log entry for completed appointments. { SecurityLogs.MakeLogEntry(Permissions.AppointmentEdit, pat.PatNum, appt.ProcDescript + ", " + appt.AptDateTime.ToString() + ", Broken from the Appts module.", appt.AptNum, datePrevious); } else { SecurityLogs.MakeLogEntry(Permissions.AppointmentCompleteEdit, pat.PatNum, appt.ProcDescript + ", " + appt.AptDateTime.ToString() + ", Broken from the Appts module.", appt.AptNum, datePrevious); } List <Procedure> listProcedures = Procedures.GetProcsForSingle(appt.AptNum, false); //splits should only exist on procs if they are using tp pre-payments List <PaySplit> listSplitsForApptProcs = new List <PaySplit>(); bool isNonRefundable = false; double brokenProcAmount = 0; if (listProcedures.Count > 0) { listSplitsForApptProcs = PaySplits.GetPaySplitsFromProcs(listProcedures.Select(x => x.ProcNum).ToList()); } Procedure brokenProcedure = new Procedure(); #region Charting the proc if (procCode != null) { switch (procCode.ProcCode) { case "D9986": //Missed HistAppointments.CreateHistoryEntry(appt.AptNum, HistAppointmentAction.Missed); break; case "D9987": //Cancelled HistAppointments.CreateHistoryEntry(appt.AptNum, HistAppointmentAction.Cancelled); break; } brokenProcedure.PatNum = pat.PatNum; brokenProcedure.ProvNum = (procCode.ProvNumDefault > 0 ? procCode.ProvNumDefault : appt.ProvNum); brokenProcedure.CodeNum = procCode.CodeNum; brokenProcedure.ProcDate = DateTime.Today; brokenProcedure.DateEntryC = DateTime.Now; brokenProcedure.ProcStatus = ProcStat.C; brokenProcedure.ClinicNum = appt.ClinicNum; brokenProcedure.UserNum = Security.CurUser.UserNum; brokenProcedure.Note = Lans.g("AppointmentEdit", "Appt BROKEN for") + " " + appt.ProcDescript + " " + appt.AptDateTime.ToString(); brokenProcedure.PlaceService = (PlaceOfService)PrefC.GetInt(PrefName.DefaultProcedurePlaceService); //Default proc place of service for the Practice is used. List <InsSub> listInsSubs = InsSubs.RefreshForFam(Patients.GetFamily(pat.PatNum)); List <InsPlan> listInsPlans = InsPlans.RefreshForSubList(listInsSubs); List <PatPlan> listPatPlans = PatPlans.Refresh(pat.PatNum); InsPlan insPlanPrimary = null; InsSub insSubPrimary = null; if (listPatPlans.Count > 0) { insSubPrimary = InsSubs.GetSub(listPatPlans[0].InsSubNum, listInsSubs); insPlanPrimary = InsPlans.GetPlan(insSubPrimary.PlanNum, listInsPlans); } double procFee; long feeSch; if (insPlanPrimary == null || procCode.NoBillIns) { feeSch = FeeScheds.GetFeeSched(0, pat.FeeSched, brokenProcedure.ProvNum); } else //Only take into account the patient's insurance fee schedule if the D9986 procedure is not marked as NoBillIns { feeSch = FeeScheds.GetFeeSched(insPlanPrimary.FeeSched, pat.FeeSched, brokenProcedure.ProvNum); } procFee = Fees.GetAmount0(brokenProcedure.CodeNum, feeSch, brokenProcedure.ClinicNum, brokenProcedure.ProvNum); if (insPlanPrimary != null && insPlanPrimary.PlanType == "p" && !insPlanPrimary.IsMedical) //PPO { double provFee = Fees.GetAmount0(brokenProcedure.CodeNum, Providers.GetProv(brokenProcedure.ProvNum).FeeSched, brokenProcedure.ClinicNum, brokenProcedure.ProvNum); brokenProcedure.ProcFee = Math.Max(provFee, procFee); } else { brokenProcedure.ProcFee = procFee; } if (!PrefC.GetBool(PrefName.EasyHidePublicHealth)) { brokenProcedure.SiteNum = pat.SiteNum; } Procedures.Insert(brokenProcedure); Procedure procOld = brokenProcedure.Copy(); //Now make a claimproc if the patient has insurance. We do this now for consistency because a claimproc could get created in the future. List <Benefit> listBenefits = Benefits.Refresh(listPatPlans, listInsSubs); List <ClaimProc> listClaimProcsForProc = ClaimProcs.RefreshForProc(brokenProcedure.ProcNum); Procedures.ComputeEstimates(brokenProcedure, pat.PatNum, listClaimProcsForProc, false, listInsPlans, listPatPlans, listBenefits, pat.Age, listInsSubs); if (listSplitsForApptProcs.Count > 0 && PrefC.GetBool(PrefName.TpPrePayIsNonRefundable) && procCode.ProcCode == "D9986") { //if there are pre-payments, non-refundable pre-payments is turned on, and the broken appointment is a missed code then auto-fill //the window with the sum of the procs for the appointment. Transfer money below after broken procedure is confirmed by the user. //normally goes to the form to let the user speficy, this is the auto filled amount for the form. brokenProcedure.ProcFee = feeOverride; //listSplitsForApptProcs.Sum(x => x.SplitAmt); isNonRefundable = true; } if (isDeleteBrokenProc) { brokenProcedure.ProcStatus = ProcStat.D; } brokenProcedure.ProcFee = feeOverride; brokenProcAmount = feeOverride; Procedures.Update(brokenProcedure, procOld); } #endregion //Note this MUST come after FormProcBroken since clicking cancel in that window will delete the procedure. if (isNonRefundable && !isDeleteBrokenProc && listSplitsForApptProcs.Count > 0) { //transfer what the user specified in the broken appointment window. //transfer up to the amount specified by the user foreach (Procedure proc in listProcedures) { if (brokenProcAmount == 0) { break; } List <PaySplit> listSplitsForAppointmentProcedure = listSplitsForApptProcs.FindAll(x => x.ProcNum == proc.ProcNum); foreach (PaySplit split in listSplitsForAppointmentProcedure) { if (brokenProcAmount == 0) { break; } double amt = Math.Min(brokenProcAmount, split.SplitAmt); Payments.CreateTransferForTpProcs(proc, new List <PaySplit> { split }, brokenProcedure, amt); brokenProcAmount -= amt; } } } return(brokenProcedure); }
public LemmaProc(Procedure proc) { this.proc = proc; }
public IBlockNameDialog CreateBlockNameDialog(Procedure proc, Block block) { var dlg = new BlockNameDialog(proc, block); return(dlg); }
// Check account existence // Get all users public DataTable DoQuery() { _dbConnector.Connect(); DataSet dataset = new DataSet("MainDataset"); _dataTable = new DataTable(); _dataTable = dataset.Tables.Add("MainTable"); MySqlCommand command = new MySqlCommand(Procedure, _dbConnector.DbConnectionInstance) { CommandType = CommandType.StoredProcedure }; if (Parameters?.Count > 0) { foreach (var parameter in Parameters) { command.Parameters.AddWithValue(parameter.Key, parameter.Value); } } using (MySqlDataReader reader = command.ExecuteReader()) { if (!reader.HasRows) { return(null); } int columCount = reader.FieldCount; for (int i = 0; i < columCount; i++) { _dataTable.Columns.Add(reader.GetName(i)); } if (Procedure == "GetResident" || Procedure == "GetResidentsList") { _dataTable.Columns.Add("Mark for archive", typeof(bool)); _dataTable.Columns["Mark for archive"].DefaultValue = false; _dataTable.Columns.Add("Generate QR", typeof(bool)); _dataTable.Columns["Generate QR"].DefaultValue = false; } else if (Procedure.Contains("GetArchive")) { _dataTable.Columns.Add("Mark for restore", typeof(bool)); _dataTable.Columns["Mark for restore"].DefaultValue = false; } else if (Procedure == "GetAdmins") { _dataTable.Columns.Add("Mark for delete", typeof(bool)); _dataTable.Columns["Mark for delete"].DefaultValue = false; } while (reader.Read()) { var currentRow = _dataTable.NewRow(); for (int i = 0; i < columCount; i++) { if (reader.IsDBNull(i)) { currentRow[i] = string.Empty; continue; } currentRow[i] = reader.GetString(i); } _dataTable.Rows.Add(currentRow); } } _dbConnector.Disconnect(); return(_dataTable); }
public override BlockWorkitem CreateBlockWorkItem(Address addrStart, Procedure proc, ProcessorState state) { Test_State = state; Test_LastBlockWorkitem = base.CreateBlockWorkItem(addrStart, proc, state); return(Test_LastBlockWorkitem); }