开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
OS.cpp
资源名称：FileSystemdesign.rar　[点击查看]
上传用户：tinajin
上传日期：2014-01-19
资源大小：136k
文件大小：21k
源码类别：

操作系统开发

开发平台：

C/C++

OS.cpp：源码内容
  1. ////////////////////////////////////////////////////////////
  2. //  编译工具:Visual c++ 6.0                               //
  3. //                                                        //
  4. //  作者:~小楚*smill~ 、蓝色的天空                        //
  5. //  邮件:qvb20974151@163.com                              //
  6. //                                                        //
  7. //  复制、传播请保留作者信息，谢谢!                       //
  8. //                                                        //
  9. ////////////////////////////////////////////////////////////
  10. #include <stdio.h>
  11. #include <conio.h>
  12. #include <string.h>
  13. #include <stdlib.h>
  14. #include <time.h> 
  15. void fileCreate(char *fileName,int fileLenght);  //创建文件,文件最大长度为1万
  16. void fileDel(char *fileName);                    //删除文件
  17. void fileRead(char *fileName,int postion,int lenght);
  18. void fileWrite(char *fileName,int position,char *s);      //函数声明
  19. void fileAsk(char *fileName);                    //查询文件属性
  20. void fileType(char *fileName);                   //显示文件内容
  21. void fileRen(char *fileName,char *newName);      //重命名文件
  22. void fileDir();                                  //列出所有文件
  23. void fileClose(char *fileName);                  //关闭一个文件
  24. int  requestDisk(int *startPosition,int *maxLength); //分配磁盘空间
  25. /////////////////////////////////
  26. //模拟磁盘空间
  27. char disk[10000]; 
  29. ///////////////////////////////
  30. //磁盘空间管理 
  31. struct freeDiskTable 
  32. {
  33. int start;   //开始位置
  34. int length;  //占用长度
  35. int maxLength;  //最大长度
  36. int useFlag;    //使用标志，1为占用，0为空闲
  37. };
  38. //////////////////////////////////
  39. //文件表
  40. struct fileTable
  41. {
  42. char fileName[20];  //文件名字
  43. int start;          //开始位置
  44. int length;         //文件长度
  45. int maxLength;      //最大长度
  46.     char fileKind[8];   //文件种类,此默认为txt
  47. struct tm *timeinfo; //文件创建时间
  48. };
  49. ////////////////////////////////
  50. //打开文件表
  51. struct openFileTable
  52. {
  53. char fileName[20];   //文件名字
  54. char fileKind[8];    //文件类型
  55. int start;           //文件开始位置
  56. int length;          //文件长度
  57. int maxLength;       //最大长度
  58. int openCount;       //打开文件的进程数
  59. struct tm *timeinfo; //文件创建时间
  60. };
  61. //////////////////////////////
  62. typedef struct freeDiskTable LinDataType; //定义链表的数据类型
  63. #include "LinList.h"               //链表操作集合
  64. SLNode *freeDiskTableHead;         //定义磁盘分配表链表 头指针
  65. #define MaxSize 100                //定义线性表 最大长度
  66. typedef struct fileTable SeqDataType; //定义线性表数据类型
  68. #include "SeqList.h"           //线性表操作集合
  69. SeqList L; //文件表，模拟文件操作嘛，文件数不多，故可以用 线性表，简化操作^_^
  70. struct openFileTable OFT[10];  //打开文件表数组
  71. int OFT_count=0;               //打开文件表占用长度
  72. void main()
  73. {
  74. struct orderTable  //命令表
  75. {
  76. char name[8];  
  77. };
  78. char orderInput[30];   //存储用户输入的命令字符串
  79. char orderName[8];     //命令名字
  80. char fileName[20];    //命令参数1,是文件名字
  81. char parameter2[6];   //命令参数2,是个数字
  82. char parameter3[30];  //命令参数3，是字符串或数字
  83. struct orderTable u[9];  //命令表
  84. int i=0;                
  85. int flag=0;             //用户输入串 读写位置 标志
  86. int flagOrder=-1;
  87. /////////////////////////////////////
  88.     
  89. LinListInitiate(&freeDiskTableHead);//磁盘空间分配键表初始化
  90. struct freeDiskTable temp; 
  91. temp.length=0;
  92. temp.maxLength=10000;
  93. temp.start=0;
  94. temp.useFlag=0;
  95. if(!LinListInsert(freeDiskTableHead,0,temp))
  96. {
  97. printf("初始磁盘空闲表失败!");
  98. system("pause");
  99. exit(0);
  100. }
  101. /////////////////////////////////////
  102. //文件表初始化
  103. SeqListInitiate(&L); //初始化 文件表
  105. /////////////////////////////////////
  106. for(i=0;i<2;i++)           
  107. for(int j=0;j<2;j++)
  108. {
  109. system("color fc");
  110. printf("nnnnnnnnn                   作者：XXX 操作系统课程设计n");
  111. for(int k=0;k<30000000;k++);
  112. system("cls");
  113. system("color f3");
  114. printf("nnnnnnnnn                   作者：XXX 操作系统课程设计n");
  115. for(k=0;k<30000000;k++);
  116. system("cls");
  117. }
  118. system("color 17");     //设置背景色 和 前景色
  119. ////////////////////////////////////////////////////////////
  120. //初始化命令表
  121. strcpy(u[0].name,"create");
  122. strcpy(u[1].name,"delete");
  123. strcpy(u[2].name,"read");
  124. strcpy(u[3].name,"write");
  125. strcpy(u[4].name,"ask");
  126. strcpy(u[5].name,"type");
  127. strcpy(u[6].name,"ren");
  128. strcpy(u[7].name,"dir");
  129. strcpy(u[8].name,"close");
  130. ////////////////////////////////////////////////////////////
  131. while(1)
  132. {
  133. printf("n");
  134. printf("|******************************************************|n");
  135. printf("|* create-创建 delete-删除 read-读取  write-写入      *|n");
  136. printf("|* ask-查询    type-显示   ren-重命名 dir-显示文件    *|n");
  137. printf("|* close-关闭文件                                     *|n");
  138. printf("|* 输入'命令 ?'获得帮助，例如'create ?',exit-退出程序 *|n");
  139. printf("|******************************************************|n");
  140. printf("请输入命令:>");
  141. fflush(stdin);      //清空缓冲区
  142. gets(orderInput);   //获取用户输入串
  143. if(!strcmp(orderInput,"exit"))exit(0); //当用户输入 exit 退出程序
  144. system("cls");     //清屏
  145. for(i=0;orderInput[i]!=' '&&orderInput[i]!='';i++)//以空格为界 分解用户输入串
  146. {
  147. orderName[i]=orderInput[i];
  148. }
  149. flag=i;//保存读写指针
  150. if(flag>6)        //命令名长度 小于6
  151. {
  152. printf("输入的命令有误，请重新输入!n");
  153. continue ;
  154. }
  155. orderName[i]='';
  157. flagOrder=-1;  //初始化标志位，flagOrder 指明命令在命令表中的位置
  158. for(i=0;i<9;i++)
  159. {
  160. if(!strcmp(orderName,u[i].name))
  161. {
  162. flagOrder=i;   //记录命令的位置，以便访问
  163. break;
  164. }
  165. }
  166. if(flagOrder==-1)
  167. {
  168. printf("你输入的命令有误!请重新输入!n");
  169. continue ;
  170. }
  171. /////////////////////////////////////////////////////
  172. //以空格为界，分解字符串,分解出第一个字符串放到fileName中
  173. for(i=flag+1;orderInput[i]!=' '&&orderInput[i]!='';i++)
  174. {
  175. fileName[i-flag-1]=orderInput[i];
  176. }
  177. fileName[i-flag-1]=''; //为字符串数组 置一个结束标志
  178. /////////////////////////////////////////////////////
  179. flag=i;                   //下一个字符串 读写指针
  180. if(!strcmp(fileName,"?")) //显示命令帮助
  181. {
  182. switch(flagOrder)
  183. {
  184. case 0: 
  185. printf("创建一个文件 格式 create [filename][filelength]n");
  186. printf("例如: create a1 1000 ,将创建名为a1,长度为1000字节的文件n");
  187. break;
  188. case 1:
  189. printf("删除一个文件 格式 delete [filename] n");
  190. printf("例如: delete a1,将删除名为a1的文件n");
  191. break;
  192. case 2: 
  193. printf("读取一个文件 格式 read [filename][postion][length]n");
  194. printf("例如: read a1 8 3,从a1文件第8个字节开始，显示3字节内容n");
  195. break;
  196. case 3:
  197. printf("写一个文件   格式 write [fileName][postion][conten] n");
  198. printf("例始: write a1 15 test,从a1文件第15字节开始写入 test 字符串n");
  199. break;
  200. case 4:
  201. printf("显示文件的属性,格式 ask [filename]n");
  202.     printf("例如 ask a1 ,将显示文件 a1的属性n");
  203. break;
  204.             case 5:
  205. printf("显示文件的所有内容,格式 type [filename]n");
  206. printf("例如 type a1,将显示文件 a1的所有内容n");
  207. break;
  208. case 6:
  209. printf("重命名一个文件,格式 ren [oldFileName][newFileName]n");
  210. printf("例如ren a1 b1 ,将a1改名为b1n");
  211. break;
  212. case 7:
  213. printf("显示所有文件,例如 dir,将显示所有文件n");
  214. break;
  215. case 8:
  216. printf("关闭文件，格式 close [fileName]n");
  217. printf("例如,close a1,将关闭文件a1n");
  218. break;
  219. default:
  220. printf("命令错误");
  221. }
  222. getch();
  223. }
  224. else
  225. {
  226. switch(flagOrder)//对相应的命令 进行参数处理
  227. {
  228. case 0:
  229. {
  230. int Temp[4]={1,10,100,1000};
  231. int sum=0;
  232. int len=0;
  233. for(i=flag+1;orderInput[i]!=' '&&orderInput[i]!='';i++)
  234. {
  235. parameter2[i-flag-1]=orderInput[i];
  236. }
  237. parameter2[i-flag-1]=''; //为字符串数组 置一个结束标志
  238. flag=i; 
  239. len=strlen(parameter2); //求字符串数组的长度
  240. for(i=0;i<len;i++)  //把第二个参数 字符串变成整数
  241. sum=sum+((int)parameter2[len-i-1]-48)*Temp[i];
  242. fileCreate(fileName,sum); //将命令和参数 传给建文件模块执行
  243. }
  244. break;
  245. case 1:
  247. fileDel(fileName); //删除文件
  248.       break;
  249. case 2:
  250. {
  251. int Temp[4]={1,10,100,1000};
  252. int sum=0;
  253. int len=0;
  254. int sum2=0;
  255. //////////////////////////////////////////////////////////
  256. for(i=flag+1;orderInput[i]!=' '&&orderInput[i]!='';i++)
  257. {
  258. parameter2[i-flag-1]=orderInput[i];
  259. }
  260. parameter2[i-flag-1]='';
  261. flag=i; 
  262. len=strlen(parameter2); //求字符串数组的长度
  263. for(i=0;i<len;i++)  //把第二个参数 字符串变成整数
  264. sum=sum+((int)parameter2[len-i-1]-48)*Temp[i];
  265. ///////////////////////////////////////////////////////////
  266. for(i=flag+1;orderInput[i]!=' '&&orderInput[i]!='';i++)
  267. {
  268. parameter3[i-flag-1]=orderInput[i]; //把第三个参数变成整型
  269. }
  270. parameter3[i-flag-1]='';
  271. flag=i; 
  272. len=strlen(parameter3);
  273. for(i=0;i<len;i++)
  274. sum2=sum2+((int)parameter3[len-i-1]-48)*Temp[i];
  275. fileRead(fileName,sum,sum2); //调用读文件模块
  277. }
  278. break;
  279. case 3:
  280. {
  281. int Temp[4]={1,10,100,1000};
  282. int sum=0;
  283. int len=0;
  284. //////////////////////////////////////////////////////////
  285. for(i=flag+1;orderInput[i]!=' '&&orderInput[i]!='';i++)
  286. {
  287. parameter2[i-flag-1]=orderInput[i];
  288. }
  289. parameter2[i-flag-1]='';
  290. flag=i; 
  291. len=strlen(parameter2); //求字符串数组的长度
  292. for(i=0;i<len;i++)  //把第二个参数 字符串变成整数
  293. sum=sum+((int)parameter2[len-i-1]-48)*Temp[i];
  294. ///////////////////////////////////////////////////////////
  295. for(i=flag+1;orderInput[i]!=' '&&orderInput[i]!='';i++)
  296. {
  297. parameter3[i-flag-1]=orderInput[i]; //获取第三个参数，为字符串
  298. }
  299. parameter3[i-flag-1]='';
  300. flag=i; 
  301. //////////////////////////////////////////////////////////
  302. fileWrite(fileName,sum,parameter3); //调用写文件模块
  303. }
  304.                 break;
  305. case 4:
  306. fileAsk(fileName); //查询文件属性
  307. break;
  308. case 5:
  309. fileType(fileName);    //显示文件内容
  310. break;
  311. case 6:
  312. {
  313. for(i=flag+1;orderInput[i]!=' '&&orderInput[i]!='';i++)
  314. {
  315. parameter2[i-flag-1]=orderInput[i];
  316. }
  317. parameter2[i-flag-1]='';
  318. flag=i; 
  319. fileRen(fileName,parameter2);
  320. }
  321. break;
  322. case 7:
  323. fileDir();
  324. break;
  325. case 8:
  326. fileClose(fileName);
  327. break;
  328. default:
  329. printf("错误!没有可执行的命令");
  330. }
  331. }
  333. }
  334. }
  335. //以上主函数，主函数进行数据结构的定义 分析用户输入的命令。
  336. //提供命令帮助。把命令和参数，传递给执行模块
  337. //////////////////////////////////////////////////////////////////////
  338. void fileCreate(char *fileName,int fileLength)//没有写到打开文件表
  339. {
  341. int i=0;
  342. time_t rawtime;
  343. int startPosition=0; //文件开始位置，等磁盘分配函数 返回值
  344. int maxLength=fileLength;
  345. struct fileTable temp;
  346. for(i=0;i<L.size;i++)
  347. if(!strcmp(fileName,L.list[i].fileName)) //判断是否重名，如果重名直接返回
  348. {
  349. printf("文件重名，请取别的名字!n");
  350. return ; //文件重名，退出创建函数
  351. }
  352.     if(!requestDisk(&startPosition,&maxLength))
  353. {
  354. printf("申请磁盘空间失败!无法建立文件!n");
  355. return ; //申请磁盘空间失败，退出创建函数
  356. }
  357. strcpy(temp.fileName,fileName); 
  358. strcpy(temp.fileKind,"txt"); //设置文件类型为 txt
  359. temp.length=0;               //创建的时候，还没写入内容，是空文件，长度设为0
  360. temp.maxLength=fileLength;  //文件的最大长度
  361. temp.start=startPosition;   //文件的开始位置
  363. time(&rawtime); //获取时间
  364. temp.timeinfo=localtime(&rawtime); //把时间写到结构体里去
  366. if(!SeqListInsert(&L,L.size,temp)) //把文件 插入到文件表
  367. {
  368. printf("插入文件表失败!n");
  369. system("pause");
  370. exit(0); //把文件插入到 文件表，如果失败，退出程序
  371. }
  372. printf("成功创建文件!nn");
  373. printf("===========================================n");
  374. printf("文件名    长度    最大长度   类型  开始位置n");//显示刚建立的文件
  375. printf("%s     ",temp.fileName);
  376. printf("%d       ",temp.length);
  377. printf("%d      ",temp.maxLength);
  378. printf("%s    ",temp.fileKind);
  379. printf("%d    ",temp.start);
  380. printf("n===========================================n");
  381. printf("create进程打开了文件%s,关闭请用close命令!nn",fileName);
  382. //写到打开文件表
  383. strcpy(OFT[OFT_count].fileName,temp.fileName);
  384. strcpy(OFT[OFT_count].fileKind,temp.fileKind);
  385. OFT[OFT_count].length=temp.length;
  386. OFT[OFT_count].maxLength=temp.maxLength;
  387. OFT[OFT_count].start=temp.start;
  388. OFT[OFT_count].openCount=1;
  389. OFT[OFT_count].timeinfo=temp.timeinfo;
  390. OFT_count++;                    //打开表 记录的是文件数 
  391. //printf("count%d",OFT_count);
  393. }
  394. void fileDel(char *fileName)
  395. {
  396. int i;
  397. int flag=0;    
  398. int k=0;       //记录文件在 文件表中的位置
  399. SLNode *p;    //磁盘空间分配表 指针
  400. SeqDataType x; //存储被删除的结点，无特殊意义
  401. for(i=0;i<OFT_count;i++) //判断是否被别的进程占用，若被占用，打印出错，直接返回
  402.    if(!strcmp(fileName,OFT[i].fileName))
  403. {
  404. printf("别的进程占用文件!无法删除!");
  405. return ;
  406. }
  407. for(i=0;i<L.size;i++)//从文件表里查找到要删除的文件，若查找不到，直接返回
  408. {
  409. if(!strcmp(fileName,L.list[i].fileName))
  410. {
  411. flag=1;
  412. k=i;
  413. break;
  414. }
  415. }
  416. if(flag==0)
  417. {
  418. printf("无此文件!");
  419. return ;
  420. }
  421. if(flag==1)//查找到文件后，把磁盘空间置为空闲,之后从文件表中删除
  422. {
  423. for(p=freeDiskTableHead;p->next!=NULL;p=p->next)
  424. {
  425. if(p->next->data.start==L.list[k].start)
  426. {
  427. p->next->data.useFlag=0;
  428. printf("成功删除!n");
  429. break;
  430. }
  431. }
  432. SeqListDelete(&L,k,&x);//从文件表中删除
  433. }
  434. }
  435. void fileRead(char *fileName,int position,int length)
  436. {
  437. int i;
  438. int flag=0;
  439. int k=0;
  440. for(i=0;i<OFT_count;i++)   //查找文件打开表，如果存在，则不需要再查找文件表
  441. {
  442. if(!strcmp(fileName,OFT[i].fileName))
  443. {
  444. k=i;
  445. flag=1;
  446. OFT[i].openCount++;//多个进程打开，计算器加1
  447. break;
  448. }
  449. }
  450. if(flag!=1) //文件不在打开表，找到它，并写到打开表最后
  451. {
  452. for(i=0;i<L.size;i++)
  453. {
  454. if(!strcmp(fileName,L.list[i].fileName)) //找到文件，写到文件打开表
  455. {
  456. strcpy(OFT[OFT_count].fileName,L.list[i].fileName);
  457. strcpy(OFT[OFT_count].fileKind,L.list[i].fileKind);
  458. OFT[OFT_count].length=L.list[i].length;
  459. OFT[OFT_count].maxLength=L.list[i].maxLength;
  460. OFT[OFT_count].start=L.list[i].start;
  461. OFT[OFT_count].timeinfo=L.list[i].timeinfo;
  462. OFT[OFT_count].openCount++;
  463. k=OFT_count;
  464. //OFT_count=1;//初次打开，赋值为1
  465. flag=1; //标志在打开文件表里
  466. }
  467. }
  468. }
  469. if(flag==1)
  470. {
  471. if(position<0||position+length>OFT[k].length)
  472. {
  473. printf("读取参数错误,请检查参数!n");
  474. return ;
  475. }
  476. for(i=0;i<length;i++)
  477. printf("%c",disk[OFT[k].start+position+i-1]); //读取内容
  478. printf("nread进程打开了文件%s,关闭请用close命令!nn",fileName);
  479. }
  481. }
  482. void fileWrite(char *fileName,int position,char *s)//找到文件，写到打开表，根据打开表操作
  483. {
  484. int i=0;
  485. int len=0; //计算写入字串长度，跟原来长度相加，如果超过最大长度，就失败
  486. int k=0;   //如果在 打开表里打到记录，则记录位置
  487. int flag=0; //如果flag=1，说明在打开表里找到了，不用在文件表里找了
  488. len=strlen(s);
  489. for(i=0;i<OFT_count;i++)
  490. {
  491. if(!strcmp(fileName,OFT[i].fileName))
  492. {
  493. k=i;
  494. flag=1;
  495. OFT[i].openCount++;//多个进程打开，计算器加1
  496. break;
  497. }
  498. }
  499. if(flag!=1) //文件不在打开表，找到它，并写到打开表最后
  500. {
  501. for(i=0;i<L.size;i++)
  502. {
  503. if(!strcmp(fileName,L.list[i].fileName)) //找到文件，写到文件打开表的最后
  504. {
  505. strcpy(OFT[OFT_count].fileName,L.list[i].fileName);
  506. strcpy(OFT[OFT_count].fileKind,L.list[i].fileKind);
  507. OFT[OFT_count].length=L.list[i].length;
  508. OFT[OFT_count].maxLength=L.list[i].maxLength;
  509. OFT[OFT_count].start=L.list[i].start;
  510. OFT[OFT_count].timeinfo=L.list[i].timeinfo;
  511. OFT[OFT_count].openCount++;
  512. k=OFT_count;                  //记录在文件打开表中的位置
  513. flag=1; //标志在打开文件表里
  515. }
  516. }
  517. }
  518. if(1==flag)  //如果在打开表里 找到文件，则不用再找文件表
  519. {
  520. if(OFT[k].length+len>OFT[k].maxLength)
  521. {
  522. printf("超过文件最大长度，写入失败!n");
  523. return ;
  524. }
  525. else if(position<0||position>OFT[k].length)
  526. {
  527. printf("插入位置非法!请检查参数n");
  528. return ;
  529. }
  530. else
  531. {
  532. int j=0;
  533. for(i=OFT[k].length-1;i>=OFT[k].start+position;i--)
  534. disk[i+len]=disk[i];  //给插入的字符串 空出位置
  535. for(i=OFT[k].start+position;i<OFT[k].start+position+len;i++,j++)
  536. disk[i]=s[j];       //写进磁盘
  537. for(i=0;i<L.size;i++)     //改变文件长度
  538. {
  539. if(!strcmp(fileName,L.list[i].fileName))
  540. {
  541. L.list[i].length=L.list[i].length+len;  //设置文件长度
  542. break;
  543. }
  544. }
  545.             OFT[k].length=OFT[k].length+len;   //同时更新打开文件表中文件的长度
  546. printf("成功写入!n");
  547. printf("write进程打开了文件%s,关闭请用close命令!nn",fileName);
  548. }
  549. }
  550. else
  551. printf("无此文件，请输入正确的文件名!");
  552. }
  553. void fileAsk(char *fileName)
  554. {
  555. int i;
  556. int flag=0;
  557. for(i=0;i<OFT_count;i++)    //如果在打开表里 找到文件，则不用再找文件表
  558. {
  559. if(!strcmp(fileName,OFT[i].fileName))
  560. {
  561. printf("文件名:%sn",OFT[i].fileName);
  562. printf("类型:%sn",OFT[i].fileKind);
  563. printf("长度:%dn",OFT[i].length);
  564. printf("打开进程数:%dn",OFT[i].openCount);
  565. printf("创建时间:%sn",asctime(OFT[i].timeinfo));
  566. flag=1;
  567. break;
  568. }
  569. }
  570. if(flag!=1)
  571. {
  572. for(i=0;i<L.size;i++)  //从文件表里查找文件
  573. {
  574. if(!strcmp(fileName,L.list[i].fileName))
  575. {
  576. printf("文件名:%sn",L.list[i].fileName);
  577. printf("类型:%sn",L.list[i].fileKind);
  578. printf("长度:%dn",L.list[i].length);
  579. printf("创建时间:%sn",asctime(L.list[i].timeinfo));
  580. flag=1;
  581. break;
  582. }
  584. }
  585. }
  586. if(flag==0)
  587. printf("无此文件!n");
  588. }
  589. void fileType(char *fileName)
  590. {
  591. int i;
  592. int flag=0;
  593. int k=0;
  594. for(i=0;i<OFT_count;i++)
  595. {
  596. if(!strcmp(fileName,OFT[i].fileName))
  597. {
  598. k=i;
  599. flag=1;
  600. OFT[i].openCount++;//多个进程打开，计算器加1
  601. break;
  602. }
  603. }
  604. if(flag!=1) //文件不在打开表，找到它，并写到打开表最后
  605. {
  606. for(i=0;i<L.size;i++)
  607. {
  608. if(!strcmp(fileName,L.list[i].fileName)) //找到文件，写到文件打开表
  609. {
  610. strcmp(OFT[OFT_count].fileName,L.list[i].fileName);
  611. strcmp(OFT[OFT_count].fileKind,L.list[i].fileKind);
  612. OFT[OFT_count].length=L.list[i].length;
  613. OFT[OFT_count].maxLength=L.list[i].maxLength;
  614. OFT[OFT_count].start=L.list[i].start;
  615. OFT[OFT_count].timeinfo=L.list[i].timeinfo;
  616. OFT[OFT_count].openCount++;
  617. k=OFT_count;
  618. //OFT_count=1;//初次打开，赋值为1
  619. flag=1; //标志在打开文件表里
  620. }
  621. }
  622. }
  623. if(flag==1)
  624. {
  625. for(i=0;i<OFT[k].length;i++)
  626. printf("%c",disk[OFT[k].start+i]); //显示全部内容
  627. if(OFT[k].length==0)
  628. printf("文件为空，无内容显示!n");
  629. printf("n===========================================n");
  630. printf("ncreate进程打开了文件%s,关闭请用close命令!nn",fileName);
  631. // printf(",,,,n");
  632. // printf("OFT[k].length %dn",OFT[k].length);
  633. }
  634. else
  635. printf("无此文件，请检查文件名!n");
  636. }
  637. void fileRen(char *fileName,char *newName)
  638. {
  639. int i=0;
  640. int flag=0;
  641. for(i=0;i<OFT_count;i++) //若还有别的进程打开文件，刚不能重命名
  642.    if(!strcmp(fileName,OFT[i].fileName))
  643. {
  644. printf("别的进程占用文件!无法重命名!n");
  645. return ;
  646. }
  647. for(i=0;i<L.size;i++)   //在文件表里找到，并重命名
  648. if(!strcmp(fileName,L.list[i].fileName))
  649. {
  650. strcpy(L.list[i].fileName,newName);
  651. flag=1;
  652. break;
  653. }
  654. if(flag==1)
  655. printf("重命名成功!n");
  656. else
  657. printf("重命名失败！无此文件n");
  659. }
  660. void fileDir()
  661. {
  662. int i;
  663. if(L.size==0)  //文件表的 大小为0，说明没有文件
  664. {
  665. printf("磁盘无文件!n");
  666. return ;
  667. }
  668. for(i=0;i<L.size;i++)   //打印所有文件名
  669. printf("%sn",L.list[i].fileName); 
  671. }
  672. void fileClose(char *fileName)
  673. {
  674. int i;
  675. int flag=0;
  676. int j;
  677. for(i=0;i<OFT_count;i++)
  678. {
  679. if(!strcmp(fileName,OFT[i].fileName)) //在文件打开表里找到，把打开数减1，
  680.                                   //如果计数为0，显示关闭成功!
  681. {
  682. OFT[i].openCount--;
  683. flag=1;
  684. if(OFT[i].openCount==0)
  685. {
  686. for(j=i;j<OFT_count;j++)
  687. OFT[j]=OFT[j+1]; //删除要关闭的文件
  688. OFT_count--;
  689. printf("成功关闭文件!n");
  690. }
  691. else
  692. printf("计数器减1n");
  693. break;
  694. }
  695. }
  696. if(flag==0)
  697. printf("此文件没有打开!n");
  699. }
  700. ///////////////////////////////
  701. //磁盘空间管理 操作
  702. int requestDisk(int *startPosistion,int *maxLength)
  703. {
  704. struct freeDiskTable temp;
  705. int flag=0; //分配成功与否标志
  706. int k=0; //记录插入位置
  707.     SLNode *p=NULL;
  708. for(p=freeDiskTableHead;p->next!=NULL;p=p->next)
  709. {
  710. k++;//记录位置，在空闲结点之后插入结点
  711. if(p->next->data.useFlag==0&&p->next->data.maxLength>=*maxLength)
  712. {
  713. temp.length=0;
  714. temp.maxLength=p->next->data.maxLength-*maxLength;
  715. temp.start=p->next->data.start+*maxLength;
  716. temp.useFlag=0;     //分解节点
  717. //=========================================
  718. p->next->data.maxLength=*maxLength;
  719. p->next->data.useFlag=1;   //设置分配的空间标志位
  720. *startPosistion=p->next->data.start;
  721. flag=1;//成功分配
  722. break;
  724. }
  726. }
  728.     if(1==flag)  //成功分配空间，返回成功标志
  729. {
  730. if(!LinListInsert(freeDiskTableHead,k,temp))
  731. {
  732. printf("失败!n");
  733. system("pause");
  734. exit(0);
  735. }
  736. return 1;
  737. }
  738. else
  739. return 0;
  740. }
  741. ///////////////////////////////////////////////////