plggen.spb

Oracle PL/SQL procedure generator (second generator type)

      THEN
         retval := endscleanup (starttext_in, currtext_in);
      ELSE
         PLGerr.RAISE (
            PLGerr.unmatched_readahead,
               'No [END***] statement found for '
            || starttext_in
         );
      END IF;

      RETURN retval;
   END;

   /* Embedded tag functions */

   FUNCTION appendloc (text_in IN VARCHAR2)
      RETURN PLS_INTEGER
   IS
   BEGIN
      RETURN INSTR (text_in, vt_append);
   END;

   FUNCTION replaceloc (text_in IN VARCHAR2)
      RETURN PLS_INTEGER
   IS
   BEGIN
      RETURN INSTR (text_in, vt_replace);
   END;

   FUNCTION appending (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN appendloc (text_in) > 0;
   END;

   FUNCTION replacetarget (text_in IN VARCHAR2)
      RETURN BOOLEAN
   IS
   BEGIN
      RETURN replaceloc (text_in) > 0;
   END;

   /* Array characteristics functions */

   FUNCTION nested_loop (lt IN VARCHAR2)
      RETURN BOOLEAN
   IS
      retval   BOOLEAN;
   BEGIN
      retval := lt IN (c_fkycol,
                       c_uindcol,
                       c_fkydesc,
                       c_fkydesccol,
                       c_conscol
                      );
      RETURN retval;
   END;

   FUNCTION offset_loop (lt IN VARCHAR2)
      RETURN BOOLEAN
   IS
      retval   BOOLEAN;
   BEGIN
      retval :=
            lt IN
                 (c_arg, c_argsep, c_argfromsep, c_retarg);
      RETURN retval;
   END;

   FUNCTION alias_loop (lt IN VARCHAR2)
      RETURN BOOLEAN
   IS
      retval   BOOLEAN;
   BEGIN
      retval := lt IN (c_argfromsep);
      RETURN retval;
   END;

   FUNCTION indirect_loop (lt IN VARCHAR2)
      RETURN BOOLEAN
   /* Not just a pointer to gencol. */
   IS
      retval   BOOLEAN;
   BEGIN
      retval := lt IN (c_pkycol,
                       c_fkycol,
                       c_uindcol,
                       c_desccol,
                       c_fkydesccol,
                       c_conscol
                      );
      RETURN retval;
   END;

   FUNCTION redirect_loop (lt IN VARCHAR2)
      RETURN BOOLEAN
   /* Just a pointer to gencol. */
   IS
      retval   BOOLEAN;
   BEGIN
      retval := lt IN (c_updcol,
                       c_notnullcol,
                       c_nonpkycol,
                       c_uconscol
                      );
      RETURN retval;
   END;

   FUNCTION outer_loop (looptype IN VARCHAR2)
      RETURN VARCHAR2
   IS
      retval   PLGadmin.identifier;
   BEGIN
      IF looptype = c_uindcol
      THEN
         retval := c_uind;
      ELSIF looptype = c_conscol
      THEN
         retval := c_cons;
      ELSIF looptype = c_fkycol
      THEN
         retval := c_fky;
      ELSIF looptype = c_fkydesc
      THEN
         retval := c_fky;
      ELSIF looptype = c_fkydesccol
      THEN
         retval := c_fkydesc;
      END IF;

      RETURN retval;
   END;

   FUNCTION same_as_outer_loop (
      innerloop   IN   VARCHAR2,
      outerloop   IN   VARCHAR2
   )
      RETURN BOOLEAN
   IS
      retval   BOOLEAN := FALSE;
   BEGIN
      IF      innerloop = c_fkydesc
          AND outerloop = c_fky
      THEN
         retval := TRUE;
      END IF;

      RETURN retval;
   END;

   
/* Generation Programs */

   FUNCTION globalname (name_in IN VARCHAR2)
      RETURN VARCHAR2
   IS
      retval   PLGadmin.dbmaxvc2 := LTRIM (name_in);
   BEGIN
      IF retval LIKE    objtagopen
                     || '%'
      THEN
         retval := PLGstr.betwn (
                      retval,
                      objtagopen,
                      objtagclose,
                      inclusive=> FALSE
                   );
      END IF;

      IF INSTR (retval, '.') = 0
      THEN
         retval :=    'PLGgenv.genrec.'
                   || retval;
      END IF;

      RETURN retval;
   END;

   FUNCTION genrec_ptr (str IN VARCHAR2)
      RETURN PLS_INTEGER
   IS
   BEGIN
      /* Now look up hash value on qualifier. */
      BEGIN
         RETURN loop_hash (PLGhash (str));
      EXCEPTION
         WHEN OTHERS
         THEN
            PLGerr.RAISE (
               PLGerr.hash_value_notfound,
                  'Error finding loop/label '
               || str
               || ' in hash.'
            );
      END;
   END;

   FUNCTION loopstart (loopstate_in IN state_stk_type)
      RETURN INTEGER
   IS
      v_outer     PLGadmin.identifier
                      := outer_loop (loopstate_in.statevar);
      v_pkgname   PLGadmin.identifier;
      v_row       PLS_INTEGER         := loop_stack.LAST;
      retval      PLS_INTEGER;
   BEGIN
      /* "Manual override" */
      IF loopstate_in.startend_override
      THEN
         retval := loopstate_in.startrow;
      ELSIF offset_loop (loopstate_in.statevar)
      THEN
         retval := strbyname (
                      PLGgenv.genrec.driver,
                         loopstate_in.statevar
                      || '_START',
                      sch   => PLGgenv.genrec.schema,
                      context_in=> curlooprow
                   );
      ELSE
         IF      nested_loop (loopstate_in.statevar)
             AND v_row IS NOT NULL
         THEN
            LOOP
               IF debugging
               THEN
                  pl (
                        'loopstart checking '
                     || loop_stack (v_row).statevar
                     || ' against '
                     || v_outer
                     || '-'
                     || v_row
                  );
               END IF;

               EXIT WHEN v_row IS NULL
                      OR loop_stack (v_row).statevar =
                                                     v_outer;
               v_row := loop_stack.PRIOR (v_row);
            END LOOP;

            IF v_row IS NOT NULL
            THEN
               v_pkgname := loop_stack (v_row).pkgname;

               IF debugging
               THEN
                  pl (
                        'loopstart pkgname used from row '
                     || v_row
                     || ' is '
                     || v_pkgname
                  );
               END IF;

               IF same_as_outer_loop (
                     loopstate_in.statevar,
                     loop_stack (v_row).statevar
                  )
               THEN
                  retval := v_row; -- Use row number from outer loop row.
               ELSE
                  v_row := loop_stack (v_row).currrow;

                  IF debugging
                  THEN
                     pl (
                           'getting starting_row from loop_stack currrow'
                        || '-'
                        || v_row
                     );
                  END IF;

                  PLGvar.assign (
                        v_pkgname
                     || '.'
                     || v_outer
                     || '('
                     || TO_CHAR (v_row)
                     || ').starting_row',
                     retval,
                     dyncur
                  );
               END IF;
            END IF;
         END IF;

         IF retval IS NULL
         THEN
            PLGvar.assign (
                  loopstate_in.pkgname
               || '.'
               || loopstate_in.statevar
               || '.FIRST',
               retval,
               dyncur
            );
         END IF;
      END IF;

      RETURN retval;
   END;

   FUNCTION loopnext (row_in IN INTEGER)
      RETURN INTEGER
   IS
      retval   PLS_INTEGER;
   BEGIN
      IF alias_loop (loopstate.statevar)
      THEN
         retval := strbyname (
                      PLGgenv.genrec.driver,
                         loopstate.statevar
                      || '_NEXT',
                      sch   => PLGgenv.genrec.schema,
                      context_in=> curlooprow
                   );
      ELSE
         PLGvar.assign (
               loopstate.pkgname
            || '.'
            || loopstate.statevar
            || '.NEXT ('
            || TO_CHAR (row_in)
            || ')',
            retval,
            dyncur
         );
      END IF;

      RETURN retval;
   END;

   FUNCTION loopend (loopstate_in IN state_stk_type)
      RETURN INTEGER
   IS
      v_outer     PLGadmin.identifier
                      := outer_loop (loopstate_in.statevar);
      v_pkgname   PLGadmin.identifier;
      v_row       PLS_INTEGER         := loop_stack.LAST;
      v_start     PLS_INTEGER;
      v_count     PLS_INTEGER;
      retval      PLS_INTEGER;
   BEGIN
      /* "Manual override" */
      IF loopstate_in.startend_override
      THEN
         retval := loopstate_in.endrow;
      ELSIF offset_loop (loopstate_in.statevar)
      THEN
         retval := strbyname (
                      PLGgenv.genrec.driver,
                         loopstate_in.statevar
                      || '_END',
                      sch   => PLGgenv.genrec.schema,
                      context_in=> curlooprow
                   );
      ELSE
         IF      nested_loop (loopstate_in.statevar)
             AND v_row IS NOT NULL
         THEN
            LOOP
               IF debugging
               THEN
                  pl (
                        'loopend checking '
                     || loop_stack (v_row).statevar
                     || ' against '
                     || v_outer
                     || '-'
                     || v_row
                  );
               END IF;

               EXIT WHEN v_row IS NULL
                      OR loop_stack (v_row).statevar =
                                                     v_outer;
               v_row := loop_stack.PRIOR (v_row);
            END LOOP;

            IF v_row IS NOT NULL
            THEN
               v_pkgname := loop_stack (v_row).pkgname;

               IF debugging
               THEN
                  pl (
                        'loopend pkgname used from row '
                     || v_row
                     || ' is '
                     || v_pkgname
                  );
               END IF;

               IF same_as_outer_loop (
                     loopstate_in.statevar,
                     loop_stack (v_row).statevar
                  )
               THEN
                  v_start := v_row; -- Use row number from outer loop row.
               ELSE
                  -- 1/99 OLD v_row := loop_stack(v_row).nthrow;
                  v_row := loop_stack (v_row).currrow;
                  PLGvar.assign (
                        v_pkgname
                     || '.'
                     || v_outer
                     || '('
                     || TO_CHAR (v_row)
                     || ').starting_row',
                     v_start,
                     dyncur
                  );
               END IF;

               PLGvar.assign (
                     v_pkgname
                  || '.'
                  || v_outer
                  || '('
                  || TO_CHAR (v_row)
                  || ').column_count',
                  v_count,
                  dyncur
               );
               retval :=   v_start
                         + v_count
                         - 1;
            END IF;
         END IF;

         IF retval IS NULL
         THEN
            PLGvar.assign (
                  loopstate_in.pkgname
               || '.'
               || loopstate_in.statevar
               || '.LAST',