plggen.spb

Oracle PL/SQL procedure generator (second generator type)

   BEGIN
      RETURN      NOT oneoutlist
              AND (    NOT is_express_version
                   AND g_drvsrctype = PLGdoir.c_file
                  );
   END;

   FUNCTION reading_list
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN    oneoutlist
             OR (    NOT is_express_version
                 AND g_drvsrctype = PLGdoir.c_list
                );
   END;

   FUNCTION curlooprow (
      loop_in   IN   VARCHAR2,
      row_in    IN   PLS_INTEGER,
      pkg_in    IN   VARCHAR2 := 'PLGgen'
   )
      RETURN VARCHAR2
   IS
   BEGIN
      RETURN    pkg_in
             || '.'
             || loop_in
             || '('
             || row_in
             || ').';
   END;

   FUNCTION curlooprow
      RETURN VARCHAR2
   IS
   BEGIN
      RETURN curlooprow (
                loopstate.statevar,
                loopstate.currrow,
                loopstate.pkgname
             );
   END;

   PROCEDURE init_src_trg_info (
      drv   IN   VARCHAR2,
      tab   IN   VARCHAR2,
      sch   IN   VARCHAR2 := NULL
   )
   IS
   BEGIN
      /* Set the source for the driver and target for the generated code. */

      g_drvsrctype := NVL (
                         PLGdoir.drvsrctype (drv, tab, sch),
                         g_drvsrctype
                      );
      g_drvtrgtype := NVL (
                         PLGdoir.drvtrgtype (drv, tab, sch),
                         g_drvtrgtype
                      );

      /* CANCELED: 99.2 Always do this -- customization files
         have to read from file.
      */
      IF g_drvsrctype = PLGdoir.c_file
      THEN
         setdrvenv (drv, sch, tab);
      END IF;

      IF g_drvtrgtype = PLGdoir.c_file
      THEN
         setgenenv (drv, sch, tab);
      END IF;
   END;

   /* Programs to encapsulate keywords */

   FUNCTION bracketedval (
      text_in    IN   VARCHAR2,
      startval   IN   VARCHAR2,
      endval     IN   VARCHAR2 := objtagopen
   )
      RETURN VARCHAR2
   IS
   BEGIN
      RETURN RTRIM (
                PLGstr.betwn (
                   text_in,
                   startval,
                   endval,
                   inclusive=> FALSE,
                   gotoend=> TRUE
                )
             );
   END;

   /* 99.2 Reverse to simply see if there is no open bracket to
           process. */
   FUNCTION no_openobjtag (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN INSTR (text_in, objtagopen) = 0;
   END;

   FUNCTION is_cgml_start_command (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN (INSTR (
                 c_cgml_start_commands,
                    text_in
                 || ','
              ) > 0
             );
   END;

   FUNCTION is_cgml_set_option (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      /* Can always set a packaged variable. */
      IF INSTR (text_in, '.') > 0
      THEN
         RETURN TRUE;
      ELSE
         RETURN (INSTR (
                    c_cgml_set_options,
                       text_in
                    || ','
                 ) > 0
                );
      END IF;
   END;

   FUNCTION defining_array (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN    text_in = c_defarray
             OR text_in = c_deftabarray;
   END;

   FUNCTION including (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN    text_in = c_include
             OR text_in = c_special;
   END;

   FUNCTION is_special (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_special;
   END;

   FUNCTION including_header (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_header;
   END;

   FUNCTION iscomment (line_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN LTRIM (line_in) LIKE c_comment;
   END;

   FUNCTION raising_exception (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_raise;
   END;

   FUNCTION handling_exception (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_handle;
   END;

   FUNCTION start_if_clause (
      text_in         IN   VARCHAR2,
      true_start_in   IN   BOOLEAN
   )
      RETURN BOOLEAN
   IS
      retval   BOOLEAN := text_in IN (c_if, c_ifnot);
   BEGIN
      IF NOT true_start_in
      THEN
         retval :=
                 retval
              OR text_in IN (c_elsif, c_elsifnot);
      END IF;

      RETURN retval;
   END;

   FUNCTION end_if_clause (
      text_in         IN   VARCHAR2,
      true_start_in   IN   BOOLEAN
   )
      RETURN BOOLEAN
   IS
      retval   BOOLEAN
                := text_in IN
                             (c_endif, c_end_if, c_endif2);
   BEGIN
      IF NOT true_start_in
      THEN
         retval :=    retval
                   OR text_in IN (c_else,
                                  c_elsif,
                                  c_elsifnot,
                                  c_elseif,
                                  c_elseifnot
                                 );
      END IF;

      RETURN retval;
   END;

   FUNCTION startsif (
      text_in         IN   VARCHAR2,
      true_start_in   IN   BOOLEAN := FALSE
   )
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN start_if_clause (text_in, true_start_in);
   /* 99.2 No longer needed
   ELSE
      RETURN start_if_clause (
         PLGstr.betwn (text_in, objtagopen, objtagclose, inclusive=>FALSE),
         true_start_in);
   END IF;
   */
   END;

   FUNCTION endsif (
      text_in       IN   VARCHAR2,
      true_end_in   IN   BOOLEAN := FALSE
   )
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN end_if_clause (text_in, /* 99.2 Already parsed...
                                        PLGstr.betwn (text_in,
                                           objtagopen, objtagclose, inclusive=>FALSE),
                                     */
                                     true_end_in);
   END;

   FUNCTION endsforeach (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN    text_in = c_endforeach
             OR text_in = c_endforeach2;
   END;

   FUNCTION endsdefarray (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN    text_in = c_enddefarray
             OR text_in = c_enddefarray2;
   END;

   FUNCTION startstotarget (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN    text_in = c_totemp
             OR text_in = c_tofile
             OR text_in = c_totarget
             OR text_in = c_rto;
   END;

   FUNCTION endstotarget (
      start_in   IN   VARCHAR2,
      text_in    IN   VARCHAR2
   )
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN (   (    text_in = c_endtotemp
                  AND start_in = c_totemp
                 )
              OR (    text_in = c_endtofile
                  AND start_in = c_tofile
                 )
              OR (    text_in = c_endtotarget
                  AND start_in = c_totarget
                 )
              OR (    text_in = c_endtotemp2
                  AND start_in = c_totemp
                 )
              OR (    text_in = c_endtofile2
                  AND start_in = c_tofile
                 )
              OR (    text_in = c_endrto
                  AND start_in = c_rto
                 )
              OR (    text_in = c_endrto2
                  AND start_in = c_rto
                 )
              OR (    text_in = c_endtotarget2
                  AND start_in = c_totarget
                 )
             );
   END;

   FUNCTION startscleanup (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_cleanup;
   END;

   FUNCTION endscleanup (
      start_in   IN   VARCHAR2,
      text_in    IN   VARCHAR2
   )
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN (   (    text_in = c_endcleanup
                  AND start_in = c_cleanup
                 )
              OR (    text_in = c_endcleanup2
                  AND start_in = c_cleanup
                 )
             );
   END;

   FUNCTION requestscleanup (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_docleanup;
   END;

   FUNCTION storein (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_storein;
   END;

   FUNCTION close_storein (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_close_cmd;
   END;

   FUNCTION exec_cmd (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN (text_in IN (c_exec, c_execrto));
   END;

   FUNCTION execrto_cmd (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_execrto;
   END;

   FUNCTION execfile_cmd (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_execfile;
   END;

   FUNCTION stop_cmd (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_stop;
   END;

   FUNCTION settingvar (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_set;
   END;

   FUNCTION settingalias (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN text_in = c_setalias;
   END;

   FUNCTION ends_read_ahead (
      starttext_in   IN   VARCHAR2,
      currtext_in    IN   VARCHAR2
   )
      RETURN BOOLEAN
   IS
      retval   BOOLEAN;
   BEGIN
      IF debugging
      THEN
         pl (
               'ends read ahead start curr '
            || starttext_in
            || '-'
            || currtext_in
         );
      END IF;

      IF starttext_in = c_foreach
      THEN
         retval := endsforeach (currtext_in);
      ELSIF starttext_in = c_if
      THEN
         retval := endsif (currtext_in);
      ELSIF starttext_in = c_else
      THEN
         retval := endsif (currtext_in, TRUE);
      ELSIF starttext_in = c_defarray
      THEN
         retval := endsdefarray (currtext_in);
      ELSIF startstotarget (starttext_in)
      THEN
         retval := endstotarget (starttext_in, currtext_in);
      ELSIF startscleanup (starttext_in)