plgdesc.spb

Oracle PL/SQL procedure generator (second generator type)

      IS
      BEGIN
         progsep_out(progrow_in).argcount := 0;
         progsep_out(progrow_in).startrow := NULL;
         progsep_out(progrow_in).endrow := NULL;
      END;

      PROCEDURE move_return_arguments (
         progrow_in IN INTEGER
         )
      IS
         new_start PLS_INTEGER :=
            PLGofst.shifted (progrow_in, c_prog_max, 1, PLGofst.c_first);

         curr_row PLS_INTEGER := progsep_out(progrow_in).startrow;

         new_row PLS_INTEGER := new_start;

      BEGIN
         /* Scan through the arguments. Everything from the first level 0
            to the second level 0 is the return argument. */

         LOOP
            /* Move the first, then see if we need to continue. */
            argseplist_out(new_row) := argseplist_out(curr_row);

            new_row := new_row + 1;
            curr_row := curr_row + 1;

            EXIT WHEN
               curr_row > progsep_out(progrow_in).endrow
               OR
               argseplist_out(curr_row).data_level = 0;
         END LOOP;

         /* Set return row information */
         progsep_out(progrow_in).ret_startrow := new_start;
         progsep_out(progrow_in).ret_argcount := ABS (new_row - new_start);
         progsep_out(progrow_in).ret_endrow := new_row - 1;


         /* Change start row and number of args. */
         IF curr_row = progsep_out(progrow_in).endrow + 1
         THEN
            /* No other arguments. */
            set_noargs (progrow_in);
            progsep_out(progrow_in).nonsepnonretstartrow := NULL;
         ELSE
            progsep_out(progrow_in).startrow := curr_row;

            progsep_out(progrow_in).argcount :=
               progsep_out(progrow_in).argcount -
               progsep_out(progrow_in).ret_argcount;

            /* Mark starting point on non-return arguments in original prog list. */
            progsep_out(progrow_in).nonsepnonretstartrow :=
               progsep_out(progrow_in).nonsepstartrow +
               progsep_out(progrow_in).ret_argcount;
         END IF;
      END;

   BEGIN
      FOR progind IN progsep_out.FIRST .. progsep_out.LAST
      LOOP
         IF progsep_out(progind).progtype = 'FUNCTION'
         THEN
            move_return_arguments (progind);

            remove_composites (
               progind,
               progsep_out(progind).ret_startrow,
               progsep_out(progind).ret_endrow,
               progsep_out(progind).ret_argcount,
               progsep_out(progind).ret_has_composite,
               progsep_out(progind).nonsepstartrow
               );
         END IF;

         remove_composites (
            progind,
            progsep_out(progind).startrow,
            progsep_out(progind).endrow,
            progsep_out(progind).argcount,
            progsep_out(progind).has_composite_arg,
            progsep_out(progind).nonsepnonretstartrow
            );
      END LOOP;
   END;

   PROCEDURE showprogs (
      prog_in IN prog_tt
      )
   IS
      v_row PLS_INTEGER := prog_in.FIRST;
   BEGIN
      DBMS_OUTPUT.PUT_LINE (
         '*** Showing Program Information');

      LOOP
         EXIT WHEN v_row IS NULL;

         /* Show "header" program information. */
         DBMS_OUTPUT.PUT_LINE (
            'Name-Type-Datatype-Overload-Overloaded: ' || 
            prog_in(v_row).progname || '-' ||
            prog_in(v_row).progtype || '-' ||
            prog_in(v_row).ret_data_type || '-' ||
            prog_in(v_row).overload || '-' ||
            PLGbool.stg (prog_in(v_row).isoverloaded));
         DBMS_OUTPUT.PUT_LINE (
            '   Start-end-num Arg: ' ||
               prog_in(v_row).startrow || '-' ||
               prog_in(v_row).endrow || '-' ||
               prog_in(v_row).argcount);
         DBMS_OUTPUT.PUT_LINE (
            '   RET start-end-num Arg: ' ||
               prog_in(v_row).ret_startrow || '-' ||
               prog_in(v_row).ret_endrow || '-' ||
               prog_in(v_row).ret_argcount);
         v_row := prog_in.NEXT (v_row);
      END LOOP;
   END;
   
   PROCEDURE showprogs (
      prog_in IN prog_tt,
      args_in IN arglist_tt,
      progsep_in IN progsep_tt,
      argsep_in IN arglist_tt,
      progstart IN PLS_INTEGER := NULL,
      progend IN PLS_INTEGER := NULL,
      argstart IN PLS_INTEGER := NULL,
      argend IN PLS_INTEGER := NULL
      )
   IS
      v_start PLS_INTEGER := NVL (progstart, prog_in.FIRST);
      v_row PLS_INTEGER := NVL (progstart, prog_in.FIRST);
      v_end PLS_INTEGER := NVL (progend, prog_in.LAST);
      v_datatype PLGadmin.identifier;
      v_ovld PLS_INTEGER := NULL;
                                                  
   BEGIN
      DBMS_OUTPUT.PUT_LINE (
         '*** Showing Program and Argument Information');

      LOOP
         EXIT WHEN v_row IS NULL OR v_row > v_end;

         /* Show "header" program information. */
         DBMS_OUTPUT.PUT_LINE (
            'Name-Overloaded: ' || prog_in(v_row).progname || '-' ||
               PLGbool.stg (prog_in(v_row).isoverloaded));
         DBMS_OUTPUT.PUT_LINE (
            'Start-End SepProg: ' ||
               prog_in(v_row).startseprow || '-' ||
               prog_in(v_row).endseprow);
         DBMS_OUTPUT.PUT_LINE (
            'Start-end-num Arg: ' ||
               prog_in(v_row).startrow || '-' ||
               prog_in(v_row).endrow || '-' ||
               prog_in(v_row).argcount);

         IF prog_in(v_row).argcount > 0
         THEN
            v_ovld := NULL;
            DBMS_OUTPUT.PUT_LINE ('*** Unseparated Parameters...');
            showhdr;
            FOR argrow IN prog_in(v_row).startrow .. prog_in(v_row).endrow
            LOOP
               showarg (args_in(argrow), v_ovld, argrow);
            END LOOP;
         END IF;

         FOR sepind IN prog_in(v_row).startseprow .. prog_in(v_row).endseprow
         LOOP
            /* Display separated program information. */

            IF RTRIM (progsep_in(sepind).data_type) IS NULL
            THEN
               v_datatype := 'N/A';
            ELSE
               v_datatype := PLGdesc.g_datatype_names(progsep_in(sepind).data_type);
            END IF;

            DBMS_OUTPUT.PUT_LINE (
               '   Overload-Type-Datatype-NonSepRow: ' ||
                  progsep_in(sepind).overload || '-' ||
                  progsep_in(sepind).progtype || '-' ||
                  v_datatype || '-' ||
                  progsep_in(sepind).nonseprow
                  );
            DBMS_OUTPUT.PUT_LINE (
               '   Composite Arg-RETURN: ' ||
                  PLGbool.stg (progsep_in(sepind).has_composite_arg) || '-' ||
                  PLGbool.stg (progsep_in(sepind).ret_has_composite)
                  );
            DBMS_OUTPUT.PUT_LINE (
               '   Start-end-num Arg: ' ||
                  progsep_in(sepind).startrow || '-' ||
                  progsep_in(sepind).endrow || '-' ||
                  progsep_in(sepind).argcount
                  );
            DBMS_OUTPUT.PUT_LINE (
               '   Start-NonRet-end-num NonSepArg: ' ||
                  progsep_in(sepind).nonsepstartrow || '-' ||
                  progsep_in(sepind).nonsepnonretstartrow || '-' ||
                  progsep_in(sepind).nonsependrow || '-' ||
                  progsep_in(sepind).nonsepargcount
                  );
            DBMS_OUTPUT.PUT_LINE (
               '   Start-end-num RETURN: ' ||
                  progsep_in(sepind).ret_startrow || '-' ||
                  progsep_in(sepind).ret_endrow || '-' ||
                  progsep_in(sepind).ret_argcount
               );

            IF progsep_in(sepind).argcount > 0
            THEN
               v_ovld := NULL;
               DBMS_OUTPUT.PUT_LINE ('Separated Parameters...');
               showhdr (3);
               FOR argrow IN progsep_in(sepind).startrow .. progsep_in(sepind).endrow
               LOOP
                  showarg (argsep_in(argrow), v_ovld, argrow, 3);
               END LOOP;
            END IF;

            IF progsep_in(sepind).ret_argcount > 0
            THEN
               v_ovld := NULL;
               DBMS_OUTPUT.PUT_LINE ('RETURN Arguments...');
               showhdr (3);
               FOR argrow IN progsep_in(sepind).ret_startrow .. 
                  progsep_in(sepind).ret_endrow
               LOOP
                  showarg (argsep_in(argrow), v_ovld, argrow, 3);
               END LOOP;
            END IF;

         END LOOP;

         v_row := prog_in.NEXT (v_row);
      END LOOP;
   END;

   FUNCTION based_on_type (dtype IN INTEGER) RETURN BOOLEAN
   IS
   BEGIN
      RETURN (dtype IN (
         c_record,
         c_indexby_table,
         c_nested_table,
         c_object_type,
         c_varray,
         c_ref,
         c_ref_cursor
         ));
   END;

   FUNCTION based_on_type (dtype IN VARCHAR2) RETURN BOOLEAN
   IS
   BEGIN
      RETURN (dtype IN (
         g_datatype_names (c_record),
         g_datatype_names (c_indexby_table),
         g_datatype_names (c_nested_table),
         g_datatype_names (c_object_type),
         g_datatype_names (c_varray),
         g_datatype_names (c_ref),
         g_datatype_names (c_ref_cursor)
         ));
   END;


BEGIN
   /* Initialize the two "translation" arrays. */
   g_datatype_names (c_varchar2) := 'VARCHAR2';
   g_datatype_names (c_number) := 'NUMBER';
   g_datatype_names (c_integer) := 'NATIVE INTEGER';
   g_datatype_names (c_binary_integer) := 'BINARY_INTEGER';
   g_datatype_names (c_long) := 'LONG';
   g_datatype_names (c_rowid) := 'ROWID';
   g_datatype_names (c_date) := 'DATE';
   g_datatype_names (c_raw) := 'RAW';
   g_datatype_names (c_longraw) := 'LONGRAW';
   g_datatype_names (c_char) := 'CHAR';
   g_datatype_names (c_mlslabel) := 'MLSLABEL';
   g_datatype_names (c_record) := 'PL/SQL RECORD';
   g_datatype_names (c_indexby_table) := 'PL/SQL TABLE';
   g_datatype_names (c_boolean) := 'PL/SQL BOOLEAN';
   g_datatype_names (c_object_type) := 'OBJECT';
   g_datatype_names (c_nested_table) := 'TABLE';
   g_datatype_names (c_varray) := 'VARRAY';
   g_datatype_names (c_clob) := 'CLOB';
   g_datatype_names (c_blob) := 'BLOB';
   g_datatype_names (c_bfile) := 'BFILE';
   g_datatype_names (c_cfile) := 'CFILE';
   g_datatype_names (c_varchar) := 'VARCHAR';
   g_datatype_names (c_crowid) := 'CROWID';
   g_datatype_names (c_ref_cursor) := 'REF CURSOR';
   g_datatype_names (c_ref) := 'REF';
   g_datatype_names (0) := 'no parms';

   g_mode_names (c_in) := 'IN';
   g_mode_names (c_out) := 'OUT';
   g_mode_names (c_inout) := 'IN OUT';
END PLGdesc;
/

-- End of DDL script for PLGDESC