home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / po7_win / install / makedir.vrf < prev    next >
Text File  |  1995-01-06  |  14KB  |  413 lines
  1. /* Copyright (c) Oracle Corporation 1993.  All Rights Reserved */
  2.  
  3. /*****************************************************************************
  4.   NAME
  5.     makedir.vrf - V3 common checks for valid path name.
  6.  
  7.   DESCRIPTION
  8.     This script requests an absolute directory name until a valid path is
  9.     found.  This directory is created if it does not already exist.  NFS 
  10.     paths are not checked for legal names.  HPFS paths are checked for
  11.     legal HPFS names.  All other paths are checked for legal FAT names.
  12.  
  13.     IN Variables:
  14.       string makedir_default_dir
  15.       string makedir_select_dir_prompt
  16.       string makedir_select_dir_content          (dos/os2 only)
  17.       string makedir_select_dir_help             (dos/os2 only)
  18.         Used in a text dialog to request a directory name.
  19.     If Windows, choose directory dialog is used instead 
  20.     (content & help will not be available).
  21.  
  22.       boolean makedir_root_allowed
  23.         Set to true if '%drive%:\' is considered valid.
  24.  
  25.       boolean makedir_skip_pass
  26.         Set to true means user has already entered a path to check, using
  27.         multiple_text_dialog in calling script, for example.  If unbound,
  28.         default to false.
  29.  
  30.       string makedir_root_message
  31.       string makedir_root_content
  32.       string makedir_root_help
  33.         Used in information dialog if makedir_root_allowed = false and 
  34.     a root path was entered.  The variable %makedir_path_to_check%
  35.     can referred to in these 3 strings to reference the root path
  36.     that was entered.
  37.  
  38.       string list makedir_bad_dir_list
  39.       string list makedir_bad_dir_message_list
  40.       string list makedir_bad_dir_content_list
  41.       string list makedir_bad_dir_help_list
  42.         List of known bad directories and their associated messages.
  43.     These will be checked for and message will be displayed.  Can
  44.     be left unbound (all 4 must be unbound) if empty.  If content
  45.     string is "", then no help is displayed with message.
  46.  
  47.      All of the above strings are instantiated immediately before usage.
  48.     
  49.     RETURNS: string
  50.       The valid directory that was specified.  This directory is
  51.       guaranteed to exist.
  52.     
  53.     NOTE:
  54.      This script uses only variables with prefix 'makedir_'.
  55.      This script requires Installer 3.0.10.1.1 or later.
  56.      This script is shared by OS/2, DOS, and Windows.
  57.  
  58.   MODIFIED   MM/DD/YY REASON
  59.   zzerhoun   12/15/94 Changed to allow to set path_to_check in calling script
  60.   ming       01/13/94 Changed to allow to run under DOS and OS/2.
  61.   ming       01/12/94 Added 'stringsonly to explode calls.
  62.   ming       12/30/93 Created.
  63. *****************************************************************************/
  64.  
  65. {
  66.   { makedir_bad_dir_list = makedir_bad_dir_list; }
  67.   [ 'unbound_variable: 
  68.    { 
  69.      makedir_bad_dir_list = list(); 
  70.      makedir_bad_dir_message_list = list(); 
  71.      makedir_bad_dir_content_list = list();
  72.      makedir_bad_dir_help_list = list();
  73.    } ]
  74.   makedir_old_current_directory = current_directory(); /* need to restore this later */
  75.   makedir_bad_names = list("kbd$","prn","nul","com1","com2","com3","com4","con","clock$",
  76.                "lpt1","lpt2","lpt3","screen$","pointer$","mouse$");
  77.   
  78.   makedir_drives = dos_mapped_drives();
  79.   
  80.   makedir_new_dirs = list();    /* list of directories created by this script */
  81.  
  82.     {
  83.       while (true) 
  84.     {
  85.       makedir_redo = false;
  86.       
  87.       while (not(empty(makedir_new_dirs))) 
  88.         {            /* clean up */
  89.           makedir_new_dir = first(makedir_new_dirs);
  90.           makedir_new_dirs = rest(makedir_new_dirs);
  91.           remove_directory(makedir_new_dir);
  92.         } [ 'default: continue(); ]
  93.       
  94.           makedir_select_dir_prompt_inst = instantiate(makedir_select_dir_prompt);
  95.           makedir_default_dir_inst = instantiate(makedir_default_dir);
  96.  
  97.       {  
  98.             if (not(makedir_skip_pass))
  99.               signal('UNBOUND_VARIABLE);
  100.       }
  101.           ['UNBOUND_VARIABLE:
  102.             {
  103.           makedir_path_to_check = choose_directory_dialog(makedir_select_dir_prompt_inst,
  104.                                                               makedir_default_dir_inst);
  105.               continue();
  106.             }
  107.           ]
  108.  
  109.           makedir_skip_pass = FALSE;
  110.  
  111.       pathify(makedir_path_to_check);
  112.  
  113.       /* check for known bad directories */
  114.       makedir_bad_dirs = makedir_bad_dir_list;
  115.       makedir_bad_dir_messages = makedir_bad_dir_message_list;
  116.       makedir_bad_dir_contents = makedir_bad_dir_content_list;
  117.       makedir_bad_dir_helps = makedir_bad_dir_help_list;
  118.       while (not(empty(makedir_bad_dirs)))
  119.         {
  120.           if (makedir_path_to_check==first(makedir_bad_dirs))
  121.         {
  122.           makedir_bad_dir_contents_inst = instantiate(first(makedir_bad_dir_contents));
  123.           if (makedir_bad_dir_contents_inst=="")
  124.             information_dialog(instantiate(first(makedir_bad_dir_messages)));
  125.           else
  126.             information_dialog(instantiate(first(makedir_bad_dir_messages)),
  127.                        makedir_bad_dir_contents_inst,
  128.                        instantiate(first(makedir_bad_dir_helps)));
  129.           makedir_redo = TRUE;
  130.           break();
  131.         }
  132.           makedir_bad_dirs = rest(makedir_bad_dirs);
  133.           makedir_bad_dir_messages = rest(makedir_bad_dir_messages);
  134.           makedir_bad_dir_contents = rest(makedir_bad_dir_contents);
  135.           makedir_bad_dir_helps = rest(makedir_bad_dir_helps);
  136.         }
  137.       if (makedir_redo)
  138.         continue();
  139.       
  140.       if (not(contains(makedir_path_to_check,":"))) 
  141.         {
  142.           information_dialog(instantiate(makedir_specify_drive));
  143.           continue();    /* no : */
  144.         }
  145.       makedir_drive_path = explode(makedir_path_to_check,":",'stringsonly);
  146.       makedir_drive = first(makedir_drive_path); /* find the drive */
  147.       if (not(member(makedir_drives,makedir_drive))) 
  148.         {
  149.           information_dialog(instantiate(makedir_bad_drive));
  150.           continue();            /* bad drive letter */
  151.         }        
  152.       makedir_path = rest(makedir_drive_path);
  153.       if (empty(makedir_path)) 
  154.         {
  155.           information_dialog(instantiate(makedir_no_dir));
  156.           continue();            /* nothing after : */
  157.         }
  158.       makedir_rest_path = rest(makedir_path);
  159.       if (not(empty(makedir_rest_path))) 
  160.         {
  161.           information_dialog(instantiate(makedir_invalid_path));
  162.           continue();            /* extra : */
  163.         }
  164.       makedir_path = first(makedir_path);
  165.       if (first(explode(makedir_path,"\",true,'stringsonly))!="\") 
  166.         {
  167.           information_dialog(instantiate(makedir_absolute_path));
  168.           continue();            /* not absolute path */
  169.         }
  170.       
  171.       {
  172.         makedir_fstype = dos_file_system_type("%makedir_drive%:");
  173.       } ['default: makedir_fstype = 'fat; ]
  174.       /* assume FAT if not disk not accessible - probably floppy */
  175.       if ((makedir_fstype!='nfs) || (makedir_fstype!='ntnf)) 
  176.         {
  177.           makedir_bad_chars = list("*","?","<",">","|",",","+","=","[","]",";","&","-");
  178.           while (not(empty(makedir_bad_chars))) 
  179.         {                /* check for illegal characters */
  180.           makedir_bad_char = first(makedir_bad_chars);
  181.           makedir_bad_chars = rest(makedir_bad_chars);
  182.           if (contains(makedir_path,makedir_bad_char)) 
  183.             {
  184.               information_dialog(instantiate(makedir_illegal_char));
  185.               makedir_redo = true;
  186.               break();
  187.             } 
  188.         }
  189.           if (makedir_redo) 
  190.         continue();
  191.         }
  192.       
  193.       if (contains(makedir_path,"\\")) 
  194.         {
  195.           information_dialog(instantiate(makedir_invalid_path));
  196.           continue();
  197.         }
  198.       
  199.  
  200.       makedir_names = explode(makedir_path,"\",'stringsonly);
  201.       
  202.       if (empty(makedir_names)) 
  203.         {
  204.           { 
  205.         makedir_root_allowed = makedir_root_allowed; 
  206.           } [ 'unbound_variable: makedir_root_allowed = false; ]
  207.           if (not(makedir_root_allowed)) 
  208.         {
  209.           information_dialog(instantiate(makedir_root_message), 
  210.                      instantiate(makedir_root_content),
  211.                      instantiate(makedir_root_help));
  212.           continue();            /* case of d:\ */
  213.         }
  214.         } 
  215.       else 
  216.         {
  217.           makedir_current_path = "%makedir_drive%:";
  218.           change_directory(makedir_current_path);
  219.           
  220.           /* check for bad names */
  221.           if ((makedir_fstype=='hpfs) || (makedir_fstype=='ntfs)) 
  222.         while (not(empty(makedir_names))) 
  223.           {
  224.             makedir_name = first(makedir_names);
  225.             makedir_names = rest(makedir_names);
  226.             if ((length(makedir_name)>254)) 
  227.               {
  228.             information_dialog(instantiate(makedir_name_too_long));
  229.             makedir_redo = true;        /* too long */
  230.             break();
  231.               }
  232.             if (member(makedir_bad_names,makedir_name)) 
  233.               {
  234.             information_dialog(instantiate(makedir_illegal_name));
  235.             makedir_redo = true;        /* illegal name */
  236.             break();
  237.               }
  238.             makedir_current_path = "%makedir_current_path%\%makedir_name%";
  239.             
  240.             {
  241.               makedir_exists = exists(makedir_current_path);
  242.             } [ 'default: 
  243.                {
  244.              information_dialog(instantiate(makedir_invalid_path));
  245.              makedir_redo = true;        /* can't check existence */
  246.              break();
  247.                } ]
  248.             
  249.             if (makedir_exists) 
  250.               {
  251.             {
  252.               change_directory(makedir_current_path);
  253.             } [ 'default(makedir_signal):
  254.                { 
  255.                  information_dialog(instantiate(makedir_dir_not_accessible));
  256.                  makedir_redo = true;
  257.                  break();
  258.                } ]
  259.               } 
  260.             else 
  261.               {
  262.             {
  263.               make_directory(makedir_current_path);
  264.               if (not(exists(makedir_current_path)))
  265.                 signal('make_directory_failure,"Can't make directory '%makedir_current_path%'.");
  266.               makedir_new_dirs = cons(makedir_current_path,makedir_new_dirs);
  267.             } [ 'default(makedir_signal): 
  268.                { 
  269.                  information_dialog(instantiate(makedir_cant_create_dir));
  270.                  makedir_redo = true; 
  271.                  break(); 
  272.                } ]
  273.               }
  274.           }
  275.           else if ((makedir_fstype=='nfs) || (makedir_fstype=='ntnf)) 
  276.         while (not(empty(makedir_names))) 
  277.           {
  278.             makedir_name = first(makedir_names); /* find last name */
  279.             makedir_names = rest(makedir_names);
  280.             makedir_current_path = "%makedir_current_path%\%makedir_name%";
  281.             {
  282.               makedir_exists = exists(makedir_current_path);
  283.             } [ 'default: 
  284.                {
  285.              information_dialog(instantiate(makedir_invalid_path));
  286.              makedir_redo = true;        /* can't check existence */
  287.              break();
  288.                } ]
  289.             
  290.             if (makedir_exists) 
  291.               {
  292.             {
  293.               change_directory(makedir_current_path);
  294.             } [ 'default(makedir_signal):
  295.                { 
  296.                  information_dialog(instantiate(makedir_dir_not_accessible));
  297.                  makedir_redo = true;
  298.                  break();
  299.                } ]
  300.               } 
  301.             else 
  302.               {
  303.             {
  304.               make_directory(makedir_current_path);
  305.               if (not(exists(makedir_current_path)))
  306.                 signal('make_directory_failure,"Can't make directory '%makedir_current_path%'.");
  307.               makedir_new_dirs = cons(makedir_current_path,makedir_new_dirs);
  308.             } [ 'default(makedir_signal): 
  309.                { 
  310.                  information_dialog(instantiate(makedir_cant_create_dir));
  311.                  makedir_redo = true; 
  312.                  break(); 
  313.                } ]
  314.               }
  315.           }
  316.           else /* FAT */
  317.         while (not(empty(makedir_names))) 
  318.           {
  319.             makedir_name = first(makedir_names);
  320.             makedir_names = rest(makedir_names);
  321.             if (member(makedir_bad_names,makedir_name)) 
  322.               {
  323.             information_dialog(instantiate(makedir_illegal_name));
  324.             makedir_redo = true;        /* illegal name */
  325.             break();
  326.               }
  327.             if (count(makedir_name,".")>1) 
  328.               {
  329.             information_dialog(instantiate(makedir_illegal_name));
  330.             makedir_redo = true;        /* too many .'s */
  331.             break();
  332.               }
  333.             makedir_base_ext = explode(makedir_name,".",'stringsonly);
  334.             makedir_base = first(makedir_base_ext);
  335.             if (length(makedir_base)>8) 
  336.               {
  337.             information_dialog(instantiate(makedir_long_basename));
  338.             makedir_redo = true;        /* basename too long */
  339.             break();
  340.               }      
  341.             makedir__ext = rest(makedir_base_ext);
  342.             if (not(empty(makedir__ext))) 
  343.               {                /* has extension - check it */
  344.             makedir_ext = first(makedir__ext);
  345.             if (length(makedir_ext)>3) 
  346.               {
  347.                 information_dialog(instantiate(makedir_long_extension));
  348.                 makedir_redo = true;        /* extension too long */
  349.                 break();
  350.               }      
  351.               }
  352.             makedir_current_path = "%makedir_current_path%\%makedir_name%";
  353.             {
  354.               makedir_exists = exists(makedir_current_path);
  355.             } [ 'default: 
  356.                {
  357.              information_dialog(instantiate(makedir_invalid_path));
  358.              makedir_redo = true;        /* can't check existence */
  359.              break();
  360.                } ]
  361.             
  362.             if (makedir_exists) 
  363.               {
  364.             {
  365.               change_directory(makedir_current_path);
  366.             } [ 'default(makedir_signal):
  367.                { 
  368.                  information_dialog(instantiate(makedir_dir_not_accessible));
  369.                  makedir_redo = true;
  370.                  break();
  371.                } ]
  372.               } 
  373.             else 
  374.               {
  375.             {
  376.               make_directory(makedir_current_path);
  377.               if (not(exists(makedir_current_path)))
  378.                 signal('make_directory_failure,"Can't make directory '%makedir_current_path%'.");
  379.               makedir_new_dirs = cons(makedir_current_path,makedir_new_dirs);
  380.             } [ 'default(makedir_signal): 
  381.                { 
  382.                  information_dialog(instantiate(makedir_cant_create_dir));
  383.                  makedir_redo = true; 
  384.                  break(); 
  385.                } ]
  386.               }
  387.           }
  388.           if (makedir_redo)
  389.         continue();
  390.           
  391.           /* reject if last name contains tabs or final white space */
  392.           if (implode(explode(makedir_name,'stringsonly))!=makedir_name) 
  393.         {
  394.           information_dialog(instantiate(makedir_has_white_space));
  395.           continue();
  396.         }
  397.         }
  398.       change_directory(makedir_old_current_directory);
  399.       return(makedir_path_to_check);
  400.     }
  401.     } [ 'default(uncaught_signal, uncaught_signal_message): 
  402.        {
  403.      while (not(empty(makedir_new_dirs))) 
  404.        {
  405.          makedir_new_dir = first(makedir_new_dirs);
  406.          makedir_new_dirs = rest(makedir_new_dirs);
  407.          remove_directory(makedir_new_dir);
  408.        } [ 'default: continue(); ]
  409.      change_directory(makedir_old_current_directory);
  410.      signal(uncaught_signal, uncaught_signal_message);
  411.        } ]
  412. }
  413.