BEGIN SEQUENCE
 Define una secuencia de sentencias para un BREAK
------------------------------------------------------------------------------
 Sintaxis

     BEGIN SEQUENCE
        <sentencias>...
     [BREAK [<exp>]]
        <sentencias>...
     [RECOVER [USING <idVar>]]
        <sentencias>...
     END [SEQUENCE]

 Argumentos

     BREAK <exp> bifurca la ejecución a la sentencia situada
     inmediatamente después del RECOVER más cercano, si se ha especificado
     uno, o de la sentencia END SEQUENCE en caso contrario. <exp> es el
     valor de retorno, que se almacena en la <idVar> especificada en la
     cláusula USING de la sentencia RECOVER.

     RECOVER USING <idVar> define un punto de recuperación en la
     estructura SEQUENCE. El control pasa a este punto después de una
     sentencia BREAK. Si se especifica la cláusula USING <idVar>, esta
     variable recibe el valor de retorno de la sentencia BREAK, que suele
     ser un objeto de error.

     END define el punto final de la estructura de control SEQUENCE.
     Después de un BREAK, el control se bifurca a la primera sentencia
     después del END si no se ha especificado una secuencia RECOVER.

 Descripción

     BEGIN SEQUENCE...END es una estructura de control que se utiliza para
     el manejo de excepciones y errores de ejecución. Delimita un bloque de
     sentencias que incluye procedimientos invocados y funciones definidas
     por el usuario. Si se encuentra un BREAK en el bloque de sentencias
     comprendido entre BEGIN SEQUENCE y el RECOVER correspondiente, el
     control se bifurca a la sentencia situada  inmediatamente después de
     RECOVER. Si no se especifica una sentencia RECOVER, el control pasa a
     la sentencia situada después de END y finaliza la estructura SEQUENCE.
     Si el control llega a la sentencia RECOVER sin encontrar antes un
     BREAK, pasa a la sentencia situada después del END correspondiente.

     La sentencia RECOVER puede recibir, opcionalmente, un parámetro pasado
     por la sentencia BREAK como valor de retorno. Normalmente es un objeto
     de error, generado y devuelto por el bloque actual de manejo de errores
     definido con ERRORBLOCK(). Si se devuelve un objeto de error, pueden
     enviarse mensajes para solicitar información sobre el error. Con esta
     información, los errores de ejecución pueden manejarse en el mismo
     contexto de la operación, en vez de en el manejador actual de errores
     de ejecución. Consulte el ejemplo siguiente.

     En una estructura SEQUENCE existen algunas restricciones sobre las
     sentencias permitidas entre BEGIN SEQUENCE y RECOVER. No pueden
     ejecutarse sentencias RETURN, LOOP o EXIT. Dentro del bloque de
     sentencias de RECOVER, no obstante, pueden ejecutarse sentencias LOOP,
     EXIT, BREAK o RETURN, ya que la estructura SEQUENCE ha finalizado
     prácticamente en este punto. La utilización de un LOOP en el bloque de
     sentencias de RECOVER permite volver a ejecutar el bloque de sentencias
     de SEQUENCE. Consulte el ejemplo siguiente.

     Las estructuras SEQUENCE son bastante flexibles. Pueden anidarse y
     puede haber varias en un mismo procedimiento o función definida por el
     usuario. Si se especifica más de una estructura SEQUENCE, cada una debe
     delimitar una operación bien definida.

     Si desea más información sobre los objetos Error, consulte la clase
     Error.

 Ejemplos

      El siguiente fragmento de código muestra una estructura
        SEQUENCE en la que aparece una sentencia BREAK dentro del
        procedimiento actual:

        BEGIN SEQUENCE
           <sentencias>...
           IF lCondBreak
              BREAK
           ENDIF
        RECOVER
           <sentencias de recuperación>...
        END

        <sentencias de recuperación>...

      El ejemplo siguiente muestra un manejador de errores que
        devuelve un objeto Error a la variable especificada en la cláusula
        USING de la sentencia RECOVER:

        LOCAL objLocal, bUltimoManejador
        //
        // Salvar el manejador actual y crear
        // un nuevo manejador de errores
        bUltimoManejador := ERRORBLOCK({ |objErr| ;
              MiManejador(objErr, .T.) })
        //
        BEGIN SEQUENCE
           .
           . <operación que puede fallar>
           .
        RECOVER USING objLocal
           //
           // Enviar mensajes a objLocal y manejar el error
           ? "Error: "
           IF objLocal:genCode != 0
              ?? objLocal:description
           ENDIF
           .
           .
           .
        END
        //
        // Restablecer el manejador de errores anterior
        ERRORBLOCK( bUltimoManejador )

        FUNCTION MiManejador( objError, lManejadorLocal)
           //
           // Manejar los errores localmente devolviendo
           // el objeto de error
           IF lManejadorLocal
              BREAK objError
           ENDIF
           .
           . <otras sentencias para manejar el error>
           .
           RETURN NIL

      El ejemplo siguiente vuelve a ejecutar el bloque de sentencias
        de SEQUENCE por medio de un LOOP en el bloque de sentencias de
        RECOVER:

        DO WHILE .T.
           BEGIN SEQUENCE
              .
              . <operación que puede fallar>
              .
           RECOVER
              IF ImprimirRecup()
                  LOOP               // Repetir el bloque de sentencias
                                     // SEQUENCE
              ENDIF
           END
           EXIT                      // Salir de la operación
        ENDDO

 To download this example - click here.

See Also: Error ERRORBLOCK() RETURN