plggen.tst

Oracle PL/SQL procedure generator (second generator type)

            staterec.statevar || '-' ||
            staterec.statelabel || '-' ||
            --staterec.beforetext || '-' ||
            --staterec.aftertext || '-' ||
            staterec.betweentext || '-' ||
            staterec.startrow || '-' ||
            staterec.endrow);
      END IF;
   END;

   PROCEDURE drv_array_add (
      drvrec IN OUT PLGdoir.drvrec_t,
      txt IN VARCHAR2,
      encr IN BOOLEAN,
      prev_row IN PLS_INTEGER := NULL,
      curr_row IN PLS_INTEGER := NULL)
   IS
      v_line plgadmin.dbmaxvc2 := txt;
      v_row PLS_INTEGER := drvrec.last_row;
   BEGIN
      IF iscomment (v_line)
      THEN
         /* Skip the comment... */
         NULL;
      ELSE
         IF encr
         THEN
            v_line := PLGadmin.decrypt (v_line);
         END IF;

         IF drvrec.last_row IS NULL
         THEN
            v_row := PLGofst.first (drvrec.seq, v_drv_max, 1);
         ELSE
            v_row := drvrec.last_row + 1;
            --v_row := PLGofst.shifted (drvrec.seq, v_drv_max, drvrec.last_row+1, 1);
         END IF;

         IF debugging AND FALSE
         THEN
            pl ('drv_array_add to row ' || v_row);
         END IF;

         /* 99.2 RTRIM everything */

         drv_array(v_row).text := RTRIM (v_line);
         drv_array(v_row).ut_text := /* 99.2 Trim tabs also */
            UPPER (LTRIM (LTRIM (drv_array(v_row).text), CHR(9)));
         drv_array(v_row).next_row := v_row + 1;
         drv_array(v_row).original_line := curr_row;
         drv_array(v_row).firsttagloc :=
            INSTR (drv_array(v_row).ut_text, objtagopen);
         IF drv_array(v_row).firsttagloc > 0
         THEN
            drv_array(v_row).firstTag :=
               PLGstr.betwn (
                  drv_array(v_row).ut_text,
                  objtagopen,
                  objtagclose,
                  inclusive=>FALSE);
         END IF;

         /*
         IF PLGgenv.genrec.relSpacing
         THEN
            DECLARE
               v_char CHAR(1);
               v_loc PLS_INTEGER;
            BEGIN
               LOOP
                  v_char := SUBSTR (drv_array(v_row).text, v_loc, 1);
                  EXIT WHEN v_char != ' ';
                  v_loc := v_loc + 1;
               END LOOP;
            END;
         END IF;
         */

         IF prev_row IS NOT NULL
         THEN
            drv_array(v_row).prev_row := prev_row;
            drv_array(prev_row).next_row := v_row;
         ELSE
            drv_array(v_row).prev_row := v_row - 1;
         END IF;

         IF debugging AND FALSE
         THEN
            pl ('drv_array_add to row ' || v_row ||
               ' next ' || drv_array(v_row).next_row ||
               ' prev ' || drv_array(v_row).prev_row || ': ' || v_line);
         END IF;

         /* Last row set in this pass. */
         drvrec.last_row := v_row;
      END IF;
   END;

   PROCEDURE drv_array_terminate (
      drvrec IN OUT PLGdoir.drvrec_t,
      row IN PLS_INTEGER := NULL)
   IS
   BEGIN
      IF debugging
      THEN
         pl ('terminate seq ' || drvrec.seq || ' at last row '|| drvrec.last_row
            || ' with ' || row);
      END IF;

      IF drvrec.last_row IS NOT NULL
      THEN
         drv_array(drvrec.last_row).next_row := row;
      END IF;
   END;

   PROCEDURE drv_array_delete (seq IN PLS_INTEGER := NULL)
   IS
   BEGIN
      IF seq IS NULL /* Complete clean up */
      THEN
         drv_array.DELETE;
         drv_info.DELETE;
         g_include_seq := c_include_seq_start;
      ELSE
         drv_info.DELETE (seq);
         drv_array.DELETE (
            PLGofst.first (seq, v_drv_max, 1),
            PLGofst.last (seq, v_drv_max, 1)
            );
      END IF;
   END;

   FUNCTION drv_array_start (seq IN PLS_INTEGER) RETURN PLS_INTEGER
   IS
   BEGIN
      RETURN PLGofst.first (seq, v_drv_max, 1);
   END;

   FUNCTION drv_array_end (seq IN PLS_INTEGER) RETURN PLS_INTEGER
   IS
   BEGIN
      RETURN drv_array.PRIOR (PLGofst.last (seq, v_drv_max, 1)+1);
   END;

   FUNCTION drv_array_exists (row IN PLS_INTEGER) RETURN BOOLEAN
   IS
   BEGIN
      RETURN drv_array.EXISTS (row);
   END;

   FUNCTION drv_array_next (row IN PLS_INTEGER,
      native_error IN BOOLEAN := FALSE) RETURN PLS_INTEGER
   IS
      retval PLS_INTEGER;
   BEGIN
      IF row IS NOT NULL
      THEN
         retval := NVL (drv_array(row).next_row, row + 1);
      END IF;
      RETURN retval;
   EXCEPTION
      WHEN NO_DATA_FOUND
      THEN
         IF native_error THEN RAISE;
         ELSE
         PLGerr.raise (
            PLGerr.read_error,
            'Attempt to get next drv_array row touched undefined row ' || row);
         END IF;
   END;

   PROCEDURE set_drv_array_next (row_in IN PLS_INTEGER, nextrow IN PLS_INTEGER)
   IS
   BEGIN
      drv_array(row_in).next_row := nextrow;
   EXCEPTION
      WHEN NO_DATA_FOUND THEN
         PLGerr.raise ('Unable to get drv array next text for row ' || row_in);
   END;

   FUNCTION drv_array_prev (row_in IN PLS_INTEGER) RETURN PLS_INTEGER
   IS
   BEGIN
      IF row_in IS NULL
      THEN
         RETURN NULL;
      ELSE
         RETURN drv_array(row_in).prev_row;
      END IF;
   EXCEPTION
      WHEN NO_DATA_FOUND THEN
         PLGerr.raise ('Unable to get drv array prev text for row ' || row_in);
   END;

   FUNCTION drv_array_text (row_in IN PLS_INTEGER) RETURN VARCHAR2
   IS
   BEGIN
      RETURN drv_array(row_in).text;
   EXCEPTION
      WHEN NO_DATA_FOUND THEN
         PLGerr.raise ('Unable to get drv array text for row ' || row_in);
   END;

   FUNCTION drv_array_ut_text (row_in IN PLS_INTEGER) RETURN VARCHAR2
   IS
   BEGIN
      RETURN drv_array(row_in).ut_text;
   EXCEPTION
      WHEN NO_DATA_FOUND THEN
         PLGerr.raise ('Unable to get drv array UT text for row ' || row_in);
   END;

   FUNCTION drv_array_firstTag (
      row_in IN PLS_INTEGER, native_error IN BOOLEAN := FALSE) RETURN VARCHAR2
   IS
   BEGIN
      RETURN drv_array(row_in).firstTag;
   EXCEPTION
      WHEN NO_DATA_FOUND 
      THEN
         IF native_error THEN RAISE;
         ELSE
            PLGerr.raise ('Unable to get first tag for row ' || row_in);
         END IF;
   END;

   FUNCTION drv_array_firstTagLoc (
      row_in IN PLS_INTEGER) RETURN PLS_INTEGER
   IS
   BEGIN
      RETURN drv_array(row_in).firstTagLoc;
   EXCEPTION
      WHEN NO_DATA_FOUND THEN
         PLGerr.raise ('Unable to get first tag location for row ' || row_in);
   END;

   FUNCTION drv_array_ut_text (text_in IN VARCHAR2) RETURN VARCHAR2
   IS
   BEGIN
      RETURN UPPER (LTRIM (text_in));
   END;

   PROCEDURE check_identifiers (
      drvtext_str IN VARCHAR2,
      genstr IN OUT VARCHAR2
      )
   IS
      v_startloc PLS_INTEGER;
      v_endloc PLS_INTEGER;
      v_nthoccur PLS_INTEGER := 1;
      v_orig_identifier PLGadmin.dbmaxvc2;
      v_alias_identifier PLGadmin.dbmaxvc2;
      v_alias PLGadmin.dbmaxvc2;
      v_orig_alias PLGadmin.dbmaxvc2;
      v_lower_genstr PLGadmin.maxvc2 := LOWER (genstr);

      FUNCTION invalid_identifier (str IN VARCHAR2) RETURN BOOLEAN
      IS
         v_dotloc PLS_INTEGER := INSTR (str, '.');
         v_len PLS_INTEGER := LENGTH (str);
         retval BOOLEAN := FALSE;
      BEGIN
         IF v_dotloc = 0
         THEN
            retval :=
               v_len > g_ident_length;
         /*
         ELSE
            -- Check right and left sides...but more than one dot?
            retval :=
               invalid_identifier (SUBSTR (str, 1, v_dotloc-1)) OR
               invalid_identifier (SUBSTR (str, v_dotloc+1))
               ;
         */
         END IF;

         RETURN retval;
      END;

      PROCEDURE record_identifier_problem (
         ident IN VARCHAR2,
         new_ident IN VARCHAR2,
         alias IN VARCHAR2,
         alias_descrip IN VARCHAR2)
      IS
         v_row PLS_INTEGER;
      BEGIN
         /* Only add it if it is not already present. */
         v_row := invalid_idents.FIRST;
         LOOP
            EXIT WHEN
               v_row IS NULL
               OR
               invalid_idents (v_row).new_ident = new_ident;
            v_row := invalid_idents.NEXT (v_row);
         END LOOP;

         IF v_row IS NULL
         THEN
            v_row := NVL (invalid_idents.LAST, 0) + 1;
            invalid_idents (v_row).driver := PLGgenv.genrec.driver;
            invalid_idents (v_row).owner := PLGgenv.genrec.schema;
            invalid_idents (v_row).name := PLGgenv.genrec.objname;
            invalid_idents (v_row).type := PLGgenv.genrec.target;
            invalid_idents (v_row).alias := alias;
            invalid_idents (v_row).alias_description := alias_descrip;
            invalid_idents (v_row).ident := ident;
            invalid_idents (v_row).new_ident := new_ident;
         END IF;
      END;

      FUNCTION fixed_identifier (ident_alias IN VARCHAR2) RETURN VARCHAR2
      IS
         v_row PLS_INTEGER := invalid_idents.first;
         foundit BOOLEAN := FALSE;
         retval PLGadmin.identifier;
      BEGIN
         LOOP
            EXIT WHEN v_row IS NULL OR foundit;
            foundit := invalid_idents (v_row).ident = ident_alias;
            IF foundit
            THEN
               retval := invalid_idents(v_row).new_ident;
            ELSE
               v_row := invalid_idents.NEXT (v_row);
            END IF;
         END LOOP;
         RETURN retval;
      END;

   BEGIN
      /*
         drvtext_str example: PROCEDURE ^{openbypkycurproc}^ (^second_identifier^,
         genstr example: PROCEDURE ^open_emp_long_tab_fk2bypky_cur^ (^what_a_long_argument_name^,
      */

      /*
         For each identifier in genstr, extract the value, do a final aliasing,
         perform validations, such as name too long, and if a problem, go back
         to drvtext_str and find the original name and log it to an error stack for
         later display/manipulation.
      */
      LOOP
         /* Go to the next idtag. */
         v_startloc := INSTR (genstr, idtag, 1, v_nthoccur);
         EXIT WHEN v_startloc = 0 OR genstr IS NULL;

         /* Get the identifier: between startloc and NEXT idtag. */
         v_endloc := INSTR (genstr, idtag, 1, v_nthoccur+1);

         IF v_endloc = 0
         THEN
            /* Error in syntax. Unmatching idtags. */
            PLGerr.raise (
               PLGerr.unmatched_idtags,
               'orig str ' || drvtext_str || CHR(10) ||
               'genstr ' || genstr);
            EXIT;
         ELSE
            v_orig_identifier :=
               PLGstr.betwn (v_lower_genstr, v_startloc, v_endloc, inclusive=>FALSE);

            /* Do a final alias substitution for the terminal string */
            v_alias_identifier :=
               LOWER (
                  PLGdoir.alias (
                     PLGgenv.genrec.driver,
                     PLGgenv.genrec.objname,
                     v_orig_identifier,
                     PLGgenv.genrec.schema
                  )
               );

            /* Get the original identifier alias. */
            v_orig_alias :=
               TRANSLATE (
                  PLGstr.betwn (drvtext_str, idtag, idtag, v_nthoccur, inclusive=>FALSE),
                  'A'||aliasopen||aliasclose, 'A');

            IF invalid_identifier (v_alias_identifier)
            THEN
               DECLARE
                  v_alias PLGadmin.dbmaxvc2 := fixed_identifier (v_alias_identifier);
                  v_alias_descrip PLG_doir.doc%TYPE;
               BEGIN
                  IF v_alias IS NOT NULL /* Already encountered this one. */
                  THEN
                     v_alias_identifier := v_alias;
                  ELSE
                     v_alias_descrip :=
                        PLGdoir.alias_descrip (
                           PLGgenv.genrec.driver,
                           PLGgenv.genrec.objname,
                           v_orig_alias,
                           PLGgenv.genrec.schema
                           );

                     /* 99.2 Don't get the abbreviation each time.
                     v_abbrev :=
                        PLGdoir.objabbrev (
                           PLGgenv.genrec.driver,
                           PLGgenv.genrec.objname,
                           PLGgenv.genrec.schema
                           );
                     */

                     /* Replace object name with abbreviation if it exists. */
                     IF PLGgenv.genrec.objabbrev IS NOT NULL
                     THEN
                        v_alias_identifier :=
                           REPLACE (
                              v_alias_identifier,
                              LOWER (PLGgenv.genrec.objname),
                              LOWER (PLGgenv.genrec.objabbrev));
                     END IF;

                     /* Perform a truncation of the string down to the max length allowed. */
                     v_alias_identifier := SUBSTR (v_alias_identifier, 1, g_ident_length);

                     /* If the resulting identifier is already in use,
                        modify with sequence number. */
                     WHILE PLGihash.inuse (v_alia