plggen.spb

Oracle PL/SQL procedure generator (second generator type)

                     drv,
                     v_srcrec
                  )
            THEN
               /*
               label --> location in stack --> row# and statevar --> colname
               nolabel -->   row# and statevar --> colname
               */
               IF v_qualifier IS NULL
               THEN
                  /*-- 1/99 OLD v_loc := loopstate.currrow; */
                  v_coltype := loopstate.statevar;

                  IF v_coltype IS NOT NULL
                  THEN
                     v_loc :=   loopstart (loopstate)
                              + loopstate.nthrow
                              - 1;
                  END IF;
               ELSE
                  v_coltype :=
                           PLGgen.genstate (v_loc).statevar;
                  v_loc := PLGgen.genstate (v_loc).currrow;
               END IF;

               PLGerr.assert (
                  v_coltype IS NOT NULL,
                     'Invalid use of column-specific tag "'
                  || v_name
                  || '". Confirm [FOREACH] context.',
                  PLGerr.undefined_objtag
               );

               IF indirect_loop (v_coltype)
               THEN
                  retval := valbyname (
                                  loopstate.pkgname
                               || '.'
                               || v_coltype
                               || '('
                               || TO_CHAR (v_loc)
                               || ').column_name',
                               dyncur
                            );
                  v_loc := gencol_row (retval);
               ELSIF redirect_loop (v_coltype)
               THEN
                  /* Get location from contents of array. */
                  PLGvar.assign (
                        loopstate.pkgname
                     || '.'
                     || v_coltype
                     || '('
                     || TO_CHAR (v_loc)
                     || ')',
                     v_loc,
                     dyncur
                  );
               ELSIF v_coltype = c_col
               THEN
                  /* All set, I think! */
                  NULL;
               END IF;

               retval := valbyname (
                               'PLGgen.gencol('
                            || TO_CHAR (v_loc)
                            || ').'
                            || v_name,
                            dyncur
                         );
            END IF;
         END IF;
      END IF;

      --tmr_end;
      RETURN retval;
   EXCEPTION
      WHEN null_name
      THEN
         RETURN retval;
      WHEN plsql_compile_error
      THEN
         PLGerr.RAISE (
            PLGerr.undefined_objtag,
               'Undefined or unmatched object tag : '
            || name_in
         );
      WHEN OTHERS
      THEN
         PLGerr.RAISE (
               'Error ORA-'
            || SQLCODE
            || ' translating '
            || name_in
         );
   END strbyname;

   PROCEDURE substitute_string (
      drv                IN       VARCHAR2,
      str                IN OUT   VARCHAR2,
      embed_in_quotes    IN       BOOLEAN := FALSE,
      subst_db_tags      IN       BOOLEAN := TRUE,
      subst_db_open      IN       VARCHAR2 := NULL,
      subst_db_close     IN       VARCHAR2 := NULL,
      use_tag_example    IN       BOOLEAN := FALSE,
      sch                IN       VARCHAR2 := NULL,
      context_in         IN       VARCHAR2 := NULL,
      expandalias_only   IN       BOOLEAN := FALSE
   )
   IS
      v_iterations   PLS_INTEGER := 1;
      v_loc          PLS_INTEGER;
      v_loc1         PLS_INTEGER;

      PROCEDURE subst_tagged_elements (
         op              IN   VARCHAR2,
         cl              IN   VARCHAR2,
         justonce        IN   BOOLEAN := FALSE,
         noncontigopen   IN   VARCHAR2 := NULL
      )
      IS
         v_end         PLS_INTEGER;
         v_orig_word   PLGadmin.dbmaxvc2;
         v_word        PLGadmin.dbmaxvc2;
         v_start       PLS_INTEGER       := 1;
         v_embed       BOOLEAN           := embed_in_quotes;

         FUNCTION nextword (str IN VARCHAR2)
            RETURN VARCHAR2
         IS
            nothing_found   BOOLEAN        := TRUE;
            v_loc           BINARY_INTEGER;
         BEGIN
            v_loc := INSTR (str, op, 1);

            IF v_loc > 0
            THEN
               nothing_found := noncontigopen IS NOT NULL;

               IF nothing_found
               THEN
                  nothing_found := SUBSTR (
                                      str,
                                        v_loc
                                      + 1,
                                      1
                                   ) = noncontigopen;
               END IF;
            END IF;

            IF nothing_found
            THEN
               RETURN NULL;
            ELSE
               RETURN PLGstr.betwn (
                         SUBSTR (str, v_loc),
                         op,
                         cl
                      );
            END IF;
         END;
      BEGIN
         LOOP
            v_orig_word := nextword (str);
            EXIT WHEN v_orig_word IS NULL;

            IF      NOT subst_db_tags
                AND op = objtagopen
            THEN
               DECLARE
                  do_translate   BOOLEAN := TRUE;
               BEGIN
                  IF use_tag_example
                  THEN
                     /* Replace tag with example text */
                     v_word :=
                        PLGdoir.tag_example (
                           drv,
                           v_orig_word,
                           objtagopen,
                           objtagclose
                        );

                     IF v_word IS NOT NULL
                     THEN
                        str := REPLACE (
                                  str,
                                  v_orig_word,
                                  v_word
                               );
                        do_translate := FALSE;
                     END IF;
                  END IF;

                  IF do_translate
                  THEN
                     /* If not substituting DB tags, then replace them with
                        substitution characters. */
                     str := TRANSLATE (
                               str,
                                  objtagopen
                               || objtagclose,
                                  subst_db_open
                               || subst_db_close
                            );
                  END IF;
               END;
            ELSE
               /* Perform the dynamic substitutions. */
               IF    v_orig_word LIKE    op
                                      || c_asis_wild
                  OR v_orig_word LIKE c_asis_wild
               THEN
                  v_embed := FALSE;
                  v_word := TRANSLATE (
                               v_orig_word,
                               c_asis_translate,
                               c_translate
                            );
               ELSE
                  v_embed := embed_in_quotes;
                  v_word := v_orig_word;
               END IF;

               v_word := strbyname (
                            drv,
                            v_word,
                            op,
                            cl,
                            sch   => sch,
                            context_in=> context_in
                         );

               IF v_embed
               THEN
                  v_word :=    ''''
                            || v_word
                            || '''';
               END IF;

               str := REPLACE (str, v_orig_word, v_word);
            END IF;

            /* Trap for infinite loop */
            IF v_iterations > maxiterations
            THEN
               PLGerr.RAISE (
                  PLGerr.too_many_iterations,
                     'Unmatched object or alias tags in '
                  || str
               );
               RAISE DUP_VAL_ON_INDEX;
            ELSE
               v_iterations :=   v_iterations
                               + 1;
            END IF;

            EXIT WHEN justonce;
         END LOOP;

         /* Get rid of double brackets if present. */
         str := REPLACE (str,    op
                              || op, op);
         str := REPLACE (str,    cl
                              || cl, cl);
      END;
   BEGIN
      IF g_asis
      THEN
         -- No substitutions
         NULL;
      ELSE
         LOOP
            v_loc := INSTR (str, objtagopen);
            v_loc1 := INSTR (str, aliasopen);
            /* I dare you, Steven, to explain this one! */
            EXIT WHEN (   str IS NULL
                       OR v_loc IS NULL
                       OR v_loc1 IS NULL
                      )
                   OR (    subst_db_tags
                       AND v_loc = 0
                       AND v_loc1 = 0
                      )
                   OR (    NOT subst_db_tags
                       AND v_loc1 = 0
                       AND (   v_loc = 0
                            OR (    v_loc > 0
                                AND NOT use_tag_example
                               )
                           )
                      );
            subst_tagged_elements (
               aliasopen,
               aliasclose,
               justonce=> TRUE,
               noncontigopen=> objtagopen
            );           /* checks for cases like {[abc]} */
            subst_tagged_elements (objtagopen, objtagclose);

            /* Trap for infinite loop */
            IF v_iterations > maxiterations
            THEN
               PLGerr.RAISE (
                  PLGerr.too_many_iterations,
                     'Unmatched object or alias tags in '
                  || str
               );
               RAISE DUP_VAL_ON_INDEX;
            ELSE
               v_iterations :=   v_iterations
                               + 1;
            END IF;
         END LOOP;

         IF NOT subst_db_tags
         THEN
            str := TRANSLATE (
                      str,
                         subst_db_open
                      || subst_db_close,
                         objtagopen
                      || objtagclose
                   );
         END IF;

         /* Strip out any PLG alias prefixes that may still be around. */
         str := REPLACE (str, PLGdoir.PLGalias, NULL);
      END IF;
   END substitute_string;

   FUNCTION substitute_string (
      drv               IN   VARCHAR2,
      str               IN   VARCHAR2,
      embed_in_quotes   IN   BOOLEAN := FALSE,
      subst_db_tags     IN   BOOLEAN := TRUE,
      subst_db_open     IN   VARCHAR2 := NULL,
      subst_db_close    IN   VARCHAR2 := NULL,
      use_tag_example   IN   BOOLEAN := FALSE,
      sch               IN   VARCHAR2 := NULL,
      context_in        IN   VARCHAR2 := NULL
   )
      RETURN VARCHAR2
   IS
      retval   PLGadmin.dbmaxvc2 := str;
   BEGIN
      substitute_string (
         drv,
         retval,
         embed_in_quotes,
         subst_db_tags,
         subst_db_open,
         subst_db_close,
         use_tag_example,
         sch,
         context_in
      );
      RETURN retval;
   END;

   PROCEDURE subst_string (
      drv                IN       VARCHAR2,
      str                IN OUT   VARCHAR2,
      embed_in_quotes    IN       BOOLEAN := FALSE,
      subst_db_tags      IN       BOOLEAN := TRUE,
      subst_db_open      IN       VARCHAR2 := NULL,
      subst_db_close     IN       VARCHAR2 := NULL,
      use_tag_example    IN       BOOLEAN := FALSE,
      sch                IN       VARCHAR2 := NULL,
      context_in         IN       VARCHAR2 := NULL,
      expandalias_only   IN       BOOLEAN := FALSE
   )
   IS
   BEGIN
      substitute_string (
         drv,
         str,
         embed_in_quotes,
         subst_db_tags,
         subst_db_open,
         subst_db_close,
         use_tag_example,
         sch,
         context_in,
         expandalias_only
      );
   END;

   FUNCTION subst_string (
      drv               IN   VARCHAR2,
      str               IN   VARCHAR2,
      embed_in_quotes   IN   BOOLEAN := FALSE,
      subst_db_tags     IN   BOOLEAN := TRUE,
      subst_db_open     IN   VARCHAR2 := NULL,
      subst_db_close    IN   VARCHAR2 := NULL,
      use_tag_example   IN   BOOLEAN := FALSE,
      sch               IN   VARCHAR2 := NULL,
      context_in        IN   VARCHAR2 := NULL
   )
      RETURN VARCHAR2
   IS
      retval   PLGadmin.dbmaxvc2 := str;
   BEGIN
      substitute_string (
         drv,
         retval,
         embed_in_quotes,
         subst_db_tags,
         subst_db_open,
         subst_db_close,
         use_tag_example,
         sch,
         context_in
      );
      RETURN retval;
   END;

   PROCEDURE setstate (
      staterec   IN OUT   state_stk_type,
      text_in    IN       VARCHAR2
   )
   IS
      v_start       PLGadmin.identifier;
      v_end         PLGadmin.identifier;
      v_statetype   PLS_INTEGER         := staterec.statetype;
   BEGIN
      IF debugging
      THEN
         pl (
               'setstate for '
            || text_in
            || ' with type '
            || staterec.statetype
         );
      END IF;

      staterec := empty_staterec;
      statere