home *** CD-ROM | disk | FTP | other *** search
/ C/C++ User's Journal & Wi…eveloper's Journal Tools / C-C__Users_Journal_and_Windows_Developers_Journal_Tools_1997.iso / smxdemo / file / fdemo.c next >
Encoding:
C/C++ Source or Header  |  1993-05-25  |  55.2 KB  |  1,627 lines
  1. /*
  2. * FDEMO.C                                                   Version 2.31
  3. *
  4. * FILEdemo module. Contains code to demonstrate use of smx with smxFile.
  5. *
  6. * Copyright (c) 1993 Micro Digital Associates, Inc. 
  7. *               All Rights Reserved.
  8. *
  9. * Author: Peter Van Oudenaren
  10. *
  11. ***********************************************************************/
  12.  
  13. #define SMX_HEAPS 1
  14.  
  15. #include    "conf.h"
  16. #include    "core.h"
  17. #include    "xmwin.h"
  18. #include    "fdemo.h"
  19. #include    <xfile.h>  /* Also brings in fconf.h */
  20. #include    <stdio.h>  /* Included only for the dos test in xfd_read_test_main */
  21. #include    <fcntl.h>  /* Included only for the dos test in xfd_read_test_main */
  22. //#include    <io.h>     /* Included only for the dos test in xfd_read_test_main */
  23. #include    <conio.h>  /* For prototype of inp and outp */
  24. #include    <time.h>
  25.  
  26. /* function prototypes */
  27.  
  28. #if __cplusplus
  29.  extern "C" {
  30. #endif
  31.  
  32. /* demo tasks */
  33. void _cdecl xfd_cscan_main(void);
  34. void _cdecl xfd_seek_test_main(void);
  35. void _cdecl xfd_read_test_main(void);
  36. void _cdecl xfd_write_test_main(void);
  37. void _cdecl xfd_ascan_main(void);
  38. void _cdecl xfd_prompt_main(void);
  39.  
  40. /* demo task helpers */
  41. void mkname(char *buffer, DSTAT *pstat);
  42. void xfd_write_status(int line, char *message);
  43. void xfd_write_purge(char *subdir);
  44. BOOL xfd_write_rmdir(char *subdir);
  45. void xfd_write_make_files(char *subdir);
  46. void xfd_write_rename_files(char *subdir);
  47. BOOLEAN ram_disk_init(void);
  48. void prompt(int goto_sleep,char *p0, char *p1,char *p2, char *p3, char *p4);
  49. void draw_title(XMWIN_PTR win, char * title, char * buffer);
  50.  
  51. /* control functions */
  52. void _cdecl opcon_main(void);
  53. void create_demo_menu(void);
  54. void command_dispatch(int command);
  55. void set_devtable(void);
  56. void  fdemo_suspend_me(int do_signal);
  57. void _cdecl xfd_error(char *p);
  58.  
  59. /* miscellaneous */
  60. void _cdecl appl_init(void);
  61. char * _cdecl ltoa(long, char *, int);
  62. void _cdecl quit_appl(void);
  63. extern int rand();
  64. void _cdecl show_etime(void);
  65. void swap_screen(void);
  66.  
  67. #if __cplusplus
  68. }
  69. #endif
  70.  
  71. /* variables */
  72.  
  73. unsigned char FGCOLOR;
  74. unsigned char BGCOLOR;
  75. unsigned char MENU_FG;
  76. unsigned char MENU_BG;
  77. unsigned char MENU_GREYED_FG;
  78. unsigned char MENU_GREYED_BG;
  79. unsigned char MENU_HIGH_FG;
  80. unsigned char MENU_HIGH_BG;
  81.  
  82. /* Room to control 10 tasks increase it if needed */
  83. #define MAXDEMOTASKS 5
  84. typedef struct _demo_control {
  85.     TCB_PTR p_task;         /* Task handle */
  86.     char *pause_menu;       /* Menu strings */
  87.     char *resume_menu;
  88.     XMWIN_PTR window;
  89.     /* Flags. Add to these as we need them */
  90.     word    suspended;
  91. } _DEMO_CONTROL;
  92. _DEMO_CONTROL demo_control[MAXDEMOTASKS];
  93. /* Indeces into the above table */
  94. #define DEMO_TASK_CSCAN     0
  95. #define DEMO_TASK_SEEK      1
  96. #define DEMO_TASK_READ      2
  97. #define DEMO_TASK_WRITE     3
  98. #define DEMO_TASK_ASCAN     4
  99.  
  100. XCB_PTR     free_msgs;
  101.  
  102. /* Tasks for the demo */
  103. TCB_PTR     opcon;         /* operation control task (for kbd) */
  104. TCB_PTR xfd_cscan_tcb;     /* Scans the c drive */
  105. TCB_PTR xfd_seek_tcb;      /* Seeks and reads a file on the c drive */
  106. TCB_PTR xfd_read_tcb;      /* Fast reads a file on the c drive */
  107. TCB_PTR xfd_write_tcb;     /* creates/removes files and dirs on a: or ramdisk */
  108. TCB_PTR xfd_ascan_tcb;     /* Scans the a or ram disk */
  109. TCB_PTR xfd_prompt_tcb;    /* Prints friendly mesages */
  110.  
  111. TCB_PTR suspend_this_task; /* If true this task should be suspend next time it
  112.                               exits and unlocks the screen. */
  113.  
  114. /* Windows */
  115. XMWIN_PTR xfd_appl_win   = 0;
  116. XMWIN_PTR xfd_cscan_win  = 0;
  117. XMWIN_PTR xfd_seek_win   = 0;
  118. XMWIN_PTR xfd_read_win   = 0;
  119. XMWIN_PTR xfd_write_win  = 0;
  120. XMWIN_PTR xfd_ascan_win  = 0;
  121. XMWIN_PTR xfd_prompt_win  = 0;
  122.  
  123. /* Window titles */
  124. char * xfd_cscan_df_title  = "SCANNING HARD DRIVE";
  125. char * xfd_seek_df_title   = "SEEK & READ      ";
  126. char * xfd_read_df_title   = "SEQ. READS/10K BUFFER - Suspend other Tasks For Speed";
  127. char * xfd_write_df_title  = "FLOPPY WRITE     ";
  128. char * xfd_ascan_df_title  = "SCANNING FLOPPY  ";
  129.  
  130. /* User help */
  131. unsigned char * non_menu_u_prompt   = "esc to Exit, F1, F2, F3 for menus     ";
  132.                        /* 030 et all are arrow chars */
  133. unsigned char * menu_u_prompt = "\030 \031 \032 \032 Move, ^cr selects, esc cancels";
  134.  
  135. /* Colors */
  136.  
  137. /* Disk info */
  138. char *hd_drive_id  = "C:";
  139. char *fd_drive_id = "A:";
  140.  
  141. static char largest_f_path[EMAXPATH];
  142. unsigned long largest_f_size;
  143.  
  144. /* DEBUGGING AIDS
  145.     These can be sent on the command line */
  146. /* If true use semaphores to control access to the file system otherwise
  147.    use process locks  */
  148. BOOLEAN use_fs_sem =   FALSE;
  149. /* If this is true we copy the bios entry points in to the devtable */
  150. BOOLEAN use_ebs_dev = FALSE;
  151. BOOLEAN force_mono = FALSE;
  152. BOOLEAN force_color = FALSE;
  153.  
  154. /* Control objects */
  155. ECB_PTR first_scan_done;
  156. ECB_PTR suspend_completed;
  157. ECB_PTR go_event;
  158.  
  159.  
  160. /* externals */
  161. extern PXCB_PTR        kbd_pipe;      /* pipe used by keyin() */
  162. extern PXCB_PTR        op_pipe;       /* operation input pipe */
  163.  
  164.  
  165. /* Demo Menus */
  166. #define NMEN 3
  167. SUB_MENU menus[NMEN];
  168. /* Exprot this to the menu package in xmwin.c */
  169. int n_sub_menus = NMEN;
  170.  
  171. /* Pause and resume. commands. The task is encoded */
  172. #define CMD_PAUSE_CSCAN     (0x10|DEMO_TASK_CSCAN)
  173. #define CMD_RESUME_CSCAN    (0x20|DEMO_TASK_CSCAN)
  174. #define CMD_PAUSE_SEEK      (0x10|DEMO_TASK_SEEK)
  175. #define CMD_RESUME_SEEK     (0x20|DEMO_TASK_SEEK)
  176. #define CMD_PAUSE_READ      (0x10|DEMO_TASK_READ)
  177. #define CMD_RESUME_READ     (0x20|DEMO_TASK_READ)
  178. #define CMD_PAUSE_WRITE     (0x10|DEMO_TASK_WRITE)
  179. #define CMD_RESUME_WRITE    (0x20|DEMO_TASK_WRITE)
  180. #define CMD_PAUSE_ASCAN     (0x10|DEMO_TASK_ASCAN)
  181. #define CMD_RESUME_ASCAN    (0x20|DEMO_TASK_ASCAN)
  182. #define CMD_USE_DOS         0x02
  183. #define CMD_USE_D           0x03
  184. #define CMD_USE_B           0x04
  185. #define CMD_USE_RD          0x05
  186. #define CMD_QUIT            0x06
  187. #define CMD_GO              0x07
  188.  
  189. /* For debugging */
  190. void say(char * string)     /* __fn__ */
  191. {
  192.     wr_dbstring(1, 1, FGCOLOR, BGCOLOR, string);
  193. /*     suspend(ct, 36);  */
  194. }
  195. void say_2(char * string)     /* __fn__ */
  196. {
  197.     wr_dbstring(40, 1, FGCOLOR, BGCOLOR, string);
  198. /*     suspend(ct, 36);  */
  199. }
  200.  
  201. /***** APPLICATION INITIALIZATION
  202. *  
  203. * Creates all tasks and initialzes the windowing system
  204. * 
  205. **********************************************************************/
  206.  
  207. void _cdecl appl_init()                             /* __fn__ */
  208. {
  209.     unsigned char buf[2];
  210.     unsigned char video;
  211.     extern BOOLEAN monochrome;
  212.  
  213.     /* If the video memory recognizer has trouble the user may specify M or C
  214.        from the command line */
  215.     if (force_mono)
  216.         op_screen = (word far *)MDA;
  217.     else if (force_color)
  218.         op_screen = (word far *)CGA;
  219.  
  220.     /* Get the video adaptor from CMOS location 0x14 bits 4&5. 0x11 ==s monochrome */
  221.     outp(0x70,0x14|0x80);
  222.     video = inp(0x71);
  223.     
  224.     if ((video & 0x30) == 0x30)
  225.     {
  226.         monochrome = TRUE;
  227.         FGCOLOR = MO_FGCOLOR;
  228.         BGCOLOR = MO_BGCOLOR;
  229.         MENU_FG = MO_MENU_FG;
  230.         MENU_BG = MO_MENU_BG;
  231.         MENU_GREYED_FG = MO_MENU_GREYED_FG;
  232.         MENU_GREYED_BG = MO_MENU_GREYED_BG;
  233.         MENU_HIGH_FG = MO_MENU_HIGH_FG;
  234.         MENU_HIGH_BG = MO_MENU_HIGH_BG;
  235.     }
  236.     else
  237.     {
  238.         FGCOLOR = CO_FGCOLOR;
  239.         BGCOLOR = CO_BGCOLOR;
  240.         MENU_FG = CO_MENU_FG;
  241.         MENU_BG = CO_MENU_BG;
  242.         MENU_GREYED_FG = CO_MENU_GREYED_FG;
  243.         MENU_GREYED_BG = CO_MENU_GREYED_BG;
  244.         MENU_HIGH_FG = CO_MENU_HIGH_FG;
  245.         MENU_HIGH_BG = CO_MENU_HIGH_BG;
  246.     }
  247.  
  248. #if (EBS_IDE && EBS_FLOPPY)
  249.     /* Debugging aid. Use the drivers instead of bios */
  250.     if (use_ebs_dev)
  251.     {
  252.         set_devtable();
  253.     }
  254. #endif
  255.  
  256.    #ifdef CODEVIEW
  257.     opcon = create_task(opcon_main, 0, 0);
  258.    #else
  259.     opcon = create_task(opcon_main, MAX, 0);
  260.    #endif
  261.  
  262.     /* fdemo specific application initialization */
  263.  
  264.     /* xfile needs stime to be set properly so it can date stamp files.
  265.        in this demo we call DOS's time function. to set it */
  266.     _disable();
  267.     time((time_t *) &stime);
  268.     _enable();
  269.  
  270.     /* Create the video windoows for the demo */
  271.     xfd_appl_win   =  xmwin_create( 0,  1, 80, 24, FGCOLOR, BGCOLOR,  XWS_BORDER_DOUBLE|XWS_SAVE_UNDER);
  272.     xfd_prompt_win  = xmwin_create(0,  1, 58, 7, FGCOLOR, BGCOLOR, XWS_BORDER_DOUBLE);
  273.     /* Fix the corner where the two windows intersect */
  274.     buf[0] = 204; buf[1] = 0; wr_ustring(0, 7, FGCOLOR, BGCOLOR,buf);
  275.     xfd_cscan_win  = xmwin_create( 1,  8, 56, 4, FGCOLOR, BGCOLOR, XWS_BORDER_SINGLE);
  276.     xfd_seek_win   = xmwin_create( 1, 12, 56, 4, FGCOLOR, BGCOLOR, XWS_BORDER_SINGLE);
  277.     xfd_read_win   = xmwin_create( 1, 16, 56, 4, FGCOLOR, BGCOLOR, XWS_BORDER_SINGLE);
  278.     xfd_write_win  = xmwin_create( 1, 20, 56, 4, FGCOLOR, BGCOLOR, XWS_BORDER_SINGLE);
  279.     xfd_ascan_win  = xmwin_create(58,  2, 21, 22, FGCOLOR, BGCOLOR, XWS_BORDER_SINGLE);
  280.  
  281.     /* Put up a prompt at the bottom of the screen */
  282.     wr_ustring(1, 24, FGCOLOR, BGCOLOR,non_menu_u_prompt);
  283.     
  284.     /* Create event queues we will use to control our tasks */
  285.     first_scan_done  = create_eq();     /* After the first scan of winchester */
  286.     suspend_completed  = create_eq();   /* Signal by task when it suspends */
  287.     go_event = create_eq();             /* Signal when user presses Run Demos */
  288.  
  289. #define PRIO NORM
  290.     /* Create demo tasks */
  291.     xfd_cscan_tcb  =    create_task(xfd_cscan_main, PRIO, 0);
  292.     xfd_seek_tcb   =    create_task(xfd_seek_test_main, PRIO, 0);
  293.     xfd_read_tcb  =    create_task(xfd_read_test_main, PRIO, 0);
  294.     xfd_write_tcb  =    create_task(xfd_write_test_main, PRIO, 0);
  295.     xfd_ascan_tcb  =    create_task(xfd_ascan_main, PRIO, 0);
  296.     xfd_prompt_tcb  =    create_task(xfd_prompt_main, PRIO, 0);
  297.  
  298.     /* Tasks */
  299.     demo_control[DEMO_TASK_CSCAN].p_task   =   xfd_cscan_tcb;
  300.     demo_control[DEMO_TASK_SEEK].p_task    =   xfd_seek_tcb;
  301.     demo_control[DEMO_TASK_READ].p_task    =   xfd_read_tcb;
  302.     demo_control[DEMO_TASK_WRITE].p_task   =   xfd_write_tcb;
  303.     demo_control[DEMO_TASK_ASCAN].p_task   =   xfd_ascan_tcb;
  304.  
  305.     /* Windows */
  306.     demo_control[DEMO_TASK_CSCAN].window   =   xfd_cscan_win;
  307.     demo_control[DEMO_TASK_SEEK].window    =   xfd_seek_win;
  308.     demo_control[DEMO_TASK_READ].window    =   xfd_read_win;
  309.     demo_control[DEMO_TASK_WRITE].window   =   xfd_write_win;
  310.     demo_control[DEMO_TASK_ASCAN].window   =   xfd_ascan_win;
  311.  
  312.     /* Task menu when running */
  313.     demo_control[DEMO_TASK_CSCAN].pause_menu = "Pause  C Scan";
  314.     demo_control[DEMO_TASK_SEEK].pause_menu = "Pause  Seek Test";
  315.     demo_control[DEMO_TASK_READ].pause_menu = "Pause  Read Test";
  316.     demo_control[DEMO_TASK_WRITE].pause_menu = "Pause  Write Test";
  317.     demo_control[DEMO_TASK_ASCAN].pause_menu = "Pause  A Scan";
  318.  
  319.     /* Task menu when paused */
  320.     demo_control[DEMO_TASK_CSCAN].resume_menu = "Resume  C Scan";
  321.     demo_control[DEMO_TASK_SEEK].resume_menu = "Resume  Seek Test";
  322.     demo_control[DEMO_TASK_READ].resume_menu = "Resume  Read Test";
  323.     demo_control[DEMO_TASK_WRITE].resume_menu = "Resume  Write Test";
  324.     demo_control[DEMO_TASK_ASCAN].resume_menu = "Resume  A Scan";
  325.  
  326.         
  327.     /* Smx probe task names */
  328.     BUILD_HT(opcon, "opcon"); 
  329.     BUILD_HT(xfd_cscan_tcb,"xfd_cscan_tcb");
  330.     BUILD_HT(xfd_seek_tcb,"xfd_seek_tcb");
  331.     BUILD_HT(xfd_read_tcb,"xfd_read_tcb");
  332.     BUILD_HT(xfd_write_tcb,"xfd_write_tcb");
  333.     BUILD_HT(xfd_ascan_tcb,"xfd_ascan_tcb");
  334.  
  335.     /* Pop up the top menu */
  336.     create_demo_menu();
  337.     start(opcon);
  338.     start(xfd_cscan_tcb);
  339.     start(xfd_seek_tcb);
  340.     start(xfd_write_tcb);
  341.     start(xfd_read_tcb);
  342.     start(xfd_ascan_tcb);
  343.     start(xfd_prompt_tcb);
  344. }
  345.  
  346. /***** SUBROUTINES
  347. * 
  348. **********************************************************************/
  349.  
  350. /* DEMO Main Tasks */
  351.  
  352. /* xfd_cscan_main - Walk the file tree
  353.  *
  354.  * This routine walks the directory tree of the file system on the hard disk
  355.  * and displays each directory and file as it is encountered. 
  356.  * It is a bit complicated because it uses its own stack for the traversal.
  357.  * Doing this is safer then writing the routine recurively (which would
  358.  * be simpler). During its first scan it finds the largest file on the system.
  359.  * After the first scan it signals those routines that need to know the largest
  360.  * file. The routine is large but for demo purposes I did not want to break it 
  361.  * up into lots of little routines.
  362.  * See pcls.c in the samples directory for similar information. 
  363.  * xfile calls demonstrated:
  364.  * 
  365.  *       create_file_mgr()
  366.  *       pc_dskopen()
  367.  *       pc_set_default_drive()
  368.  *       pc_set_cwd()
  369.  *       pc_gfirst()
  370.  *       pc_gnext()
  371.  *       pc_gdone()
  372. */
  373. static char cscan_stack[30][13];
  374. BOOLEAN find_largest;
  375.  
  376. void _cdecl xfd_cscan_main(void)                             /* __fn__ */
  377. {
  378. static char display_buffer[80];
  379. static char path[EMAXPATH];
  380. char fname_buffer[14];
  381. DSTAT statobj;
  382. int i,stackp, path_len;
  383. BOOLEAN found_dir;
  384. BOOLEAN display_files;
  385.  
  386.  
  387.     unlock();
  388.  
  389.     draw_title(xfd_cscan_win, xfd_cscan_df_title, display_buffer);
  390.     xmwin_wr_string(xfd_cscan_win, 2, 1, FGCOLOR, BGCOLOR, "Dir :");
  391.     xmwin_wr_string(xfd_cscan_win, 2, 2, FGCOLOR, BGCOLOR, "File:");
  392.     
  393.     /* Wait for the gun */
  394.     count(1, go_event, INF);
  395.  
  396.     /* First register the task as a user of the file manager */
  397.     if (!create_file_mgr())
  398.         xfd_error("xfd_cscan: Can't access file manager");
  399.  
  400.     /* Now mount drive C. */
  401.     if (!pc_dskopen(hd_drive_id))
  402.         xfd_error("xfd_cscan: Can't open hard disk");
  403.  
  404.     /* Set the default drive to C: */
  405.     if (!pc_set_default_drive(hd_drive_id))
  406.         xfd_error("Can't select hard disk as default");
  407.  
  408.     /* Find the largest file on the first pass */
  409.     find_largest = TRUE;
  410.     largest_f_size = 0;
  411.     largest_f_path[0] = '\0';
  412.  
  413.     while(bump_task(ct, ct->priority))
  414.     {   
  415.         /* clear our directory stack */
  416.         for (stackp=0; stackp<30;stackp++) cscan_stack[stackp][0]='\0';
  417.         stackp = 0;
  418.  
  419.         while(bump_task(ct, ct->priority))
  420.         {
  421.             /* Walk up our stack and build a path from it */
  422.             path[0]='\0';
  423.             path_len = 0;
  424.             for (i = 0; i < stackp; i++)   
  425.             { 
  426.                path_len += (strlen(cscan_stack[i])+1); 
  427.                if (path_len > EMAXPATH)
  428.                    xfd_error("Too many subdirs for this build");
  429.                strcat(path,"\\"); 
  430.                strcat(path,cscan_stack[i]);
  431.             }
  432.             if (!stackp)
  433.                 strcat(path,"\\"); 
  434.  
  435.             /* Display files if at a new directory (the stack is NULL for
  436.                this dir. Otherwise we will scan forward til we find where 
  437.                we left */
  438.             if (cscan_stack[stackp][0])
  439.                 display_files = FALSE;
  440.             else
  441.                 display_files = TRUE;
  442.  
  443.             /* Display the path */
  444.             if (display_files)
  445.             {
  446.                 memset(display_buffer,' ', 67);
  447.                 display_buffer[66] = 0;
  448.                 xmwin_wr_string(xfd_cscan_win, 7, 1, FGCOLOR, BGCOLOR,
  449.                                 display_buffer);
  450.                 xmwin_wr_string(xfd_cscan_win, 7, 1, FGCOLOR, BGCOLOR, path);
  451.             }
  452.             /* Set the path to the current working path */
  453.             if (!pc_set_cwd(path))
  454.                 xfd_error("Can't set default directory");
  455.  
  456.             /* Get the first entry in the current working directory */
  457.             found_dir = FALSE;
  458.             if (!pc_gfirst(&statobj, "*.*"))
  459.                 xfd_error("No FIles Found");
  460.             do
  461.             {
  462.                 /* make the directory object into file.nam   */
  463.                 mkname(fname_buffer, &statobj);
  464.  
  465.                 if (statobj.fattribute & ADIRENT)
  466.                 {
  467.                     /* If it's a directory push it on our stack if we haven't
  468.                        visited it yet */
  469.                     if (fname_buffer[0] != '.')
  470.                     {
  471.                         if (!cscan_stack[stackp][0])
  472.                         {
  473.                             strcpy(cscan_stack[stackp],fname_buffer);
  474.                             found_dir = TRUE;
  475.                             break;
  476.                         }
  477.                         else
  478.                         {
  479.                             /* This is the one we just saw. zero the slot
  480.                                so we know to take another one */
  481.                             if (strcmp(cscan_stack[stackp],fname_buffer)==0)
  482.                             {
  483.                                 /* 0 the stack so we take the next directory.
  484.                                    plus display files again */
  485.                                 display_files = TRUE;
  486.                                 cscan_stack[stackp][0] = 0;
  487.                             }
  488.                         }
  489.                     }
  490.                 }
  491.                 else if (!(statobj.fattribute & AVOLUME))
  492.                 {
  493.                     /* It's a file. */
  494.                     /* Display the file */
  495.                     if (display_files)
  496.                     {
  497.                         if (find_largest)
  498.                         {
  499.                             if (statobj.fsize > largest_f_size)
  500.                             {
  501.                                 largest_f_size = statobj.fsize;
  502.                                 strcpy(largest_f_path, path);
  503.                                 if (stackp)
  504.                                     strcat(largest_f_path,"\\"); 
  505.                                 strcat(largest_f_path, fname_buffer); 
  506.                             }
  507.                         }
  508.                         xmwin_wr_string(xfd_cscan_win, 7, 2, FGCOLOR, BGCOLOR, 
  509.                                     "               ");
  510.                         xmwin_wr_string(xfd_cscan_win, 7, 2, FGCOLOR, BGCOLOR, 
  511.                                         fname_buffer);
  512.                     }
  513.                 }
  514.                 bump_task(ct, ct->priority);
  515.             } while (pc_gnext(&statobj));
  516.             /* Call gdone to free up internal resources used by statobj */
  517.             pc_gdone(&statobj);
  518.  
  519.             /* If we found a directory bump the stack pointer */
  520.             if (found_dir)
  521.             {
  522.                 stackp += 1;
  523.                 if (stackp >= 30)
  524.                    xfd_error("Too many subdirs for this build");
  525.                 cscan_stack[stackp][0] = 0;
  526.             }
  527.             else
  528.             {
  529.                 /* Decrement the stack. If already 0 we finished the traverse */
  530.                 if (!stackp)
  531.                     break;
  532.                 /* Clean up the stack and decrement the pointer */
  533.                 cscan_stack[stackp--][0] = 0;
  534.             }
  535.         }
  536.         if (find_largest)
  537.         {
  538.             /* Wake up the read task */
  539.             find_largest = FALSE;
  540.             signal(first_scan_done);
  541.             bump_task(ct, ct->priority);
  542.             /* ungrey all the other tests */
  543.             menus[1].flags[DEMO_TASK_SEEK]    &= ~ITEM_GREYED;
  544.             menus[1].flags[DEMO_TASK_READ]    &= ~ITEM_GREYED;
  545.             menus[1].flags[DEMO_TASK_WRITE]   &= ~ITEM_GREYED;
  546.             menus[1].flags[DEMO_TASK_ASCAN]   &= ~ITEM_GREYED;
  547.         }
  548.     }
  549. }
  550.  
  551. /* xfd_seek_test_main - Randomly seek and read from a large file on the 
  552.  *                      hard disk.
  553.  *
  554.  * This routine waits for scan main to find the largest file on the hard 
  555.  * disk and then opens that file and continuously seeks and reads from it.
  556.  * A graph displays the progress
  557.  * 
  558.  *       create_file_mgr()
  559.  *       pc_dskopen()
  560.  *       pc_set_default_drive()
  561.  *       po_open()
  562.  *       po_read()
  563.  *       po_lseek()
  564.  */
  565.  
  566. void _cdecl xfd_seek_test_main(void)                             /* __fn__ */
  567. {
  568. static unsigned char display_buffer[80];
  569. static unsigned char read_buff[512];
  570. unsigned long blocks_per_tick;
  571. unsigned long largest_f_blocks;
  572. long ltemp;
  573. PCFD fd;
  574. int th_posn = 0;
  575.  
  576.     unlock();
  577.     draw_title(xfd_seek_win, xfd_seek_df_title, display_buffer);
  578.  
  579.     /* Wait for the gun */
  580.     count(1, go_event, INF);
  581.  
  582.     /* Wait for the user to launch it */
  583.     xmwin_wr_string(xfd_seek_win, 1, 1, FGCOLOR, BGCOLOR,
  584.          "Suspended At start up Enable from menus..");
  585.     fdemo_suspend_me(0);
  586.     
  587.  
  588.     memset(display_buffer, ' ', 78);
  589.     display_buffer[78] = 0;
  590.     xmwin_wr_string(xfd_seek_win, 1, 1, FGCOLOR, BGCOLOR, display_buffer);
  591.     
  592.  
  593.     xmwin_wr_string(xfd_seek_win, 1, 1, FGCOLOR, BGCOLOR, "File: ");
  594.     xmwin_wr_string(xfd_seek_win, 7, 1, FGCOLOR, BGCOLOR, largest_f_path);
  595.  
  596.     /* Calculate how to position the thermometer */
  597.     largest_f_blocks = largest_f_size/512;
  598.     blocks_per_tick =   largest_f_blocks/38;
  599.  
  600.     /* Now draw the thermometer with double line chars */
  601.     memset(display_buffer,205, 40);
  602.     display_buffer[0]  = (unsigned char) 204;
  603.     display_buffer[39] = (unsigned char) 185;
  604.     display_buffer[40] = '\0';
  605.     xmwin_wr_string(xfd_seek_win, 4, 2, FGCOLOR, BGCOLOR, display_buffer);
  606.  
  607.     /* First register the task as a user of the file manager */
  608.     if (!create_file_mgr())
  609.         xfd_error("xfd_cscan: Can't access file manager");
  610.  
  611.     /* Make sure drive C is mounted. */
  612.     if (!pc_dskopen(hd_drive_id))
  613.         xfd_error("xfd_cscan: Can't open hard disk");
  614.  
  615.     /* Set the default drive to C: */
  616.     if (!pc_set_default_drive(hd_drive_id))
  617.         xfd_error("Can't select hard disk as default");
  618.  
  619.     /* Open the file */
  620.     if ((fd = po_open(largest_f_path, (PO_BINARY|PO_RDONLY), 0)) < 0)
  621.     {
  622.         xfd_error("Can't open the seek test file");
  623.     }
  624.  
  625.     /* Now randomly seek and read */
  626.     while(bump_task(ct, ct->priority))
  627.     {
  628.         ltemp = (long) rand();
  629.         ltemp %= largest_f_blocks;
  630.         display_buffer[1] = '\0';
  631.         /* Clear the thumb */
  632.         if (th_posn)
  633.         {
  634.             display_buffer[0] = 205;
  635.             xmwin_wr_string(xfd_seek_win, th_posn, 2, FGCOLOR, BGCOLOR, display_buffer);
  636.         }
  637.         if (blocks_per_tick)
  638.         {
  639.             th_posn = (int) (ltemp/blocks_per_tick);
  640.             /* There's a bug in the calculation, fix it here */
  641.             if (th_posn > 37)
  642.                 th_posn = 37;
  643.             th_posn += 5;
  644.             display_buffer[0] = 206;
  645.             xmwin_wr_string(xfd_seek_win, th_posn, 2, FGCOLOR, BGCOLOR, display_buffer);
  646.         }
  647.         
  648.         ltemp *= 512;
  649.         if (po_lseek(fd, ltemp, PSEEK_SET) != ltemp)
  650.             xfd_error("Seek error");
  651.         bump_task(ct, ct->priority);
  652.         if (po_read(fd, read_buff, 512) !=  512)
  653.             xfd_error("Read error");
  654.     }
  655. }
  656.  
  657.  
  658.  
  659. /* xfd_read_test_main - Sequentially read from a large file on the 
  660.  *                      hard disk.
  661.  *
  662.  * This routine waits for scan main to find the largest file on the hard 
  663.  * disk and then opens that file and reads it sequentially. After each
  664.  * read it calulates the throughput.
  665.  * If the user selects it DOS can be used instead of RTFS. This gives an idea
  666.  * of the relative performance of the two.
  667.  * A graph displays the progress
  668.  * 
  669.  *       create_file_mgr()
  670.  *       pc_dskopen()
  671.  *       pc_set_default_drive()
  672.  *       po_open()
  673.  *       po_read()
  674.  *       po_lseek()
  675.  */
  676.  
  677. /* Use 20 blocks per read (10 K) */
  678. #if LARGE_DATA
  679. #define BLOCKS_PREAD 20
  680. #define BYTES_PREAD  (20*512)
  681. #else
  682. #define BLOCKS_PREAD 1
  683. #define BYTES_PREAD  (1*512)
  684. #endif
  685. void _cdecl xfd_read_test_main(void)                             /* __fn__ */
  686. {
  687. static unsigned char display_buffer[80];
  688. char *read_buff;
  689. unsigned long blocks_per_tick;
  690. unsigned long largest_f_blocks;
  691. unsigned long ltemp;
  692. PCFD fd;
  693. int th_posn = 0;
  694. long starting_ticks;
  695.  
  696.     unlock();
  697.     draw_title(xfd_read_win, xfd_read_df_title, display_buffer);
  698.  
  699.     /* Wait for the gun */
  700.     count(1, go_event, INF);
  701.  
  702.     /* Grab a buffer for the test */
  703.     read_buff = (char *) malloc(BYTES_PREAD);
  704.     if (!read_buff)
  705.         xfd_error("Read Test, Not enough core to allocate buffer");
  706.     xmwin_wr_string(xfd_read_win, 1, 1, FGCOLOR, BGCOLOR,
  707.          "Scanning Drive For Largest File....");
  708.  
  709.     /* Wait for the largest file to be found */
  710.     count(1, first_scan_done, INF);
  711.  
  712.     memset(display_buffer, ' ', 78);
  713.     display_buffer[78] = 0;
  714.     xmwin_wr_string(xfd_read_win, 1, 1, FGCOLOR, BGCOLOR, display_buffer);
  715.     
  716.     xmwin_wr_string(xfd_read_win, 1, 1, FGCOLOR, BGCOLOR, "File: ");
  717.     xmwin_wr_string(xfd_read_win, 7, 1, FGCOLOR, BGCOLOR, largest_f_path);
  718.  
  719.     /* Calculate how to position the thermometer */
  720.     largest_f_blocks = largest_f_size/512;
  721.     blocks_per_tick =   largest_f_blocks/38;
  722.  
  723.     /* Now draw the thermometer with double line chars */
  724.     memset(display_buffer,205, 40);
  725.     display_buffer[0]  = (unsigned char) 204;
  726.     display_buffer[39] = (unsigned char) 185;
  727.     display_buffer[40] = '\0';
  728.     xmwin_wr_string(xfd_read_win, 4, 2, FGCOLOR, BGCOLOR, display_buffer);
  729.  
  730.     /* First register the task as a user of the file manager */
  731.     if (!create_file_mgr())
  732.         xfd_error("xfd_cscan: Can't access file manager");
  733.  
  734.     /* Make sure drive C is mounted. */
  735.     if (!pc_dskopen(hd_drive_id))
  736.         xfd_error("xfd_cscan: Can't open hard disk");
  737.  
  738.     /* Set the default drive to C: */
  739.     if (!pc_set_default_drive(hd_drive_id))
  740.         xfd_error("Can't select hard disk as default");
  741.     
  742.     LOCK();
  743.     /* Open the file */
  744.     if ((fd = po_open(largest_f_path, (PO_BINARY|PO_RDONLY), 0)) < 0)
  745.     {
  746.         xfd_error("Can't open the read test file");
  747.     }
  748.     unlock();
  749.     
  750.     strcpy(read_buff,hd_drive_id);
  751.     strcat(read_buff,largest_f_path);
  752.  
  753.  
  754.     /* Now sequentially read */
  755.     ltemp = 0;    
  756.     starting_ticks = get_etime();
  757.  
  758.     while(bump_task(ct, ct->priority))
  759.     {
  760.         if (ltemp == 0)
  761.         draw_title(xfd_read_win, xfd_read_df_title, display_buffer);
  762.  
  763.         ltemp %= largest_f_blocks;
  764.         display_buffer[1] = '\0';
  765.             /* Clear the thumb */
  766.  
  767.         if (th_posn)
  768.         {
  769.             display_buffer[0] = 205;
  770.             xmwin_wr_string(xfd_read_win, th_posn, 2, FGCOLOR, BGCOLOR, display_buffer);
  771.         }
  772.         if (blocks_per_tick)
  773.         {
  774.             th_posn = (int) (ltemp/blocks_per_tick);
  775.             /* There's a bug in the calculation, fix it here */
  776.             if (th_posn > 37)
  777.                 th_posn = 37;
  778.             th_posn += 5;
  779.             display_buffer[0] = 206;
  780.             xmwin_wr_string(xfd_read_win, th_posn, 2, FGCOLOR, BGCOLOR, display_buffer);
  781.         }
  782.         if (po_read(fd, read_buff, BYTES_PREAD) == (UCOUNT) ~0)
  783.             xfd_error("Read error");
  784.  
  785.         ltemp += BLOCKS_PREAD;    
  786.         if (ltemp >= largest_f_blocks)
  787.         {
  788.             if (po_lseek(fd, 0L, PSEEK_SET) != 0L)
  789.                 xfd_error("Seek error");
  790.            
  791.             /* Calculate transfer rate */
  792.             /* Elapsed time in seconds */
  793.             ltemp = get_etime()-starting_ticks;
  794.             /* Bytes/second */
  795.             if (ltemp)
  796.                 ltemp = ((largest_f_blocks*512)/ltemp)*SEC;
  797.             else
  798.                 ltemp = 0;
  799.  
  800.             /* Clear the line and write the transfer rate */
  801.             memset(display_buffer, ' ', 78);
  802.             display_buffer[78] = 0;
  803.             xmwin_wr_string(xfd_read_win, 1, 1, FGCOLOR, BGCOLOR, display_buffer);
  804.             ltoa(ltemp, display_buffer, 10);
  805.             strcat(display_buffer, " Bytes/Second");
  806.             xmwin_wr_string(xfd_read_win, 1, 1, FGCOLOR, BGCOLOR, display_buffer);
  807.  
  808.             /* Remember the time for next time */
  809.             starting_ticks = get_etime();
  810.             /* reset the byte counter. ltemp is really overused, I know */
  811.             ltemp = 0;
  812.         }
  813.     }
  814. }
  815.  
  816. /* xfd_write_test_main - Create directorues and files. Then rename the files,
  817.  *                       delete them and then delete the directories.
  818.  *                      
  819.  * This routine works on the user selected folppy or ram disk. Creates two
  820.  * directories, populates them with files, renames the files, deletes the files
  821.  * and finally deletes the directories. This loops continuosly. Its sister
  822.  * function xfd_ascan_main() scans these directories and prints the tree 
  823.  * structure in a continuous manner.
  824.  * 
  825.  *       create_file_mgr()
  826.  *       pc_dskopen()
  827.  *       pc_set_default_drive()
  828.  *       pc_mkfs() - See ram_disk_init()
  829.  *       po_open()
  830.  *       po_read()
  831.  *       po_close()
  832.  *       po_mkdir()
  833.  *       po_rmdir()
  834.  *       pc_set_cwd()
  835.  *       pc_iddir()
  836.  *       pc_mv()
  837.  *       po_unlink()
  838.  * 
  839.  *  To do all this in line would have been unwieldly, so several helper functions
  840.  *  were created. See the task helper function section after the main tasks.
  841.  *
  842.  */
  843.  
  844. /* used by write_test and its helpers */
  845. static char wr_display_buffer[80];
  846. static char wr_display_buffer_2[80];
  847.  
  848. void _cdecl xfd_write_test_main(void)                             /* __fn__*/
  849. {
  850. static char dir[14];
  851. char c;
  852. extern PFILE_SYSTEM_USER fs_user;    /* Current user pointer contains errno/pwd */
  853.  
  854.     unlock();
  855.     draw_title(xfd_write_win, xfd_write_df_title, wr_display_buffer);
  856.     /* Wait for the gun */
  857.     count(1, go_event, INF);
  858.  
  859.  
  860.     /* First register the task as a user of the file manager */
  861.     if (!create_file_mgr())
  862.         xfd_error("xfd_cscan: Can't access file manager");
  863.     if (fd_drive_id[0] == 'E')
  864.         if (!ram_disk_init())
  865.             xfd_error("No Ram drive");
  866.     /* Now mount drive A:. */
  867.     if (!pc_dskopen(fd_drive_id))
  868.         xfd_error("xfd_write: Can't open floppy drive");
  869.     /* Set the default drive to A: */
  870.     if (!pc_set_default_drive(fd_drive_id))
  871.         xfd_error("Can't select floppy as default");
  872.     if (!pc_set_cwd("\\"))
  873.         xfd_error("Can't set default directory");
  874.     /* Wait for the user to enable floppy operations */
  875.     xmwin_wr_string(xfd_write_win, 1, 1, FGCOLOR, BGCOLOR,
  876.          "Suspended At start up Enable from menus..");
  877.     fdemo_suspend_me(0);
  878.  
  879.  
  880.     memset(wr_display_buffer,' ', 67);
  881.     xmwin_wr_string(xfd_write_win, 1, 1, FGCOLOR, BGCOLOR, wr_display_buffer);
  882.     xmwin_wr_string(xfd_write_win, 1, 2, FGCOLOR, BGCOLOR, wr_display_buffer);
  883.  
  884.     strcpy(dir, "SUBDIR1");
  885.  
  886.     while(bump_task(ct, ct->priority))
  887.     {   
  888.         /* Set the default path to \\ */
  889.         if (!pc_set_cwd("\\"))
  890.             xfd_error("Can't set default directory");
  891.         /* Delete all files in two subdirectories and the dirs themselves */
  892.         for (c = '1'; c < '3'; c++)
  893.         {
  894.             dir[6] = c;         /* Flip from SUBDIR1 to SUBDIR2 */
  895.             if (pc_isdir(dir))
  896.             {
  897.                 /* Delete all files from dir */
  898.                 xfd_write_purge(dir);
  899.                 strcpy(wr_display_buffer_2, "Removing: ");
  900.                 strcat(wr_display_buffer_2,  dir);
  901.                 xfd_write_status(1, wr_display_buffer_2);
  902.                 /* Call special rmdir routine which waits around for the
  903.                    scanner routine to stop looking at the directory.
  904.                    Normally you would just call pc_rmdir(dir). It would
  905.                    fail if someone else was using it (which is the
  906.                    correct behavior) */
  907.                 if (!xfd_write_rmdir(dir))
  908.                     xfd_error("Can't remove directory");
  909.             }
  910.         }
  911.  
  912.         /* Create the subdirectory and files */
  913.         xfd_write_status(1, "Creating SUBDIR 1");
  914.         if (!pc_mkdir("SUBDIR1"))
  915. cant_mkdir:
  916.             xfd_error("Can't create directory");
  917.  
  918.         xfd_write_status(1, "Creating SUBDIR 2");
  919.         if (!pc_mkdir("SUBDIR2"))
  920.             goto cant_mkdir;
  921.         
  922.         /* Create a bunch of files */
  923.         xfd_write_make_files("SUBDIR1");
  924.         xfd_write_make_files("SUBDIR2");
  925.         xfd_write_rename_files("SUBDIR1");
  926.         xfd_write_rename_files("SUBDIR2");
  927.     }
  928. }
  929.  
  930. /* xfd_ascan_main - Scan directories and files on the floppy or ram disk.
  931.  *                      
  932.  * This routine works on the user selected floppy or ram disk. It scans for
  933.  * the two directories created by xfd_write_test_main() and print their
  934.  * contents. The display will vary ofer time as the directory contents
  935.  * change.
  936.  * 
  937.  *       create_file_mgr()
  938.  *       pc_dskopen()
  939.  *       pc_set_default_drive()
  940.  *       pc_set_cwd()
  941.  *       pc_isdir()
  942.  *       pc_gfirst()
  943.  *       pc_gnext()
  944.  *       po_gdone()
  945.  * 
  946.  */
  947.  
  948. void _cdecl xfd_ascan_main(void)                                /* __fn__*/
  949. {
  950. static char display_buffer[80];
  951. DSTAT statobj;
  952. int i, posn;
  953. int n_found;
  954.  
  955.     unlock();
  956.  
  957.     draw_title(xfd_ascan_win, xfd_ascan_df_title, display_buffer);
  958.  
  959.     /* Wait for the gun */
  960.     count(1, go_event, INF);
  961.  
  962.     /* First register the task as a user of the file manager */
  963.     if (!create_file_mgr())
  964.         xfd_error("Lost File manager");
  965.  
  966.     if (fd_drive_id[0] == 'E')
  967.         if (!ram_disk_init())
  968.             xfd_error("No Ram drive");
  969.  
  970.     /* Now mount drive A:. */
  971.     if (!pc_dskopen(fd_drive_id))
  972.         xfd_error("No floppy drive");
  973.  
  974.     /* Set the default drive to A: */
  975.     if (!pc_set_default_drive(fd_drive_id))
  976.         xfd_error("Can't set drive");
  977.  
  978.     /* Set the default path to \\ */
  979.     if (!pc_set_cwd("\\"))
  980.         xfd_error("Can't set dir");
  981.  
  982.  
  983.     xmwin_wr_string(xfd_ascan_win, 1, 1, FGCOLOR, BGCOLOR, "Suspended At");
  984.     xmwin_wr_string(xfd_ascan_win, 1, 2, FGCOLOR, BGCOLOR, "Start up..");
  985.     /* Wait to be turned on */
  986.     fdemo_suspend_me(0);
  987.  
  988.     while(bump_task(ct, ct->priority))
  989.     {   
  990.         /* Clear the window */
  991.         memset(display_buffer,' ', 20);
  992.         for (i = 1; i < xfd_ascan_win->height-2; i++)
  993.             xmwin_wr_string(xfd_ascan_win, 1, i, FGCOLOR, BGCOLOR, display_buffer);
  994.  
  995.          posn = 0;
  996.          n_found = 0;
  997.  
  998.         /* See if the DIR exists. If it does we scan through it and display
  999.            its contents */
  1000.         if (pc_isdir("SUBDIR1"))
  1001.         {
  1002.             posn += 1;
  1003.             n_found += 1;
  1004.  
  1005.             xmwin_wr_string(xfd_ascan_win, 1, posn++, FGCOLOR, BGCOLOR,"SUBDIR1");
  1006.             if (pc_gfirst(&statobj, "SUBDIR1\\*.*"))
  1007.             {
  1008.                 /* Limit the display to for files */
  1009.                 for (i = 1; i < ((xfd_ascan_win->height-4)/2); i++,posn++)
  1010.                 {
  1011.                     /* make the directory object into file.nam   */
  1012.                     mkname(display_buffer, &statobj);
  1013.                     xmwin_wr_string(xfd_ascan_win, 4, posn, FGCOLOR,
  1014.                                     BGCOLOR, display_buffer);
  1015.                     if (!pc_gnext(&statobj))
  1016.                         break;
  1017.                 }
  1018.                 /* Call gdone to free up internal resources used by statobj */
  1019.                 pc_gdone(&statobj);
  1020.             }
  1021.         }
  1022.         /* Repeat the loop for subdir2 */
  1023.         if (pc_isdir("SUBDIR2"))
  1024.         {
  1025.             posn += 1;
  1026.             n_found += 1;
  1027.             xmwin_wr_string(xfd_ascan_win, 1, posn++, FGCOLOR, BGCOLOR,"SUBDIR2");
  1028.             if (pc_gfirst(&statobj, "SUBDIR2\\*.*"))
  1029.             {
  1030.                 for (i = 1; i < ((xfd_ascan_win->height-4)/2); i++,posn++)
  1031.                 {
  1032.                     /* make the directory object into file.nam   */
  1033.                     mkname(display_buffer, &statobj);
  1034.                     xmwin_wr_string(xfd_ascan_win, 4, posn, FGCOLOR,
  1035.                                     BGCOLOR, display_buffer);
  1036.                     if (!pc_gnext(&statobj))
  1037.                         break;
  1038.                 }
  1039.                 /* Call gdone to free up internal resources used by statobj */
  1040.                 pc_gdone(&statobj);
  1041.             }
  1042.         }
  1043.         /* Suspend a few ticks. This smooths thing out a little plus
  1044.            it masks a bug:
  1045.             If this routine did not find any files and we did not suspend
  1046.             smx doesn't preempt us and it spins in a tight loop. Will
  1047.             use probe to find out why later. */
  1048.         suspend(ct,5);
  1049.     }
  1050. }
  1051.  
  1052. /* This task manages the prompt window, There are now xfile calls in it */
  1053.  
  1054. void _cdecl xfd_prompt_main(void)              /* __fn__*/
  1055. {
  1056.     unlock();
  1057.  
  1058.     prompt(0, "              Welcome To The smxFile Demo        ", 
  1059.               "        Use the Options Menu to Modify Parameters",
  1060.               "        Then select Run Demo From The Files Menu",
  1061.               "        Wait for first scan before selecting F2",
  1062.               "           Press Escape at any time to Exit");
  1063. #if 0
  1064.     xmwin_scroll(xfd_prompt_win; TRUE);
  1065.     xmwin_scroll(xfd_prompt_win; FALSE);
  1066. #endif
  1067.  
  1068.     /* Wait for the gun */
  1069.     count(1, go_event, INF);
  1070.     while(bump_task(ct, ct->priority))
  1071.     {
  1072.         prompt(1,"   There are five tasks running, each performing",
  1073.                  "   a different function. The first continually scans",
  1074.                  "   the hard drive and prints the names of all files",
  1075.                  "   and directories.",0);
  1076.         prompt(1," The second task waits for the first scan of the disk",
  1077.                  " to complete and then randomly seeks and reads from",
  1078.                  " the largest file on it. This task is initially disabled",
  1079.                  " for max thruput. The third task reads the largest file",
  1080.                  " sequentially and calculates disk thruput.");
  1081.         prompt(1," The fourth task creates two directories on the floppy",
  1082.                  " or RAM disk and fills them with files which are",
  1083.                  " later renamed and deleted. The fifth task continually",
  1084.                  " scans the floppy disk and displays the contents of",
  1085.                  " the two directories.");
  1086.         prompt(1," The Floppy tasks are disabled at first because",
  1087.                  " they slow down the hard disk tasks. It\'s the fault",
  1088.                  " of the BIOS not smxFile. We have drivers to fix this.",
  1089.                  " You may enable floppy tasks from the F2 menu. Be sure",
  1090.                  " to use a high density floppy.");
  1091.         prompt(1," If you want something a little snappier, you may use",
  1092.                  " a RAM disk instead of a floppy disk for the \"Floppy",
  1093.                  " Tests\". To do this use the F3 options menu before",
  1094.                  " you select Run Demo from the F1 menu.", 0);
  1095.         prompt(1," The \"Read Test\" demonstrates the throughput of",
  1096.                  " smxFile. With some disk controllers the DOS driver is",
  1097.                  " faster than the BIOS driver. Hence the BIOS driver may",
  1098.                  " lower the performance of smxFile relative to DOS.",0);
  1099.         prompt(1," To get a better idea of smxFile performance, invoke",
  1100.                  " this demo with the smx floppy and ide drivers.",
  1101.                  " e.g.: \"run l d\"",0,0);
  1102.     }
  1103. }
  1104.  
  1105. /* Task helper functions */
  1106.  
  1107. /* make a directory object into file.nam   */
  1108. void mkname(char *buffer, DSTAT *pstat)                             /* __fn__ */
  1109. {
  1110. char *pfr, *pto;
  1111.     pto = buffer;  pfr = (char *) pstat->fname;
  1112.     while (*pfr && *pfr!=' ') *pto++ = *pfr++;
  1113.     pfr = pstat->fext;
  1114.     if (*pfr != ' ')  *pto++ = '.';
  1115.     while (*pfr && *pfr!=' ') *pto++ = *pfr++;
  1116.     *pto = '\0';
  1117. }
  1118.  
  1119. /* These routines are helpers to  xfd_write_test_main(void) below */
  1120.  
  1121. void xfd_write_status(int line, char *message)              /* __fn__*/
  1122. {
  1123.     memset(wr_display_buffer,' ', 67);
  1124.     xmwin_wr_string(xfd_write_win, 1, line, FGCOLOR, BGCOLOR, wr_display_buffer);
  1125.     /* If status 1 has change clear status 2 */
  1126.     if (line == 1)
  1127.         xmwin_wr_string(xfd_write_win, 1, 2, FGCOLOR, BGCOLOR, wr_display_buffer);
  1128.     xmwin_wr_string(xfd_write_win, 1, line, FGCOLOR, BGCOLOR, message);
  1129. }
  1130.  
  1131. /* Delete all files in a subdirectory */
  1132. void xfd_write_purge(char *subdir)                              /* __fn__*/
  1133. {
  1134.     DSTAT statobj;
  1135.     BOOL  more;
  1136.     int i;
  1137.     char fname_buffer[14];    
  1138.     BOOL deleted;
  1139.     extern PFILE_SYSTEM_USER fs_user;    /* Current user pointer contains errno/pwd */
  1140.  
  1141.     strcpy(wr_display_buffer_2,"Deleting Files In: ");
  1142.     strcat(wr_display_buffer_2,subdir);
  1143.     xfd_write_status(1, wr_display_buffer_2);
  1144.  
  1145.     if (!pc_set_cwd(subdir))
  1146.         goto cant_set;
  1147.  
  1148.     if (pc_gfirst(&statobj, "*.*"))
  1149.     {
  1150.         do {
  1151.             if (!(statobj.fattribute & ADIRENT))
  1152.             {
  1153.                 mkname(fname_buffer, &statobj);
  1154.                 strcpy(wr_display_buffer_2,"Deleting : ");
  1155.                 strcat(wr_display_buffer_2,fname_buffer);
  1156.                 xfd_write_status(2, wr_display_buffer_2);
  1157.                 /* Get next so the DROJ is no longer open */
  1158.                 more = pc_gnext(&statobj);
  1159.                 if (!more)
  1160.                     pc_gdone(&statobj);
  1161.                 /* xfd_ascan_main is continually scanning the FLOPPY disk. 
  1162.                    If it happens to be looking at this file at the time we try 
  1163.                    to delete it this routine will fail (correctly) with 
  1164.                    fs_user->p_errno == PEACCES. So we suspend and try again
  1165.                    later in this case.
  1166.  
  1167.                    Note:
  1168.                         PEACCES has other meanings as well so we we time out 
  1169.                         after a few. (this is a minor bug in the API)
  1170.                 */
  1171.                 for (i = 0; i < 100; i++)
  1172.                 {
  1173.                     deleted = pc_unlink(fname_buffer);
  1174.                     if (deleted || (fs_user->p_errno != PEACCES))
  1175.                         break;
  1176.                     else
  1177.                         suspend(ct,1);
  1178.                 }
  1179.                 if (!deleted)
  1180.                     xfd_error("Can't delete File");
  1181.             }
  1182.             else
  1183.             {
  1184.                 more = pc_gnext(&statobj);
  1185.                 if (!more)
  1186.                     pc_gdone(&statobj);
  1187.             }
  1188.         } while (more);
  1189.     }
  1190.     if (!pc_set_cwd("\\"))
  1191. cant_set:
  1192.         xfd_error("Can't set default directory");
  1193. }
  1194.  
  1195.  
  1196. /* Remove a subdirectory, bearing in mind that it may be being accessed
  1197.    by the scanner task.  */
  1198. BOOL xfd_write_rmdir(char *subdir)                              /* __fn__*/
  1199. {
  1200.     int i;
  1201.     BOOL deleted;
  1202.     extern PFILE_SYSTEM_USER fs_user;    /* Current user pointer contains errno/pwd */
  1203.  
  1204.     for (i = 0; i < 100; i++)
  1205.     {
  1206.      /* xfd_ascan_main is continually scanning the FLOPPY disk. 
  1207.         If it happens to be looking at this directory at the time we try 
  1208.         to delete it this routine will fail (correctly) with 
  1209.         fs_user->p_errno == PEACCES. So we suspend and try again
  1210.         later in this case.
  1211.          Note:
  1212.              PEACCES has other meanings as well so we we time out 
  1213.               after a few. (this is a minor bug in the API)
  1214.      */
  1215.  
  1216.         deleted = pc_rmdir(subdir);
  1217.         if (deleted || (fs_user->p_errno != PEACCES))
  1218.             break;
  1219.         else
  1220.             suspend(ct,1);
  1221.     }
  1222.     return (deleted);
  1223. }
  1224.  
  1225.  
  1226. /* Create files in a subdirectory */
  1227. void xfd_write_make_files(char *subdir)                           /* __fn__*/
  1228. {
  1229.     int i;
  1230.     int fd;
  1231.     char fname_buffer[14];    
  1232.     char c;
  1233.  
  1234.     strcpy(wr_display_buffer_2,"Creating Files In: ");
  1235.     strcat(wr_display_buffer_2,subdir);
  1236.     xfd_write_status(1, wr_display_buffer_2);
  1237.  
  1238.     if (!pc_set_cwd(subdir))
  1239.         goto cant_set;
  1240.     strcpy(fname_buffer, "FILE_1.TXT");
  1241.  
  1242.     
  1243.     for (i = 0, c = '1'; i < 8; i++, c++)
  1244.     {
  1245.         fname_buffer[5] = c;
  1246.         strcpy(wr_display_buffer_2,"Creating : ");
  1247.         strcat(wr_display_buffer_2,fname_buffer);
  1248.         xfd_write_status(2, wr_display_buffer_2);
  1249.         if ((fd = po_open(fname_buffer,(PO_BINARY|PO_WRONLY|PO_CREAT|PO_TRUNC),
  1250.                                        (PS_IWRITE | PS_IREAD) ) ) < 0)
  1251.                 xfd_error("Can't open File");
  1252.         if (po_write(fd, fname_buffer, 10) != 10)
  1253.                 xfd_error("Can't write File");
  1254.         po_close(fd);
  1255.     }
  1256.  
  1257.     if (!pc_set_cwd("\\"))
  1258. cant_set:
  1259.         xfd_error("Can't set default directory");
  1260. }
  1261.  
  1262. /* Rename files in a directory */
  1263. void xfd_write_rename_files(char *subdir)                       /* __fn__*/
  1264. {
  1265.     DSTAT statobj;
  1266.     BOOL  more;
  1267.     char fname_buffer[14];    
  1268.  
  1269.     strcpy(wr_display_buffer_2,"Renaming Files In: ");
  1270.     strcat(wr_display_buffer_2,subdir);
  1271.     xfd_write_status(1, wr_display_buffer_2);
  1272.  
  1273.     if (!pc_set_cwd(subdir))
  1274.         goto cant_set;
  1275.  
  1276.     if (pc_gfirst(&statobj, "*.*"))
  1277.     {
  1278.         do {
  1279.             if (!(statobj.fattribute & ADIRENT))
  1280.             {
  1281.                 mkname(&fname_buffer[1], &statobj);
  1282.                 strcpy(wr_display_buffer_2,"Rename : ");
  1283.                 strcat(wr_display_buffer_2,&fname_buffer[1]);
  1284.                 xfd_write_status(2, wr_display_buffer_2);
  1285.                 fname_buffer[0] = '_';
  1286.                 /* Get next so the DROJ is no longer open */
  1287.                 more = pc_gnext(&statobj);
  1288.                 if (!pc_mv(&fname_buffer[1],fname_buffer))
  1289.                     xfd_error("Can't rename File");
  1290.             }
  1291.             else
  1292.                 more = pc_gnext(&statobj);
  1293.         } while (more);
  1294.         /* Call gdone to free up internal resources used by statobj */
  1295.         pc_gdone(&statobj);
  1296.     }
  1297.     if (!pc_set_cwd("\\"))
  1298. cant_set:
  1299.         xfd_error("Can't set default directory");
  1300. }
  1301.  
  1302. /* Format a ram disk */
  1303. BOOLEAN ram_disk_init()                                 /* __fn__*/
  1304. {
  1305. IMPORT _PC_BDEVSW pc_bdevsw[];
  1306. FMTPARMS fmt;
  1307. int driveno;
  1308. static BOOLEAN ram_disk_formatted = FALSE;
  1309.  
  1310.     LOCK();
  1311.  
  1312.     if (ram_disk_formatted)
  1313.         goto out;
  1314.  
  1315.     
  1316.     driveno = 4;        /* E: */
  1317.     strcpy(&fmt.oemname[0], "EBS");
  1318.     fmt.secpalloc =      (UTINY)  1;
  1319.     fmt.secreserved =    (UCOUNT) 1;
  1320.     fmt.numfats     =    (UTINY)  1;
  1321.     fmt.secpfat     =    (UCOUNT) 1;
  1322.     fmt.numroot     =    (UCOUNT) 16;   /* One block */
  1323.     fmt.mediadesc =      (UTINY)  0xFD;
  1324.  
  1325.     /* 2 * 2 * (N/4)  =s N */
  1326.     fmt.secptrk     =    (UCOUNT) NRAMDISKBLOCKS/4;
  1327.     fmt.numhead     =    (UCOUNT) 2;
  1328.     fmt.numcyl     =     (UCOUNT) 2;
  1329.     fmt.physical_drive_no =   0;
  1330.     fmt.binary_volume_label = 0x12345678L;
  1331.     strcpy(fmt.text_volume_label, "VOLUMELABE"); 
  1332.  
  1333.     if (!pc_bdevsw[driveno].open_proc(driveno))
  1334.         goto out;
  1335.  
  1336.     /* How many sectors do we need for the fat */
  1337.     fmt.secpfat = pc_fat_size( (UCOUNT) fmt.secreserved,
  1338.                                (UCOUNT) fmt.secpalloc,
  1339.                                (UCOUNT) fmt.numfats,
  1340.                                (UCOUNT) fmt.numroot,NRAMDISKBLOCKS);
  1341.  
  1342.     if (!pc_mkfs(driveno, &fmt ))
  1343.         goto out;
  1344.     ram_disk_formatted = TRUE;
  1345. out:
  1346.     unlock();
  1347.     return(ram_disk_formatted);
  1348. }
  1349.  
  1350. /* Used by prompt_main. This routine displays strings in the prompt window
  1351.    and sleeps if requested. */
  1352.  
  1353. void prompt(int goto_sleep,char *p0, char *p1,char *p2, char *p3, char *p4)/*__fn__*/
  1354. {
  1355. int posn;
  1356. static char display_buffer[80];
  1357.  
  1358.     /* Clear the rows */
  1359.         memset(display_buffer,' ', 79);
  1360.         for (posn = 1; posn < 6; posn++)
  1361.           xmwin_wr_string(xfd_prompt_win, 1, posn, FGCOLOR, BGCOLOR,display_buffer);
  1362.  
  1363.        if (p0)
  1364.            xmwin_wr_string(xfd_prompt_win, 1, 1, FGCOLOR, BGCOLOR,p0);
  1365.        if (p1)
  1366.            xmwin_wr_string(xfd_prompt_win, 1, 2, FGCOLOR, BGCOLOR,p1);
  1367.        if (p2)
  1368.            xmwin_wr_string(xfd_prompt_win, 1, 3, FGCOLOR, BGCOLOR,p2);
  1369.        if (p3)
  1370.            xmwin_wr_string(xfd_prompt_win, 1, 4, FGCOLOR, BGCOLOR,p3);
  1371.        if (p4)
  1372.            xmwin_wr_string(xfd_prompt_win, 1, 5, FGCOLOR, BGCOLOR,p4);
  1373.        if (goto_sleep)
  1374.            suspend(ct, 12*SEC);
  1375. }
  1376. /* Draws a title in top left corner of a window */
  1377. void draw_title(XMWIN_PTR win, char * title, char * buffer)     /* __fn__ */
  1378. {
  1379. char *p = buffer;
  1380.  
  1381.     memset(buffer, CH_SHOR, 76);
  1382.     buffer[75] = 0;
  1383.     while (*title)
  1384.         *p++ = *title++;
  1385.     xmwin_wr_string(win, 1, 0, FGCOLOR, BGCOLOR, buffer);
  1386. }
  1387.  
  1388. /* Task control and interaction functions */
  1389.  
  1390. /***** OPERATION CONTROL
  1391. * Filters key board input and exits or pops up menus
  1392. * 
  1393. **********************************************************************/
  1394. void _cdecl opcon_main(void)                             /* __fn__ */
  1395. {
  1396.    char  key;
  1397.    unsigned int  ikey;
  1398.  
  1399.     while(key = (char)(ikey = pget_char(op_pipe, INF)))
  1400.     {
  1401.         if(key == Esc)
  1402.             start(exitx);
  1403.         else if ( (ikey &0xff) == KEY_F1)
  1404.             command_dispatch(process_menu(0));
  1405.         else if ( (ikey &0xff) == KEY_F2)
  1406.             command_dispatch(process_menu(1));
  1407.         else if ( (ikey &0xff) == KEY_F3)
  1408.             command_dispatch(process_menu(2));
  1409.         else if(key == Ctrl_S)
  1410.         {
  1411.             if(sp_scrn_sel)
  1412.                 swap_screen();
  1413.             kbd_pipe = op_pipe;
  1414.         }
  1415.     }
  1416. }
  1417.  
  1418. /* This routine is called to create the menu system for the demo */
  1419. void create_demo_menu()                                      /* __fn__ */
  1420. {
  1421.     menus[0].top = "F1: Files";
  1422.     menus[1].top = "F2: Tasks";
  1423.     menus[2].top = "F3: Options";
  1424.  
  1425.     menus[0].texts[0]    = "Run Demos";
  1426.     menus[0].commands[0] = CMD_GO;
  1427.     menus[0].flags[0]    = 0;
  1428.     menus[0].texts[1]    = "Quit";
  1429.     menus[0].commands[1] = CMD_QUIT;
  1430.     menus[0].flags[1]    = 0;
  1431.     menus[0].texts[2]    = 0;
  1432.  
  1433.     /* Task menu */
  1434.     menus[1].texts[0]    = demo_control[DEMO_TASK_CSCAN].pause_menu;
  1435.     menus[1].commands[0] = CMD_PAUSE_CSCAN;
  1436.     menus[1].flags[0]    = ITEM_GREYED;
  1437.  
  1438.     /* The next group of tasks start in a paused state */
  1439.     menus[1].texts[1]    = demo_control[DEMO_TASK_SEEK].resume_menu;
  1440.     menus[1].commands[1] = CMD_RESUME_SEEK;
  1441.     menus[1].flags[1]    = ITEM_GREYED;
  1442.  
  1443.     /* Read has a delayed start but its starting state is on */
  1444.     menus[1].texts[2]    = demo_control[DEMO_TASK_READ].pause_menu;
  1445.     menus[1].commands[2] = CMD_PAUSE_READ;
  1446.     menus[1].flags[2]    = ITEM_GREYED;
  1447.  
  1448.     menus[1].texts[3]    = demo_control[DEMO_TASK_WRITE].resume_menu;
  1449.     menus[1].commands[3] = CMD_RESUME_WRITE;
  1450.     menus[1].flags[3]    = ITEM_GREYED;
  1451.  
  1452.     menus[1].texts[4]    = demo_control[DEMO_TASK_ASCAN].resume_menu;
  1453.     menus[1].commands[4] = CMD_RESUME_ASCAN;
  1454.     menus[1].flags[4]    = ITEM_GREYED;
  1455.  
  1456.     menus[1].texts[5]    = 0;
  1457.  
  1458.     /* Menus 2 Options. */
  1459.     menus[2].texts[0]    = "Use D: drive Instead of C:";
  1460.     menus[2].commands[0] = CMD_USE_D;
  1461.     menus[2].flags[0]    = 0;
  1462.     menus[2].texts[1]    = "Use B: drive Instead of A:";
  1463.     menus[2].commands[1] = CMD_USE_B;
  1464.     menus[2].flags[1]    = 0;
  1465.     menus[2].texts[2]    = "Use Ram Disk Instead Of Floppy";
  1466.     menus[2].commands[2] = CMD_USE_RD;
  1467.     menus[2].flags[2]    = 0;
  1468. #if 0
  1469.     menus[2].texts[3]    = "Use DOS For Read Performance Test   ";
  1470.     menus[2].commands[3] = CMD_USE_DOS;
  1471.     menus[2].flags[3]    = 0;
  1472.     menus[2].texts[4]    = 0;
  1473. #else
  1474.     menus[2].texts[3]    = 0;
  1475. #endif
  1476.     build_menu();
  1477.     display_top();
  1478. }
  1479.  
  1480. /* This routine is called do dispatch commands from the menus */
  1481. void command_dispatch(int command)                             /* __fn__ */
  1482. {
  1483.     if (!command)
  1484.         return;
  1485.    
  1486.     switch(command)
  1487.     {
  1488.         case CMD_GO:
  1489.             /* Start the process. Grey out start-up items. */
  1490. /*GO*/      menus[0].flags[0]    = 
  1491. /*D:B:&E:*/ menus[2].flags[0]    = 
  1492.             menus[2].flags[1]    = 
  1493.             menus[2].flags[2]    =  ITEM_GREYED;
  1494. /* pause C: */ menus[1].flags[0]    &=  ~ITEM_GREYED;
  1495.  
  1496.             signal(go_event);
  1497.             break;
  1498.         case CMD_QUIT:
  1499.             start(exitx);
  1500.             break;
  1501.         case CMD_USE_D:
  1502.             hd_drive_id  = "D:";
  1503.             break;
  1504.         case CMD_USE_B:
  1505.             fd_drive_id = "B:";
  1506.             menus[2].flags[1]    = 
  1507.             menus[2].flags[2]    =  ITEM_GREYED;
  1508.             break;
  1509.         case CMD_USE_RD:
  1510.             fd_drive_id  = "E:";
  1511.             menus[2].flags[1]    = 
  1512.             menus[2].flags[2]    =  ITEM_GREYED;
  1513.             break;
  1514.         case CMD_PAUSE_CSCAN:
  1515.         case CMD_PAUSE_SEEK:
  1516.         case CMD_PAUSE_READ:
  1517.         case CMD_PAUSE_WRITE:
  1518.         case CMD_PAUSE_ASCAN:
  1519.             if (!demo_control[(command & 0x0f)].suspended)
  1520.             {
  1521.                 menus[1].texts[(command & 0x0f)] = 
  1522.                     demo_control[(command & 0x0f)].resume_menu;
  1523.                 /* Hack. Change menu command from pause to resume */
  1524.                 menus[1].commands[(command & 0x0f)] -= 0x10;
  1525.                 menus[1].commands[(command & 0x0f)] |= 0x20;
  1526.  
  1527.                 /* Request it be suspended */
  1528.                 suspend_this_task =  demo_control[(command & 0x0f)].p_task;
  1529.                 /* And wait */
  1530.                 count(1, suspend_completed, SEC);
  1531.                 suspend_this_task =  (TCB_PTR) 0;
  1532.             }
  1533.             break;
  1534.         case CMD_RESUME_CSCAN:
  1535.         case CMD_RESUME_SEEK:
  1536.         case CMD_RESUME_READ:
  1537.         case CMD_RESUME_WRITE:
  1538.         case CMD_RESUME_ASCAN:
  1539.             if (demo_control[(command & 0x0f)].suspended)
  1540.             {
  1541.                 menus[1].texts[(command & 0x0f)] =
  1542.                      demo_control[(command & 0x0f)].pause_menu;
  1543.                 /* Hack. Change menu command from resume to pause */
  1544.                 menus[1].commands[(command & 0x0f)] -= 0x20;
  1545.                 menus[1].commands[(command & 0x0f)] |= 0x10;
  1546.                 demo_control[(command & 0x0f)].suspended = 0;
  1547.                 resume(demo_control[(command & 0x0f)].p_task);
  1548.             }
  1549.             break;
  1550.         default:
  1551.             break;
  1552.     }
  1553. }    
  1554.  
  1555. /* Other miscelanous control functions */
  1556.  
  1557. /* This is called from xmwin_epilogue in xmwin.c. The task must be locked on 
  1558.    entry.It suspends the current tasks and notes it in demo control structure 
  1559.    If requested it signals when the suspend is complete. This signaling
  1560.    mechanism is needed because opcon_main() asks the task to suspend and
  1561.    then waits for acknowledgement. This eliminates race conditions in the 
  1562.    menus.
  1563. */
  1564.  
  1565. void  fdemo_suspend_me(int do_signal)                             /* __fn__ */
  1566. {
  1567. int i;
  1568.     for (i = 0;i<MAXDEMOTASKS;i++)
  1569.     {
  1570.         if(demo_control[i].p_task == ct)
  1571.         {
  1572.             demo_control[i].suspended = 1;          /* yea */
  1573.             if (do_signal)
  1574.                 signal(suspend_completed);
  1575.             suspend(ct,INF);
  1576.             break;
  1577.         }
  1578.     }
  1579. }
  1580.  
  1581. /* Task error function. If called display the message in the tasks window
  1582.    and suspend forever */
  1583. void _cdecl xfd_error(char *p)                             /* __fn__ */
  1584. {
  1585. int i;
  1586. int j;
  1587. char display_buffer[70];
  1588.  
  1589.     for (i = 0; i < MAXDEMOTASKS; i++)
  1590.     {
  1591.         if (ct == demo_control[i].p_task)
  1592.         {
  1593.             /* Clear the window */
  1594.             memset(display_buffer,' ', 69);
  1595.             for (j = 1; j < demo_control[i].window->height-1; j++)
  1596.                 xmwin_wr_string(demo_control[i].window, 1, j, FGCOLOR, BGCOLOR, 
  1597.                                 display_buffer);
  1598.             xmwin_wr_string(demo_control[i].window, 1, 1, FGCOLOR, BGCOLOR, 
  1599.                             p);
  1600.             xmwin_wr_string(demo_control[i].window, 1, 2, FGCOLOR, BGCOLOR, 
  1601.                             "Bye.....");
  1602.             break;
  1603.         }
  1604.     }
  1605.     suspend(ct, INF);
  1606. }
  1607.  
  1608. /* These tasks don't do anything at the current time */
  1609. void _cdecl quit_appl()                                         /* __fn__ */
  1610. {
  1611. #if IDE_FLOPPY
  1612.     /* Restore interrupt vectors */
  1613.    fl_restore();
  1614. #endif
  1615.  
  1616.     /* Restore the screen */
  1617.     if (xfd_appl_win)
  1618.         xmwin_destroy(xfd_appl_win);
  1619.     clr_screen(LIGHTGRAY, BLACK);
  1620. }
  1621.  
  1622. void _cdecl show_etime()                                        /* __fn__ */
  1623. {
  1624.  
  1625. }
  1626.  
  1627.