plgadmin.spb

Oracle PL/SQL procedure generator (second generator type)

      compile (v_program, show_err_in, add_cor, schema_in);

   EXCEPTION
      WHEN OTHERS
      THEN
         DBMS_OUTPUT.PUT_LINE ('Error compiling contents of file ' || file_in || ' ' || SQLERRM);
   END;

   FUNCTION version RETURN VARCHAR2
   IS
   BEGIN
      RETURN g_version;
   END;

   FUNCTION is_trial_version RETURN BOOLEAN
   IS
   BEGIN
      RETURN version LIKE c_trial || '%';
   END;

   PROCEDURE set_version (vrsn IN VARCHAR2, pwd IN VARCHAR2)
   IS
   BEGIN
      IF pwd = 'el1silv2'
      THEN
         g_version := vrsn;
      END IF;
   END;
   
   FUNCTION oraversion RETURN VARCHAR2
   IS
      retval VARCHAR2(100);
   BEGIN
      SELECT SUBSTR (version,1,3) col
        INTO retval
        FROM product_component_version
       WHERE ROWNUM < 2
         AND (UPPER(product) LIKE 'ORACLE7%'
          OR UPPER(product) LIKE 'PERSONAL ORACLE%'
          OR UPPER(product) LIKE 'ORACLE8%');
      RETURN retval;
   EXCEPTION
      WHEN NO_DATA_FOUND THEN RETURN NULL;
   END;
   
   FUNCTION max_cgml_lines RETURN PLS_INTEGER
   IS
   BEGIN
      RETURN 50;
   END;

   FUNCTION max_gen_lines RETURN PLS_INTEGER
   IS
   BEGIN
      RETURN 100;
   END;

   PROCEDURE check_trial_gen_limit (
      drv IN VARCHAR2, line IN PLS_INTEGER)
   IS
   BEGIN
      /* Table Encapsulation has different trial limitation. */
      IF PLGgenv.genrec.driver != PLGte.driver
         AND
         line > max_gen_lines
         AND
         is_trial_version
      THEN
         PLGerr.raise (PLGerr.trial_limit_exceeded,
            'Trial limitation of ' || max_gen_lines || 
            ' generated lines exceeded');
      END IF;
   END;

   PROCEDURE check_trial_cgml_limit (
      drv IN VARCHAR2, line IN PLS_INTEGER)
   IS
   BEGIN
      /* Table Encapsulation has different trial limitation. */
      IF PLGgenv.genrec.driver != PLGte.driver
         AND
         is_trial_version
         AND
         line > max_cgml_lines
      THEN
         PLGerr.raise (PLGerr.trial_limit_exceeded,
            'Trial limitation of ' || max_cgml_lines || 
            ' cgml script lines exceeded');
      END IF;
   END;

   FUNCTION surrounded 
      (string_in IN VARCHAR2, char_in IN VARCHAR2, trimchar IN BOOLEAN := TRUE)
      RETURN VARCHAR2
   IS
   BEGIN
      IF trimchar 
      THEN
         RETURN (char_in || LTRIM (RTRIM (string_in, char_in), char_in) || 
             char_in);         
      ELSE
         RETURN (char_in || string_in || char_in);         
      END IF;
   END;

   FUNCTION isboolean (stg_in IN VARCHAR2) RETURN BOOLEAN IS
   BEGIN
      RETURN UPPER (stg_in) = 'BOOLEAN';
   END;

   FUNCTION isdate (stg_in IN VARCHAR2) RETURN BOOLEAN 
   IS
   BEGIN
      RETURN UPPER (stg_in) = 'DATE';
   END;

   FUNCTION isnumber (stg_in IN VARCHAR2) RETURN BOOLEAN 
   IS
      v_paren INTEGER := INSTR (stg_in, '(');
      v_stg identifier := UPPER (stg_in);
   BEGIN
      v_stg := ifelse (v_paren = 0, v_stg, 
         PLGstr.betwn (v_stg, 1, v_paren-1));
      RETURN 
         (v_stg IN ('NUMBER', 
          'FLOAT', 'DECIMAL', 'INTEGER', 'POSITIVE', 'BINARY_INTEGER', 'PLS_INTEGER'));
   END;

   FUNCTION isvarchar2 (stg_in IN VARCHAR2) RETURN BOOLEAN 
   IS
      v_paren INTEGER := INSTR (stg_in, '(');
      v_stg identifier := UPPER (stg_in);
   BEGIN
      v_stg := ifelse (v_paren = 0, v_stg, 
         PLGstr.betwn (v_stg, 1, v_paren-1));
      RETURN (v_stg = 'VARCHAR2');
   END;


/* Decryption Program */

   PROCEDURE do_encryption IS BEGIN g_do_encryption := TRUE; END;
   PROCEDURE nodo_encryption IS BEGIN g_do_encryption := FALSE; END;
   FUNCTION doing_encryption RETURN BOOLEAN IS BEGIN RETURN g_do_encryption; END;

   /* Confusion any effort to decrypt... */
   FUNCTION mymod (top IN PLS_INTEGER, bot IN PLS_INTEGER) RETURN PLS_INTEGER
   IS
      int PLS_INTEGER;
   BEGIN
      int := top / bot;
      RETURN top - int * bot;
   END;

   FUNCTION decrypt (text IN VARCHAR2) RETURN VARCHAR2
   IS
      decrypted_text PLGadmin.maxvc2 := NULL;
   BEGIN
      IF doing_encryption
      THEN
         FOR i IN 1..NVL (LENGTH (text), 0)
         LOOP
            decrypted_text := decrypted_text ||
               CHR (MOD /*mymod*/ (ASCII (SUBSTR (text, i, 1)) + c_encryp_size - i, c_encryp_size));
         END LOOP;
      ELSE
         decrypted_text := text;
      END IF;
      RETURN decrypted_text;
   END;

   FUNCTION encrypt (text IN VARCHAR2) RETURN VARCHAR2
   IS
      encrypted_text PLGadmin.maxvc2 := NULL;
   BEGIN
      FOR i IN 1..NVL (LENGTH (text), 0)
      LOOP
         encrypted_text := encrypted_text ||
            CHR (MOD /*mymod*/ (ASCII (SUBSTR (text, i, 1)) + i, c_encryp_size));
      END LOOP;
      RETURN encrypted_text;
   END;

   PROCEDURE encrypt_file
      (from_dir IN VARCHAR2,
       fr_file IN VARCHAR2,
       to_dir IN VARCHAR2,
       to_file IN VARCHAR2)
   IS
      from_handle utl_file.file_type;
      to_handle utl_file.file_type;
      buffer PLGadmin.maxvc2;

      PROCEDURE closeall
      IS
      BEGIN
         IF utl_file.is_open (from_handle)
         THEN
            utl_file.fclose  (from_handle);
         END IF;
         IF utl_file.is_open (to_handle)
         THEN
            utl_file.fclose  (to_handle);
         END IF;
      END;

      PROCEDURE recNgo (str IN VARCHAR2)
      IS
      BEGIN
         closeall;
         DBMS_OUTPUT.PUT_LINE (
            'Error encrypting ' || from_dir || '\' || fr_file || ': ' || str);
      END;
   BEGIN
      from_handle := UTL_FILE.FOPEN (from_dir, fr_file, 'r');
      to_handle := UTL_FILE.FOPEN (to_dir, to_file, 'w');
      UTL_FILE.PUT_LINE  (to_handle, c_encrypted);
      LOOP
         UTL_FILE.GET_LINE  (from_handle, buffer);
         IF LTRIM (buffer) NOT LIKE PLGgen.c_comment OR
            LTRIM (buffer) IS NULL
         THEN
            UTL_FILE.PUT_LINE  (to_handle, encrypt (buffer));
         END IF;
      END LOOP;
      closeall;
   EXCEPTION
      WHEN NO_DATA_FOUND
      THEN
         closeall;
      WHEN UTL_FILE.INVALID_PATH
       THEN recNgo ('c_invalid_path');
      WHEN UTL_FILE.INVALID_MODE
       THEN recNgo ('c_invalid_mode');
      WHEN UTL_FILE.INVALID_FILEHANDLE
       THEN recNgo ('c_invalid_filehandle');
      WHEN UTL_FILE.INVALID_OPERATION
       THEN recNgo ('c_invalid_operation');
      WHEN UTL_FILE.READ_ERROR
       THEN recNgo ('c_read_error');
      WHEN UTL_FILE.WRITE_ERROR
       THEN recNgo ('c_write_error');
      WHEN UTL_FILE.INTERNAL_ERROR
       THEN recNgo ('c_internal_error');
      WHEN OTHERS
       THEN recNgo (SQLCODE);
   END;

   PROCEDURE encrypt_driver (
      driver IN VARCHAR2
      )
   IS
      v_filenum PLS_INTEGER;
      v_tfile PLGdoir.drvrec_t;
      v_drvdir PLGadmin.dbmaxvc2 :=
         PLGdoir.drvdir (
            driver,
            PLGdoir.c_global,
            PLGdoir.c_global
            );
   BEGIN
      v_filenum := 1;
      LOOP
         v_tfile := PLGdoir.drvsrc (
            driver,
            v_filenum,
            PLGdoir.c_global,
            PLGdoir.c_global);
         EXIT WHEN v_tfile.fname IS NULL;
         IF NOT PLGdoir.ishtmlsrc (v_tfile.ftype) AND
              -- Reinstated. Problem with encryption and then insert into the database.
            /*NOT PLGdoir.ishtmlsrc (v_tfile.ftype) AND*/ -- 9/98 O8 bug removed
            NOT PLGdoir.iscustsrc (v_tfile.ftype) AND
            NOT PLGdoir.ishdrsrc (v_tfile.ftype)
         THEN
            encrypt_file (
               v_drvdir,
               v_tfile.fname,
               v_drvdir,
               v_tfile.fname || '.edr'
               );
         END IF;
         v_filenum := v_filenum + 1;
      END LOOP;
   END;

   FUNCTION genXowner RETURN VARCHAR2
   IS
      srcrec PLGdoir.src_rectype;
   BEGIN
      /* Logic here drawn from PLGcgml.spb definition of this entry. */
      srcrec := PLGdoir.srcinfo (PLGdoir.c_global, 'GENXOWNER');
      RETURN TRANSLATE (srcrec.plsql_command, '%''', '%');
   END;

END PLGadmin;
/