Exemple #1
0
        private void lbInstructions_SelectedIndexChanged(object sender, EventArgs e)
        {
            lbOverloads.Items.Clear();
            lblInstructionName.Text = "Instruction: ";

            if (lbInstructions.SelectedIndex != -1)
            {
                string inst = lbInstructions.SelectedItem.ToString();
                if (inst.StartsWith("(INCOMPATIBLE)"))
                {
                    inst = inst.Remove(0, "(INCOMPATIBLE)".Length);
                }

                FLInstructionCreator c = FindCreator(inst);
                string args            = c.GetArgumentSignatureForInstruction(inst);

                bool ret = SignatureParser.ParseCreatorSig(args, out List <InstructionArgumentSignature> sig);

                lblInstructionName.Text = "Instruction: " + inst;

                rtbInstructionDescription.Text = c.GetDescriptionForInstruction(inst);

                lbOverloads.Items.Clear();
                for (int i = 0; i < sig.Count; i++)
                {
                    lbOverloads.Items.Add(sig[i]);
                }
            }
        }
        private FLInstructionCreator FindCreator(string name)
        {
            for (int i = 0; i < Container.InstructionSet.CreatorCount; i++)
            {
                FLInstructionCreator creator = Container.InstructionSet.GetCreatorAt(i);
                if (creator.InstructionKeys.Contains(name))
                {
                    return(creator);
                }
            }

            return(null);
        }
        public override object Process(object o)
        {
            SerializableFLProgram input = (SerializableFLProgram)o;

            foreach (SerializableFLFunction serializableFlFunction in input.Functions)
            {
                foreach (SerializableFLInstruction serializableFlInstruction in serializableFlFunction.Instructions)
                {
                    FLInstructionCreator creator = InstructionSet.GetCreator(serializableFlInstruction);

                    bool hasDefinedSig = ParseCreatorSig(
                        creator.GetArgumentSignatureForInstruction(serializableFlInstruction),
                        out List <InstructionArgumentSignature> creatorSigs);
                    if (!hasDefinedSig)
                    {
                        Logger.Log(LogType.Warning,
                                   "FL Creator: " + creator.GetType().Name + " has no Argument Signatures defined. Skipping.",
                                   1);
                        continue;
                    }

                    InstructionArgumentSignature sig = new InstructionArgumentSignature
                    {
                        Signature = serializableFlInstruction.Arguments
                                    .Select(x => x.ArgumentCategory).ToList()
                    };
                    bool matches = false;
                    foreach (InstructionArgumentSignature instructionArgumentSignature in creatorSigs)
                    {
                        matches |= instructionArgumentSignature.Compare(sig.Signature);
                    }

                    if (!matches)
                    {
                        throw new FLProgramCheckException(
                                  $"The Script is using the instruction with key: " +
                                  serializableFlInstruction.InstructionKey +
                                  " with the Arguments: " + sig + " but no such argument overload is found.", this);
                    }
                }
            }

            foreach (SerializableExternalFLFunction serializableFlFunction in input.ExternalFunctions)
            {
                Process(serializableFlFunction.ExternalProgram);
            }


            return(input);
        }
        private InstructionObject FormatInstruction(string name)
        {
            FLInstructionCreator creator = FindCreator(name);

            if (creator == null)
            {
                return(new InstructionObject
                {
                    Name = name,
                    Description = "unknown",
                    Parameters = ""
                });
            }

            return(new InstructionObject
            {
                Name = name,
                Description = creator.GetDescriptionForInstruction(name),
                Parameters = creator.GetArgumentSignatureForInstruction(name)
            });
        }