→ Для вступления в общество новичков и профессионалов программирования, пожалуйста нажмите здесь ...

Форум программистов: C++, Basic, Delphi, Pascal, JavaScript
Логин: Пароль:
Запомнить?  
@Mail.ru



Начать новую тему Ответить на тему  [ 1 сообщение ] 
помощь запуск программы на С++ 
Автор Сообщение
Начинающий

Регистрация: 06.05.2011
Сообщения: 2
Языки:
Специальность:

Репутация: 0 [ ? ]
Сообщение помощь запуск программы на С++
есть рабочая прога -доступ к объектам файл сист FAT-
на Borlandc но она не находит у меня диски с FAT,и на вирт машине
под FAT тоже пробовал нет дисков
вот прога

/******************************************************************
Контрольная работа
Задание: Вывод на экран всех пустых директорий по указанному
логическому диску
******************************************************************/

#include<ctype.h>
#include<dir.h>
#include<dos.h>
#include<stdio.h>
#include<string.h>
#include<process.h>
#include<conio.h>
#include<malloc.h>

static int NumDisk;
char dir[8];
char path[MAXPATH];

typedef struct Node
{
char Data[37];
char attrib;
long StartSector;
struct Node far *PrevPtr;
struct Node far *NextPtr;
}
far ListNode;
static ListNode far *HeadPtr, *CurPtr, *NewPtr, *TempPtr; //общие

struct PTable
{
unsigned char priz;
char head_b;
unsigned int track_b;
unsigned char s_code;
char head_e;
unsigned int track_e;
long StartSector;
long size;
};
struct
{
char reserved[0x1BE];
struct PTable PT[4];
int sig;
} MBR;

struct
{
char JMPCODE[3]; // JMP на код загрузчика
char OS[8]; // название ОС, под которой форматировался диск
unsigned int bpersect; // байт в секторе
unsigned char sperclust; // секторов в кластере
unsigned int reservsect; // кол-во зарезервированных секторов
unsigned char numFAT; // кол-во копий FAT
unsigned int maxDirEntry; // кол-во элементов корневого каталога
unsigned int SmallSize; // размер в секторах (для диска>32Mb=0)
char MediaDescriptor; // описатель среды
unsigned int sectinFAT16; // кол-во секторов занимаемых FAT
unsigned int sectpertrack; // секторов на дорожке
unsigned int heads; // кол-во головок
long HiddenSect; // кол-во скрытых секторов
long int size; // размер в секторах для диска>32Mb. Для FAT32 резерв
unsigned int sectinFAT32; // для FAT32 кол-во секторов, занимаемых FAT
// для FAT12/16 старший байт - резерв,
// младший - тип устройства
char reserv1[6]; // резерв
long startclust; // начальный кластер корня
int BigFS; // начальный сектор FS (обычно=1)
int BootCopy; // номер сектора с копией ВООТ
char reserv2[12]; // резерв
char PhysNum; // физический номер устройства
char reserv3; // резерв
char ExtSign; // расширенная сигнатура
long SerNum; // серийный номер диска
char Label[11]; // метка диска
char fatID2[8]; // идентивикатор FAT ('FAT32 ')
char reserv6[0x1A6]; // код загрузчика
} BOOT;
struct DirEntry
{
unsigned char fn; // признак или первая буква имени
char Name[7]; // остальные 7 символов имени
char ext[3]; // расширение
char attr; // поле атрибутов
char reserv[8]; // резерв
unsigned int extclust; // старшая часть номера первого кластера(FAT32)
int time; // время последней модификации файла
int date; // дата последней модификации файла
unsigned int begclust; // младшая часть номера первого кластера(FAT32)
long size; // размер файла в байтах
};
struct DirEntry ROOT[16];
struct
{
int drv;
long ss;
} SSA[26]={0};

/****************************************************************/
//чтение с диска drive сектора sect в buf
int readsector(char drive,long sect, void *buf)
{
union REGS reg;
struct SREGS segreg;
struct
{ unsigned char Len10h;
unsigned char Res1;
unsigned int NumBlock;
unsigned int BufOff;
unsigned int BufSeg;
unsigned long Sect;
unsigned long Res2;
} stack = {0};
stack.Len10h = 0x10;
stack.NumBlock = 1;
stack.BufOff = FP_OFF (buf);
stack.BufSeg = FP_SEG (buf);
stack.Sect = sect;

reg.h.ah = 0x42;
reg.h.dl = drive;
reg.x.si = FP_OFF(&stack);
segreg.ds = FP_SEG(&stack);
int86x (0x13, &reg, &reg, &segreg);
if (reg.x.cflag) return reg.h.ah;
return 0;

}
/****************************************************************/
//поиск следующего кластера по цепочке FAT (для FAT32)
long FATclst(char hdd, long sshdd, long Nclust)
{
long nsect, //номер сектора от начала FAT
sect, // номер сектора
offs; //смещение от начала сектора
long *buffer;
unsigned long clst; //номер кластера

clst=Nclust; //clst-номер текущего кластера
nsect=(long)(clst/(BOOT.bpersect>>2)); //определение номера сектора
offs=((clst<<2) % BOOT.bpersect)>>2; //и смещения от начала сектора
sect=sshdd+BOOT.reservsect+nsect; //определение номера сектора
buffer = (long *) calloc (BOOT.bpersect>>2,4);
//чтение сектора
readsector(hdd,sect,buffer);
clst=buffer[offs];
free(buffer);
//проверка на конец цепочки
if ((clst>=0x0FFFFFF8)&&(clst<=0x0FFFFFFF)) return(0);
else
//проверка на пустой или BAD кластер
if ((clst==0x0FFFFFF7)||(clst==0)) return(-1);

return(clst); //возвращаем номер кластера
}

/****************************************************************/
//переводит номер сектора в номер кластера
long sect2clst(long sect)
{
sect=(sect-BOOT.reservsect-BOOT.sectinFAT32*BOOT.numFAT)/BOOT.sperclust+2;
return sect;
}
/****************************************************************/
//переводит номер кластера в номер сектора
long clst2sect(long clst)
{
clst=(clst-2)*BOOT.sperclust+BOOT.reservsect+BOOT.sectinFAT32*BOOT.numFAT;
return clst;
}
/****************************************************************/
//определяет диски
void DISK_DETECT()
{
char flag,drive='B',ndrv;
char name[MAXDIR];
int i,j,n,s,size,drv=0x80;
long sect=0,sbuf,clst;

ndrv=peekb(0x40,0x75);
printf("===================== D I S C M A P ==========================\n");
printf("? Drive ? Letter ? Activity ? System ? First sector ? Size(Mb) ?\n");
for(i=drv;i<drv+ndrv;i++) //поиск по дискам загрузочного раздела
{
flag=0;
readsector(i,sect,&MBR);
for(j=0;j<4;j++)
{
s=MBR.PT[j].s_code;
if((MBR.PT[j].priz == 0x80)&&(s==1||s==4||s==6||s==0xB||s==0xC||s==0xE))
{
flag=1; drive++; size=MBR.PT[j].size/2048;
SSA[drive-0x43].drv=i;
SSA[drive-0x43].ss=MBR.PT[j].StartSector;
printf("? %.2X ? %c: ? %.2X ? %.2X ? %9lu ? %6u ?\n",i,drive,MBR.PT[j].priz,s,MBR.PT[j].StartSector,size);
break;
}
}
if(!flag) //если загрузочный раздел не найден, поиск раздела FAT на диске
{
for(j=0;j<4;j++)
{
s=MBR.PT[j].s_code;
if((s==1||s==4||s==6||s==0xB||s==0xC||s==0xE))
{
size=MBR.PT[j].size/2048;
drive++;
SSA[drive-0x43].drv=i;
SSA[drive-0x43].ss=MBR.PT[j].StartSector;
printf("? %.2X ? %c: ? %.2X ? %.2X ? %9lu ? %6u ?\n",i,drive,MBR.PT[j].priz,s,MBR.PT[j].StartSector,size);
break;
}
}
}
}
for(i=drv;i<drv+ndrv;i++) //поиск по дискам расширеных разделов
{
readsector(i,sect=0,&MBR);
for(j=0;j<4;j++)
{
s=MBR.PT[j].s_code;
if(s==5||s==0xF)
{
sect=MBR.PT[j].StartSector;
sbuf=MBR.PT[j].StartSector;
for(;;)
{
readsector(i,sect,&MBR);
s=MBR.PT[0].s_code;
if(s==1||s==4||s==6||s==0xB||s==0xC||s==0xE)
{
drive++; size=MBR.PT[0].size/2048;
SSA[drive-0x43].drv=i;
SSA[drive-0x43].ss=sect+MBR.PT[0].StartSector;
printf("? %.2X ? %c: ? %.2X ? %.2X ? %9lu ? %6u ?\n",i,drive,MBR.PT[0].priz,s,sect+MBR.PT[0].StartSector,size);
}
if(!MBR.PT[1].s_code) break;
sect=sbuf+MBR.PT[1].StartSector;
}
}
}
}
for(i=drv;i<drv+ndrv;i++) //поиск по дискам остальных разделов
{
readsector(i,sect=0,&MBR);
for(j=0;j<4;j++)
{
flag=0;
for(n=0;n<=25;n++) if(SSA[n].ss==MBR.PT[j].StartSector&&SSA[n].drv==i) flag=1;
s=MBR.PT[j].s_code;
if((!flag)&&(s==1||s==4||s==6||s==0xB||s==0xC||s==0xE))
{
drive++; size=MBR.PT[j].size/2048;
SSA[drive-0x43].drv=i;
SSA[drive-0x43].ss=sect+MBR.PT[j].StartSector;
printf("? %.2X ? %c: ? %.2X ? %.2X ? %9lu ? %6u ?\n",i,drive,MBR.PT[j].priz,s,sect+MBR.PT[j].StartSector,size);
}
}
}
}
/****************************************************************/
void MEMFREE()
{
while (HeadPtr != NULL)
{
NewPtr = HeadPtr->NextPtr;
farfree (HeadPtr);
HeadPtr = NewPtr;
}
}

/***************************************************************/
int BrowseFolder(long Sect, int nHDD, long ssHDD) //n-кол-во вложений
{
struct DirEntry DISCR[16];

int s,i,j;
long sbuf,clst,StartSector;
int NumElem;

readsector(nHDD,ssHDD,&BOOT);
if (Sect<(ssHDD+clst2sect(BOOT.startclust)))
Sect=ssHDD+clst2sect(BOOT.startclust);

clst=sect2clst(Sect-ssHDD);
i=0; s=0;
readsector(nHDD,Sect,&DISCR); //чтение каталога
NumElem=0;
do
{
if(i>=BOOT.bpersect/32) //достигнута граница сектора
{
s++;
if(s==BOOT.sperclust) //достигнута граница кластера
{
s=0;
sbuf=sect2clst(Sect-ssHDD);
clst=FATclst(nHDD, ssHDD, sbuf);
Sect=ssHDD+clst2sect(clst);
}
else Sect++;
readsector(nHDD,Sect,&DISCR);
i=0;
}

//поиск элементов директории
if(DISCR[i].fn!=0 && DISCR[i].fn!=0xE5 && DISCR[i].fn!='.' && DISCR[i].attr!=0x8)
{
if (DISCR[i].attr!=0xF);
{
NumElem++;
}
}
i++;
} while (clst);

return NumElem;
}

/***************************************************************/
int CurrentFolder(long Sect, int nHDD, long ssHDD)
{
struct DirEntry DISCR[16];

char flag, attrib, offset, *sym;
char rez[37]="", name[MAXDIR];
int YEAR, MONTH, pos;
int s,i,j;
long sbuf,clst,StartSector;
char size[8],date[8],time[5];
char SYM;
readsector(nHDD,ssHDD,&BOOT);
if (Sect<(ssHDD+clst2sect(BOOT.startclust)))
Sect=ssHDD+clst2sect(BOOT.startclust);

clst=sect2clst(Sect-ssHDD);
i=0; s=0;
readsector(nHDD,Sect,&DISCR); //чтение каталога
do
{
if(i>=BOOT.bpersect/32) //достигнута граница сектора
{
s++;
if(s==BOOT.sperclust) //достигнута граница кластера
{
s=0;
sbuf=sect2clst(Sect-ssHDD);
clst=FATclst(nHDD, ssHDD, sbuf);
Sect=ssHDD+clst2sect(clst);
}
else Sect++;
readsector(nHDD,Sect,&DISCR);
i=0;
}

//поиск элементов директории
if(DISCR[i].fn!=0 && DISCR[i].fn!=0xE5 && DISCR[i].fn!='.' && DISCR[i].attr!=0x8)
{
if (DISCR[i].attr!=0xF);
{
//Если это директория
if (DISCR[i].attr&0x10)
{
//Если директория пуста
sbuf=DISCR[i].extclust;
sbuf=DISCR[i].begclust|sbuf<<16;
StartSector = ssHDD + clst2sect(sbuf);
if (!BrowseFolder(StartSector, nHDD, ssHDD))
{
strcpy(size,"SUB-DIR ");

YEAR=(DISCR[i].date>>9)+80;
if (YEAR>=100) YEAR-=100;
MONTH = (DISCR[i].date >> 5) & 0xF;
sprintf(date,"%02d.%02d.%02d",DISCR[i].date & 0x1F,
MONTH, YEAR ); //1980
sprintf(time,"%02d:%02d",(DISCR[i].time>>11)&0x1F,
(DISCR[i].time>>5)&0x3F);

rez[0]=0x0;
sprintf(rez,"%c%.7s DIR %.8s %.5s",DISCR[i].fn,
DISCR[i].Name, date, time);

attrib=DISCR[i].attr;

//резервирование памяти
NewPtr = (ListNode far *) farmalloc(sizeof(ListNode));
if (NewPtr != NULL)
{
movedata(FP_SEG(rez), FP_OFF(rez), FP_SEG(NewPtr->Data), FP_OFF(NewPtr->Data), 37);
NewPtr->attrib = attrib;
NewPtr->StartSector = StartSector;
NewPtr->NextPtr = NULL;
NewPtr->PrevPtr = CurPtr;
if (CurPtr==NULL)
HeadPtr = NewPtr;
else
CurPtr->NextPtr = NewPtr;
CurPtr=NewPtr;
}
else { sound(100); delay(500); nosound(); break;}
}

}

}
}
i++;
} while (clst);

return 0;
}


void main (void)
{
char letter;
char s[37], _path [MAXPATH] = "";
long sector;
int i;

clrscr();
printf("По указанному логическому диску поиск и вывод на экран пустых директорий\n\n");
DISK_DETECT();
MEMFREE();
printf("\nВведите букву диска:\n\n-> ");


scanf("%s",_path);

strcpy(path, _path);
strupr(path);
if (!isalpha(path[0])||strlen(path)>1) {printf("\n\n\nERROR - WRONG PATH\n\n\n"); getch(); exit (0);}
//поиск запрашиваемого логического диска
sector=0;
for(letter='C',i=0;letter<='Z';letter++,i++)
if (path[0]==letter)
{
sector=SSA[i].ss;
if(!sector){printf("\n\n\nERROR - WRONG PATH\n\n\n"); getch(); exit (0);}
NumDisk=i;
break;
}

if (!sector) {printf("Ошибка! Указанный диск не найден."); getch();}
else
{
printf("\n\tУказанный диск найден \n\tПожалуйста, подождите пока я сканирую диск\n");
CurPtr=NULL;
CurrentFolder(sector, SSA[NumDisk].drv, SSA[NumDisk].ss);
printf("\n\tСпасибо за ожидание!\n ");
printf("\n ============================================== ");

//vyvod na ekran
NewPtr=HeadPtr;
if (NewPtr==0) printf("\n\tПо указанному пути пустых папок не найдено!");
while (NewPtr != 0)
{
movedata(FP_SEG(NewPtr->Data),FP_OFF(NewPtr->Data),FP_SEG(s),FP_OFF(s),37);
printf("\n\t%s",s);
NewPtr = NewPtr->NextPtr;
}
printf("\n ==============================================\n ");
printf("\n\n\tДля выхода нажмите любую клавишу. ");
getch();
MEMFREE();
}
}


06.05.2011 18:50
Профиль Отправить email
Показать сообщения за:  Поле сортировки  
Начать новую тему Ответить на тему  [ 1 сообщение ] 


Кто сейчас на конференции

Зарегистрированные пользователи: нет зарегистрированных пользователей


Вы не можете начинать темы
Вы не можете отвечать на сообщения
Вы не можете редактировать свои сообщения
Вы не можете удалять свои сообщения
Вы не можете добавлять вложения

Перейти:  
cron
© 2013 «Форум программистов Украины»