public static Signature ForFunction(SignatureType type, ISignatureOwner owner, Parser.SignatureData sd, ApiTypeBuilder api)
    {
        if (owner.CefName.Contains("::get_") && sd.Arguments.Count == 2)
        {
            if (sd.ReturnType.Name == "void" && string.IsNullOrEmpty(sd.ReturnType.Indirection))
            {
                if (sd.Arguments[1].ArgumentType.Name.StartsWith("cef_string_list") || sd.Arguments[1].ArgumentType.Name.StartsWith("cef_string_m"))
                {
                    return(new StringCollectionAsRetvalSignature(owner, sd, api));
                }
            }
        }

        if (owner.CefConfig.CountFunction != null && sd.Arguments.Count == 3 && sd.ReturnType.Name == "void")
        {
            //Debug.Print(owner.CefName);
        }

        switch (owner.CefName)
        {
        case "cef_browser::get_frame_identifiers":
            return(new GetFrameIdentifiersSignature(owner, sd, api));

        case "cef_v8value::execute_function_with_context":
            return(new SignatureWithStructPtrArray(SignatureType.LibraryCall, owner, sd, api, 4, 3));

        case "cef_v8value::execute_function":
            return(new SignatureWithStructPtrArray(SignatureType.LibraryCall, owner, sd, api, 3, 2));

        case "cef_render_handler::on_paint":
            return(new SignatureWithStructArray(SignatureType.ClientCallback, owner, sd, api, 4, 3));

        case "cef_post_data::get_elements":
        case "cef_sslinfo::get_derencoded_issuer_chain":
        case "cef_sslinfo::get_pemencoded_issuer_chain":
            return(new StructArrayGetterSignature(owner, sd, api));

        case "cef_v8handler::execute":
            return(new CefV8HandlerExecuteSignature(owner, sd, api));

        case "cef_print_settings::set_page_ranges":
            return(new SignatureWithStructArray(SignatureType.LibraryCall, owner, sd, api, 2, 1));

        case "cef_print_settings::get_page_ranges":
            return(new GetPageRangesSignature(owner, sd, api, 2, 1));

        case "cef_drag_handler::on_draggable_regions_changed":
            return(new SignatureWithStructArray(SignatureType.ClientCallback, owner, sd, api, 3, 2));

        default:
            return(null);
        }
    }
    public OutStringToRetvalSignature(ISignatureOwner parent, Parser.SignatureData sd, ApiTypeBuilder api, int arrayIndex, int countIndex)
        : base(SignatureType.LibraryCall, parent, sd, api)
    {
        if (this.ReturnType.Name != "int")
        {
            System.Diagnostics.Debugger.Break();
        }

        foreach (var arg in Arguments)
        {
        }
    }
    public static Signature Create(SignatureType type, ISignatureOwner owner, Parser.SignatureData sd, ApiTypeBuilder api)
    {
        var s = CustomSignatures.ForFunction(type, owner, sd, api);

        if (s == null)
        {
            return(new Signature(type, owner, sd, api));
        }
        else
        {
            return(s);
        }
    }
예제 #4
0
    public CefV8HandlerExecuteSignature(ISignatureOwner owner, Parser.SignatureData sd, ApiTypeBuilder api)
        : base(SignatureType.ClientCallback, owner, sd, api, 4, 3)
    {
        Arguments[6]             = new Argument(Arguments[6], new CefStringOutType());
        base.ManagedArguments[5] = new Argument(base.ManagedArguments[5], new CefStringOutType());
        var list = new List <Argument>();

        foreach (var arg in base.ManagedArguments)
        {
            if (arg.VarName != "retval")
            {
                list.Add(arg);
            }
        }
        m_publicArguments = list.ToArray();
    }
예제 #5
0
    public SignatureWithStructArray(SignatureType type, ISignatureOwner parent, Parser.SignatureData sd, ApiTypeBuilder api, int arrayIndex, int countIndex)
        : base(type, parent, sd, api)
    {
        var list = new List <Argument>();

        for (var i = 0; i <= Arguments.Length - 1; i++)
        {
            if (i != arrayIndex && i != countIndex)
            {
                list.Add(Arguments[i]);
            }
            else if (i == arrayIndex)
            {
                var a = new Argument(Arguments[arrayIndex], new CefStructArrayType(Arguments[arrayIndex], Arguments[countIndex]));
                list.Add(a);
                Arguments[i] = a;
            }
        }
        m_publicArguments = list.ToArray();
    }
    protected Signature(SignatureType type, ISignatureOwner owner, Parser.SignatureData sd, ApiTypeBuilder api)
    {
        Type  = type;
        Owner = owner;
        var args  = new List <Argument>();
        var index = 0;

        foreach (var arg in sd.Arguments)
        {
            args.Add(new Argument(arg, api, index));
            index += 1;
        }

        this.Arguments = args.ToArray();

        this.ReturnType         = api.GetApiType(sd.ReturnType, false);
        this.ReturnValueIsConst = sd.ReturnValueIsConst;
        var comments = owner.Comments;

        DebugPrintUnhandledArrayArguments();
    }
 public GetPageRangesSignature(ISignatureOwner parent, Parser.SignatureData sd, ApiTypeBuilder api, int arrayIndex, int countIndex)
     : base(SignatureType.LibraryCall, parent, sd, api, arrayIndex, countIndex)
 {
 }
예제 #8
0
 public StructArrayGetterSignature(ISignatureOwner owner, Parser.SignatureData sd, ApiTypeBuilder api)
     : base(SignatureType.LibraryCall, owner, sd, api)
 {
 }
 public StringCollectionAsRetvalSignature(ISignatureOwner parent, Parser.SignatureData sd, ApiTypeBuilder api)
     : base(SignatureType.LibraryCall, parent, sd, api)
 {
 }
 public static void EmitPInvokeDelegateInitialization(CodeBuilder b, ISignatureOwner owner)
 {
     EmitPInvokeDelegateInitialization(b, owner.PublicClassName.Substring(3), owner.CfxApiFunctionName);
 }
예제 #11
0
 public GetFrameIdentifiersSignature(ISignatureOwner parent, Parser.SignatureData sd, ApiTypeBuilder api)
     : base(SignatureType.LibraryCall, parent, sd, api)
 {
 }