plgdesc.spb

Oracle PL/SQL procedure generator (second generator type)

                              PLGadmin.ifelse (argind = prog_out(rowind).argcount, 1, 0);

                           progsep_out(v_seprow).endrow :=
                              progsep_out(v_seprow).startrow +
                              progsep_out(v_seprow).argcount -
                              1;

                           progsep_out(v_seprow).nonsependrow := v_currrow;

                           progsep_out(v_seprow).nonsepargcount :=
                              progsep_out(v_seprow).nonsependrow -
                              progsep_out(v_seprow).nonsepstartrow + 1;

                        END IF;
                        v_seprow := v_seprow + 1;
                     END IF;

                     IF argind != prog_out(rowind).argcount /* Not cleaning up last one. */
                     THEN
                        /* Populate the progsep table entry for this overloading. */
                        progsep_out(v_seprow).overload :=
                           arglist_out(v_currrow).overload;

                        /* Set the program type */
                        set_progtype (v_currrow, v_seprow);

                        v_currargseprow := PLGofst.shifted (v_seprow, c_prog_max, 1, 1);
                        progsep_out(v_seprow).startrow := v_currargseprow;
                        v_last_startseprow := v_currargseprow;
                        v_last_overload := arglist_out(v_currrow).overload;

                        progsep_out(v_seprow).nonsepstartrow := v_currrow;
                        progsep_out(v_seprow).nonsepnonretstartrow := v_currrow;
                     END IF;
                  END IF;

                  /* Transfer arg information to sep arg list. */
                  argseplist_out(v_currargseprow) := arglist_out(v_currrow);
                  arglist_out(v_currrow).startseprow := v_currargseprow;
                  arglist_out(v_currrow).endseprow := v_currargseprow;
                  arglist_out(v_currrow).is_composite :=
                     based_on_type (arglist_out(v_currrow).data_type);

                  /* Increment the argument row numbers. */
                  v_currargseprow := v_currargseprow + 1;
                  v_currrow := v_currrow + 1;
               END LOOP;
            END;

            prog_out(rowind).endseprow := v_seprow - 1;

         ELSE /* Not overloaded. */

            /* Make the link back to the non-separated program, duplicate program name. */
            progsep_out(v_seprow).progname := prog_out(rowind).progname;
            progsep_out(v_seprow).nonseprow := rowind;
            prog_out(rowind).startseprow := v_seprow;
            prog_out(rowind).endseprow := v_seprow;

            /* Set the argument row values. */

            progsep_out(v_seprow).argcount := prog_out(rowind).argcount;

            IF progsep_out(v_seprow).argcount = 0
            THEN
               progsep_out(v_seprow).startrow := NULL;
               progsep_out(v_seprow).endrow := NULL;
            ELSE
               progsep_out(v_seprow).startrow :=
                  PLGofst.shifted (v_seprow, c_prog_max, 1, 1);

               progsep_out(v_seprow).endrow :=
                  progsep_out(v_seprow).startrow + progsep_out(v_seprow).argcount - 1;
            END IF;

            progsep_out(v_seprow).nonsepargcount := prog_out(rowind).argcount;
            progsep_out(v_seprow).nonsepstartrow := prog_out(rowind).startrow;
            progsep_out(v_seprow).nonsepnonretstartrow := prog_out(rowind).startrow;
            progsep_out(v_seprow).nonsependrow := prog_out(rowind).endrow;

            set_progtype (prog_out(rowind).startrow, v_seprow);

            /* Copy all the arguments over without any alterations. */
            FOR argind IN 1 .. prog_out(rowind).argcount
            LOOP
               v_row := prog_out(rowind).startrow+argind-1;
               argseplist_out(progsep_out(v_seprow).startrow+argind-1) :=
                  arglist_out(v_row);
               arglist_out(v_row).startseprow := v_row;
               arglist_out(v_row).endseprow := v_row;
               arglist_out(v_row).is_composite :=
                  based_on_type (arglist_out(v_row).data_type);
            END LOOP;

            /* Ready for the next program unit... */
            v_seprow := v_seprow + 1;
         END IF;
      END LOOP;
   END;

   PROCEDURE filter_arguments (
      prog_out IN OUT prog_tt,
      arglist_out IN OUT arglist_tt,
      progsep_out IN OUT progsep_tt,
      argseplist_out IN OUT arglist_tt
      )
   /*
   || Sweep through ENTIRE CONTENTS of argsep. For each program (progsep),
   || move the function return information to its own location and get rid
   || of composite data structures.
   */
   IS
      PROCEDURE remove_composites (
         progrow_in IN INTEGER,
         startrow_in IN INTEGER,
         endrow_inout IN OUT INTEGER,
         argcount_inout IN OUT INTEGER,
         has_comp_inout IN OUT BOOLEAN,
         nonsepstartrow IN PLS_INTEGER
         )
      IS
         curr_level PLS_INTEGER;
         last_level PLS_INTEGER := NULL;

         /* argument name put together from composite names. */
         arg_name PLGadmin.identifier := NULL;

         /* actual composite name with dot notation. */
         comp_name PLGadmin.dbmaxvc2 := NULL;

         in_ibtab BOOLEAN := FALSE;

         /* stack of argument and composite names. */
         c_stack CONSTANT VARCHAR2(30) := 'PLG$PLSQL$ARG-COMP-NAME';

         last_row PLS_INTEGER := startrow_in + argcount_inout - 1;
         new_row PLS_INTEGER := startrow_in;

         nonseprow PLS_INTEGER := nonsepstartrow;
         save_nonseprow PLS_INTEGER := nonsepstartrow;

         PROCEDURE set_nonseps (
            arg_name_in IN VARCHAR2,
            is_composite_in IN BOOLEAN,
            level_in IN PLS_INTEGER)
         IS
         BEGIN
            IF arg_name_in IS NULL AND level_in = 0
            THEN
               arglist_out(nonseprow).startseprow := new_row;

               IF is_composite_in
               THEN
                  save_nonseprow := nonseprow;
               ELSE
                  arglist_out(nonseprow).endseprow := new_row;
               END IF;
            ELSE
               arglist_out(nonseprow).startseprow := NULL;
               arglist_out(nonseprow).endseprow := NULL;
            END IF;
         END;

         FUNCTION arg_name_val (name_in IN VARCHAR2, row_in IN PLS_INTEGER) RETURN VARCHAR2
         IS
         BEGIN
            IF argseplist_out(row_in).argument_name IS NULL
            THEN
               RETURN name_in;
            ELSE
               RETURN
                   identifier_fit (
                      name_in ||
                      PLGadmin.ifelse (name_in IS NULL, NULL, '_') ||
                      argseplist_out(row_in).argument_name
                      );
            END IF;
         END;

         FUNCTION comp_name_val (name_in IN VARCHAR2, row_in IN PLS_INTEGER) RETURN VARCHAR2
         IS
         BEGIN
            IF argseplist_out(row_in).argument_name IS NULL
            THEN
               RETURN name_in;
            ELSE
               RETURN
                  name_in ||
                  PLGadmin.ifelse (name_in IS NULL, NULL, '.') ||
                  argseplist_out(row_in).argument_name
                  ;
            END IF;
         END;
         
         PROCEDURE push_arg_info (currow IN PLS_INTEGER,
            arg IN OUT VARCHAR2, comp IN OUT VARCHAR2, intab IN OUT BOOLEAN)
         IS
         BEGIN
            PLGstk.push (argseplist_out(currow).data_type || c_delim  || arg || c_delim || comp, c_stack);

            /* Create new argument names by concatenating higher level names. */
            arg := arg_name_val (arg, currow);
            comp := comp_name_val (comp, currow);
            intab :=
               argseplist_out(currow).data_type = 
                  g_datatype_names (PLGdesc.c_indexby_table)
                  /* Current composite is a record. */
               OR
               intab; /* Record inside an index-by table.*/
         END;         

         PROCEDURE pop_arg_info (arg OUT VARCHAR2, comp OUT VARCHAR2, intab OUT BOOLEAN)
         IS
            stkitem PLGadmin.identifier;
         BEGIN
            PLGstk.pop (stkitem, c_stack);
            
            intab :=
               PLGstr.betwn (stkitem, NULL, c_delim, inclusive => FALSE) =
               PLGdesc.c_indexby_table;
               
            arg := PLGstr.betwn (stkitem, c_delim, c_delim, inclusive => FALSE);
            
            comp := PLGstr.betwn (stkitem, c_delim, c_delim, startnth_in => 2,
                  gotoend => TRUE, inclusive => FALSE);
         END;
         
     BEGIN
         IF argcount_inout > 0
         THEN
            PLGstk.make (c_stack);

            /* For each argument... */
            FOR curr_row IN startrow_in .. last_row
            LOOP
               curr_level := argseplist_out(curr_row).data_level;

               /* If the current level is lower than the last level,
                  it indicates that we need to reset values. */

               IF curr_level < last_level
               THEN
                  FOR levdiff IN 1 ..
                     NVL (last_level, curr_level) - curr_level
                  LOOP
                     pop_arg_info (arg_name, comp_name, in_ibtab);
                  END LOOP;
               END IF;

               /* If at level 0 or at end, then end of composite, so mark it. */
               IF (curr_level = 0 AND last_level > 0) OR
                  curr_row = last_row
               THEN
                  arglist_out(save_nonseprow).endseprow :=
                     new_row - SIGN (new_row) * PLGadmin.ifelse (curr_row = last_row, 0, 1);
               END IF;

               IF PLGdesc.based_on_type (argseplist_out(curr_row).data_type)
               THEN
                  set_nonseps (arg_name, TRUE, curr_level);

                  has_comp_inout := TRUE;

                  push_arg_info (curr_row, arg_name, comp_name, in_ibtab);
                  
               ELSE
                  /* Scalar. Move current argument info unchanged to potentially
                     new location. */
                  argseplist_out(new_row) := argseplist_out(curr_row);

                  set_nonseps (arg_name, FALSE, NULL);

                  argseplist_out(new_row).position := curr_row - startrow_in + 1;

                  /* Overwrite with corrected name. */

                  IF argseplist_out(curr_row).argument_name IS NULL
                  THEN
                     /* Upper level was a table or RETURN of function. */
                     argseplist_out(new_row).argument_name := arg_name;
                     argseplist_out(new_row).composite_name := comp_name;
                  ELSE
                     argseplist_out(new_row).argument_name := arg_name_val (arg_name, curr_row);
                     argseplist_out(new_row).composite_name := comp_name_val (arg_name, curr_row);
                  END IF;

                  /* If a column of an index-by table set datatype to VARCHAR2 for later
                     potential list processing. */
                  IF in_ibtab
                  THEN
                     argseplist_out(new_row).data_type := PLGdesc.c_varchar2;
                  END IF;

                  /* No more nesting. */
                  argseplist_out(new_row).data_level := 0;

                  new_row := new_row + 1;
               END IF;

               nonseprow := nonseprow + 1;
               last_level := curr_level;
            END LOOP;

            /* Adjust the program-level settings. */
            endrow_inout :=  new_row - 1;
            argcount_inout := new_row - startrow_in;

            PLGstk.destroy (c_stack);
         END IF;
      END;

      PROCEDURE set_noargs (progrow_in IN PLS_INTEGER)