AYUDA EN LÍNEA
 WINDEVWEBDEV Y WINDEV MOBILE

Este contenido se ha traducido automáticamente.  Haga clic aquí  para ver la versión en inglés.
Ayuda / WLanguage / Funciones WLanguage / Funciones estándar / Funciones de Windows / Funciones varias de WINDEV
  • Using the dynamic procedure
  • Dynamic code
  • Parameters of a query
  • Fields in HFSQL functions
  • Deploying of an application that uses Compile
  • Limitations
WINDEV
WindowsLinuxUniversal Windows 10 AppJavaReportes y ConsultasCódigo de Usuario (UMC)
WEBDEV
WindowsLinuxPHPWEBDEV - Código Navegador
WINDEV Mobile
AndroidWidget Android iPhone/iPadIOS WidgetApple WatchMac CatalystUniversal Windows 10 App
Otros
Procedimientos almacenados
Dynamically compiles a procedure whose source code is supplied. The created and compiled procedure is a procedure global to the project.
Remark: ExecuteCode and EvaluateExpression also allow you to use a code that is dynamically generated.
// Syntaxe 1: Compilation dynamique d'une procédure globale
// Source: champ dans lequel est saisi le code de procédure

sRésultat is string 
sRésultatCompile is string 
sRésultatCompile = Compile("Proc_dynamique", MonCodeSource)
SWITCH sRésultatCompile
CASE "": sRésultat = ExecuteProcess("Proc_dynamique", trtProcedure)
CASE "ERR": sRésultat = "Compilation impossible." + CR + ErrorInfo()
OTHER CASE: sRésultat = sRésultatCompile
END
RETURN sRésultat
// Syntaxe 2: Compilation dynamique d'une procédure globale
// Utilisation du type Procédure
// Source: champ dans lequel est saisi le code de procédure

Formule is procedure = Compile("Proc_dynamique", MonCodeSource)
IF ErrorOccurred = False THEN
ExecuteProcess("Proc_Dynamique", trtProcedure)
// Autre possibilité pour exécuter la procédure: Formule()
ELSE
Info(ErrorInfo())
END
// Syntaxe 3: Compilation dynamique d'une procédure globale
// Utilisation directe du type Procédure
// Source: champ dans lequel est saisi le code de procédure

Formule is procedure = Compile(MonCodeSource)
IF ErrorOccurred = False THEN
Formule()
ELSE
Info(ErrorInfo())
END
Sintaxis

Dynamic compilation of a global procedure Ocultar los detalles

<Result> = Compile(<Procedure name> , <Source code> [, <Parameters>])
<Result>: Character string
Compilation result:
  • Empty string ("") if the compilation was successful. The procedure can be run using ExecuteProcess and Execute with the trtProcedure constant.
  • ERR if a fatal error occurred: wdxxxcpl.dll not found, incorrect <Source code>, no current project, global procedure already created, etc. ErrorInfo returns the details of the error.
  • An error message if a compilation error was detected. This message corresponds to the caption of the error.
PHP This parameter is not available. This function returns no result.
<Procedure name>: Character string
Name of dynamic global procedure to create.
To create a local procedure, all you have to do is specify the element name. For example: "WindowName.ProcedureName".
Caution: If Compile is called several times with the same procedure name, the last created procedure is automatically overwritten.
<Source code>: Character string
Source code in WLanguage of the procedure to compile dynamically.
  • If this code contains quotes, they must be doubled (see the example).
  • This code may contain the call and declaration code of an internal procedure.
PHP Source code in PHP of the procedure to compile dynamically. If this code contains quotes, they must be doubled.
<Parameters>: Optional variable of type WLangageCodeCompiling
Novedad versión 2024
WEBDEV - Código Servidor Name of Variable type WLangageCodeCompiling used to define compilation parameters (WLanguage functions allowed, forbidden, etc.)..
If this parameter is not specified, all WLanguage functions are allowed..
WEBDEV - Código ServidorWindowsLinuxAjax

Dynamic compilation of a global procedure associated with a Procedure variable Ocultar los detalles

<Result> = Compile(<Procedure name> , <Source code> [, <Parameters>])
<Result>: Procedure variable
Name of the Procedure variable that points to the compiled procedure.
The procedure can be run:
If a compilation error occurs, the ErrorOccurred variable is set to True and ErrorInfo returns the error details.
<Procedure name>: Character string
Name of dynamic global procedure to create.
To create a local procedure, all you have to do is specify the element name. For example: "WindowName.ProcedureName".
If Compile is called several times with the same procedure name, the last created procedure is automatically overwritten.
<Source code>: Character string
Source code in WLanguage of the procedure to compile dynamically.
  • If this code contains quotes, they must be doubled (see the example).
  • This code may contain the call and declaration code of an internal procedure.
<Parameters>: Optional variable of type WLangageCodeCompiling
Novedad versión 2024
WEBDEV - Código Servidor Name of Variable type WLangageCodeCompiling used to define compilation parameters (WLanguage functions allowed, forbidden, etc.)..
If this parameter is not specified, all WLanguage functions are allowed..
WEBDEV - Código ServidorWindowsLinuxAjax

Dynamic compilation of anonymous procedure Ocultar los detalles

<Result> = Compile(<Source code> [, <Parameters>])
<Result>: Procedure variable
Name of the Procedure variable that points to the compiled procedure.
The procedure can be run by a call to the Procedure variable.
If a compilation error occurs, the ErrorOccurred variable is set to True and ErrorInfo returns the error details.
The procedure is compiled as a global procedure. To compile a procedure associated with a window, you must name the procedure (syntax 2).
<Source code>: Character string
Source code in WLanguage of the procedure to compile dynamically.
  • If this code contains quotes, they must be doubled.
  • This code may contain the call and declaration code of an internal procedure.
<Parameters>: Optional variable of type WLangageCodeCompiling
Novedad versión 2024
WEBDEV - Código Servidor Name of Variable type WLangageCodeCompiling used to define compilation parameters (WLanguage functions allowed, forbidden, etc.)..
If this parameter is not specified, all WLanguage functions are allowed..
Observaciones

Using the dynamic procedure

  • If you are using the first syntax, to use your dynamic procedures, all you have to do is run the procedure via ExecuteProcess or Execute.
    Another solution (not recommended): before calling Compile, declare the name of the procedure to the WLanguage compiler using the EXTERN keyword and use the procedure directly.
  • If you are using the second syntax, to use your dynamic procedures, simply start the procedure:
  • If you are using the third syntax, to use your dynamic procedures, all you have to do is run the procedure via a direct call to the Procedure variable. A procedure that is dynamically compiled can take parameters. Example:
MonCodeSource is string = [
PROCÉDURE AdditionneXetY(aa, bb)
RENVOYER aa + bb
]
MaProc is procedure = Compile(MonCodeSource)
Trace(MaProc(2, 3))

Dynamic code

Structures can be used in dynamic code.
Constants cannot be used in dynamic code (defined with the CONSTANT keyword).
When using constants in a code, all the occurrences of the constants are replaced with their value during the compilation in the editor but the correspondence between the name of constants and their value is not "embedded" in the application. Therefore, the dynamic compilation cannot use the constants.
Let's see two alternatives:
  • 1st solution: Use variables instead of constants.
    The code:
    CONSTANT
    CST_Nom = 1
    END

    becomes for example
    CST_Nom is int = 1
  • 2nd solution: In the string containing the code that must be compiled dynamically, replace the name of the constant by its value:
    sCode is string
    sCode = [
    Info(CST_Nom)
    ]

    // Remplace le nom de la constante par sa valeur
    sCode = Replace(sCode, "CST_Nom", CST_Nom, WholeWord + IgnoreCase)

    // Il est ensuite possible de compiler le code
    IF Compile("ProcDyn", sCode) <> "" THEN
    Error("Erreur de compilation de la procédure dynamique: ", ...
    ErrorInfo())
    ELSE
    // Puis de l'exécuter
    WHEN EXCEPTION IN 
    ExecuteProcess("ProcDyn", trtProcedure)
    DO
    Error("Erreur d'exécution de la procédure dynamique: ", ...
    ExceptionInfo())
    END
    END

Parameters of a query

If the source code used for the dynamic compilation runs a query with parameters (HExecuteQuery), the parameters expected by the query must necessarily be specified in HExecuteQuery.
For example, you must use:
HExecuteQuery("MaRequête", hQueryDefault, "Dupont")
instead of:
MaRequête.NomClient = "Dupont"
HExecuteQuery("MaRequête", hQueryDefault)

Fields in HFSQL functions

If the source code used for dynamic compilation executes an HFSQL function that requires the name of a field as a parameter, this name must be given in the Geometry form of a string enclosed in quotation marks. For example, the code to use for the HReadSeekFirst function is as follows:
HReadSeekFirst(Article, "CodeArticle", "ValeurRecherchée")
instead of:
HReadSeekFirst(Article, CodeArticle, "ValeurRecherchée")

Deploying of an application that uses Compile

When deploying an application that usesCompile (when creating the executable or deploying the site), you must specify all the libraries of the WINDEV/WEBDEV/WINDEV Mobile framework used by the code that is dynamically compiled. Indeed, this code being compiled dynamically, WINDEV, WEBDEV and WINDEV Mobile do not detect the framework libraries used.
WEBDEV - Código ServidorAjax

Limitations

  • If a window (page) in the project uses a local Procedure with the name , calls to from a WLanguage event in the window (page) will always execute the local Procedure.
  • If a global Procedure already exists, dynamically compiling an Procedure will cause an error.
  • By default, overloading the WLanguage functions is ignored during the dynamic compilation.
    For example, if Trace has been overloaded, the WLanguage function (not the overloaded function) will be called in a code that is dynamically compiled. To force the use of the overloaded function during the dynamic compilation, the name of the function must be preceded by the "Extern" keyword.
  • The enumerations and the combinations are not available in dynamic compilation.
Componente: wd290vm.dll
Versión mínima requerida
  • Versión 9
Esta página también está disponible para…
Comentarios
exemplo compile e execute
https://windevdesenvolvimento.blogspot.com/2021/05/dicas-3340-windev-webdev-mobile-compile.html
https://youtu.be/fSx8ybbBZws

//initializing - pode ser colocado no global caso precisar
CONSTANT
// Nome do procedimento que é compilado dinamicamente
DYNAMIC_PROCEDURE = "DYNAMIC_PROCEDURE"
END

// BOTAO CALCULA - ACIONAR O AJAX
EDT_resultado_compilacao=Compile(dynamic_procedure,EDT_comandos)
IF EDT_resultado_compilacao="" THEN
Execute(dynamic_procedure)
EDT_resultado_compilacao="Compilado corretamente"
ELSE
EDT_resultado_compilacao="Erro"+ErrorInfo(errFullDetails)
END
amarildo
01 06 2021

Última modificación: 02/02/2024

Señalar un error o enviar una sugerencia | Ayuda local