plggen.tst

Oracle PL/SQL procedure generator (second generator type)

               END IF;

               IF v_srcrec.context = 'DEFAULT'
               THEN
                  /* Don't need to do complex substitution. */
                  v_srcrec.plsql_command :=
                     PLGdoir.func_call (
                        v_name,
                        PLGgenv.genrec.driver,
                        PLGgenv.genrec.objname,
                        PLGgenv.genrec.schema);
               ELSE
                  subst_string (
                     drv,
                     v_srcrec.plsql_command,
                     embed_in_quotes => TRUE,
                     sch => v_sch,
                     context_in => context_in);
               END IF;

               IF debugging
               THEN
                  pl ('Dynamic OIR execution of: ' || v_srcrec.plsql_command);
               END IF;

               IF PLGadmin.isvarchar2 (v_srcrec.returntype)
               THEN
                  PLGvar.assign (v_srcrec.plsql_command, retval, dyncur);
               ELSIF PLGadmin.isnumber (v_srcrec.returntype)
               THEN
                  PLGvar.assign (v_srcrec.plsql_command, v_number, dyncur);
                  retval := TO_CHAR (v_number);
               ELSIF PLGadmin.isboolean (v_srcrec.returntype)
               THEN
                  PLGvar.assign (v_srcrec.plsql_command, v_boolean, dyncur);
                  retval := PLGbool.stg (v_boolean, PLGdoir.c_truefalse);
               END IF;

               IF debugging
               THEN
                  pl ('generated a value of : ' || retval);
               END IF;
            END;

         ELSE /* Non PL/SQL object tag: look up in array or PLGgenv */

            IF v_qualifier IS NOT NULL
            THEN
               v_loc := genrec_ptr (v_qualifier);
            END IF;

            IF PLGdoir.iteration_specific_src (drv, v_srcrec)
            THEN
               IF v_qualifier IS NOT NULL
               THEN
                  retval := valbyname
                     ('PLGgen.genstate (' || TO_CHAR (v_loc) || ').' || v_name, dyncur);
               ELSE
                  retval := valbyname ('PLGgen.loopstate.' || v_name, dyncur);
               END IF;

            ELSIF PLGdoir.driver_wide_src (drv, v_srcrec)
            THEN
               IF v_qualifier IS NOT NULL
               THEN
                  retval := valbyname
                     ('PLGgen.genstate (' || TO_CHAR (v_loc) || ').' || v_name, dyncur);

               /* 99.2 Special case override of name with abbreviation */
               ELSIF PLGgenv.genrec.useobjabbrev AND
                     v_name = PLGdoir.c_objname
               THEN
                  retval := PLGgenv.genrec.objabbrev;

               /* 99.2 Avoid dynamic PL/SQL with known elements */
               ELSIF v_name = PLGdoir.c_objname
               THEN
                  retval := PLGgenv.genrec.objname;

               ELSE
                  retval := valbyname ('PLGgenv.genrec.' || v_name, dyncur);
               END IF;

            ELSIF PLGdoir.column_specific_src (PLGgenv.genrec.driver, 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 (LOWER (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 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
      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
      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 subst_string;

   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
      subst_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;
      staterec.statetype := v_statetype;

      /* Get command and main qualifier */
      staterec.statecommand :=
         PLGstr.betwn (text_in, objtagopen, objtagclose, inclusive=>FALSE);
      staterec.statevar :=
         NVL (bracketedval (text_in, objtagclose),
              SUBSTR (text_in, INSTR (text_in, objtagclose)+1));

      /* Extract other elements if present. */
      staterec.statelabel := bracketedval (text_in, vt_AS);
      staterec.astext := staterec.statelabel;
      staterec.betweentext := bracketedval (text_in, vt_BETWEEN);

      /* Special processing for arrays. */
      IF staterec.statetype = c_loopstate
      THEN
         /* Validate the array and retrieve names. */
         PLGdoir.validate_isarray (
            PLGgenv.genrec.driver,
            staterec.statevar,
            staterec.pkgname);

         /* Set the current array name */
         PLGgenv.genrec.arrayname := staterec.statevar;
      END IF;

      staterec.at_first_line := TRUE;

      IF debugging
      THEN
         pl ('STATEREC values command-var-pkg-label-between: ' ||
            staterec.statecommand || '-' ||
            staterec.statevar || '-' ||
            staterec.pkgname || '-' ||
            staterec.statelabel || '-' ||
            staterec.betweentext);
      END IF;

      v_start := bracketedval (text_in, vt_STARTROW);
      v_end := bracketedval (text_in, vt_ENDROW);

      IF debugging
      THEN
         pl ('STATEREC values start-end: ' ||
            staterec.startrow || '-' ||
            staterec.endrow);
      END IF;

      IF v_start IS NOT NULL
      THEN
         staterec.startend_override := TRUE;

         staterec.startrow :=
            strbyname (PLGgenv.genrec.driver,
               v_start, sch => PLGgenv.genrec.schema,
            context_in => curlooprow);

         staterec.endrow :=
            strbyname (PLGgenv.genrec.driver,
               v_end, sch => PLGgenv.genrec.schema,
            context_in => curlooprow);
      END IF;

      IF debugging
      THEN
         pl ('STATEREC values for ' || text_in ||
            'type-var-label-between-start-end: ' ||
            staterec.statecommand || '-' ||