@Variables

Declara variables dentro de un ámbito nombrado: global (visibles en todo el archivo) o el nombre de un Procedure/Function declarado en @Source (visibles sólo dentro de ese procedimiento/función, además de las global).

@Variables {
    global {
        Usuario     char(10)
        Fecha       date
        Saldo       number(9,2)
    }
    Procedimiento {
        contador    number(3)
    }
    Saluda {
        nombre      char(10)
    }
}

Una línea Nombre tipo(...) por variable — mismo formato que @Fields, pero con más tipos disponibles (ver Tipos de dato): char, varchar, number, date, field(Campo), list(tipo), matrix(filas, cols, tipo), struct(NombreTemplate).

Ámbito local

local es un ámbito reservado, junto a global y a los nombres de Procedure/Function. Sus variables sólo son visibles en el cuerpo principal de @Source (fuera de cualquier Procedure/Function) y en @Layout. Usarlas dentro de un Procedure/Function produce E00146.

@Variables {
    global {
        Usuario   char(10)
    }
    local {
        contador  number(3)
        mensaje   char(40)
    }
}

• Sólo tiene sentido en programas tipo Program; en Screen no está soportado.
• No puede repetir un nombre ya declarado en global (E00298).
• No admite templates de struct (E00234, como cualquier ámbito distinto de global).
• En el RPG generado se declara a nivel de módulo, igual que global; la restricción de visibilidad la aplica sólo el compilador.
• Un parámetro de @Parameters puede declararse en global o en local. En local solo lo ve el cuerpo principal, no los Procedure/Function.

Struct: definición de template inline

Dentro del ámbito global (sólo ahí) también se puede definir un template de struct con struct Nombre [ ... ], antes o después de instanciarlo con struct(Nombre) — ver Tipos de dato: Struct para la sintaxis completa y sus límites (incluye structs anidados y list(struct(...)) como miembro).

Modificador

Sólo Description("texto") está disponible en @Variables (a diferencia de @Fields, no admite Default/AllowNull):

@Variables {
    global {
        NroSolicitud  field(ADHOJA50)  Description("Número de Solicitud")
    }
}

Constantes

Dentro de cualquier ámbito (global, local o el de un Procedure/Function), en Program y en Screen, se puede declarar una constante con const Nombre tipo = valor:

@Variables {
    global {
        const MaxItems  number(3,0) = 100
        const Precio    number(9,2) = -5.5
        const Titulo    char(30) = "Reporte de pases"
        const Saludo    varchar(30) = "Hola" Description("Saludo inicial")
    }
}

• Sólo se admiten char, varchar y number; cualquier otro tipo produce E00310.
• El valor debe ser un literal del mismo tipo: texto entre comillas, o un número (entero o decimal) con signo - opcional. Debe caber en el tipo (el texto no puede ser más largo que la longitud; el número no puede tener más decimales que la escala ni más dígitos enteros que los que admite la precisión) o se produce E00311.
• Se puede leer en cualquier expresión, pero nunca modificar: asignarla, usarla como contador de un For, pasarla como argumento out/inout de un Call o como destino de un Input produce E00312. Pasarla a una Procedure/Function que modifica ese parámetro produce E00179.
• Un parámetro de @Parameters no puede ser una constante (E00313).
• En un Block imprimible de un Program se puede mostrar, por ejemplo con @Label(1,1,&Titulo). En una Screen no puede mostrarse en un campo de pantalla (Label/Input/Column): E00314; cópiela a una variable.

En el RPG generado se declara como constante nombrada (dcl-c NOMBRE valor;):

• Un texto char(n) se rellena con blancos hasta n, de modo que se comporta como una variable char(n); un varchar no se rellena.
• Un número se escribe con exactamente los decimales de su escala (const Precio number(9,2) = -5.5 genera dcl-c Precio -5.50;).
• Una constante numérica de RPG no tiene precisión propia (la fija el contexto en que se usa), pero WARP la trata como el tipo declarado en los chequeos de tipo.

Límites de longitud/precisión (variable standalone, distinto de un campo de tabla)

Estos límites mayores en @Variables reflejan que una variable declarada ahí no está atada a un archivo físico DDS como sí lo está un campo de @Fields.