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

Форум программистов: 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 сообщение ] 


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

Зарегистрированные пользователи: Google [Bot]


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

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