Код программы. 
Разработка операционных систем

Структура.

Rtos_api.h.

/****************************************/.

/* rtos_api.h */.

/****************************************/.

#include.

#include.

#include.

#define MAX_TASK 32.

#define MAX_RES 16.

#define MAX_PRIOR 16.

#define MAX_EVENT 16.

typedef struct Type_Mask.

{bool mask[MAX_EVENT]; // маска событий.

} TEventMask;

typedef struct Type_stack.

{void *stack; // стек.

int size; // рамер стека.

} _stack;

typedef struct Type_Task.

{int priority; // приоритет.

int state; // состояние задачи.

void (*entry)(void); // точка входа.

char* name; // имя задачи.

TEventMask mask_w; // маска ожидаемых событий.

TEventMask mask_h; // маска произошедших событий.

bool eventwaiting; // флаг ожидания события.

bool semaphorewaiting; // флаг ожидагия семафора.

CONTEXT context; // контекст задачи.

_stack Rsp; // стек вызовов.

} TTask;

typedef struct Type_runningtask.

{int priority; // приоритет.

int task; // номер задачи в очереди.

} TRunningTask;

typedef struct Type_semaphore.

{int sem_id; // идентификатор

int task_id; // идентификатор задачи.

bool isfree; // состояние.

} TSemaphore;

#define DeclareTask (TaskID, priority).

TASK (TaskID);

enum {TaskID##prior=priority}.

#define DeclareResource (ResID, priority).

enum {ResID=priority}.

#define DeclareEvent (Event_ID, EventID).

enum {Event_ID=EventID}.

#define TASK (TaskID) void TaskID (void).

typedef void TTaskCall (void);

extern TTask TaskQueue[MAX_PRIOR][MAX_TASK]; // Очередь задач для POSIX планировщика, отдельная очередь на каждый приоритет.

extern TRunningTask RunningTask; // Запущенная задача.

extern TRunningTask FreeTask[MAX_TASK]; // Очередь свободных задач отсортированных по убыванию приоритетов.

extern TRunningTask SemaphoreWaitingTask[MAX_TASK]; // Очередь задач, ожидающих освобождение семафора.

extern TSemaphore Semaphore; // Семафор

extern void *SP; // Начало стека.

extern bool RestoreStack; // Флаг, характеризующий необходимость восстанавления стека.

extern HANDLE MainProcess; // Дескриптор процесса.

void CheckTask (int prt, int tasknumber);

void ActivateTask (TTask tsk);

void TerminateTask (void);

void Schedule (int prt, int task);

void Dispatch (int prt, int task);

void InitializeTaskQueue ();

int StartOS (TTask Task);

void ShutdownOS ();

void InitPVS (TSemaphore semaphore);

void P (TSemaphore semaphore);

void V (TSemaphore semaphore);

void SetEvent (TTask *Task, TEventMask Mask);

void GetEvent (TTask Task, TEventMask *Mask);

void WaitEvent (TEventMask Mask);

void ClearEvent (TEventMask Mask);

void ClearMask (TTask *Task);

void ClearMask (TEventMask *Mask);

void Sort (TRunningTask *Task);

void InsertIntoQueue (TRunningTask *Task);

Additional.cpp.

/*********************************/.

/* additional. cpp */.

/*********************************/.

#include «rtos_api.h» .

void Sort (TRunningTask *Task).

{TRunningTask Buf;

for (int i=0; i.

{if (Task[i+1]. priority == -1) break;

Buf = Task[i];

Task[i] = Task[i + 1];

Task[i + 1] = Buf;}}.

void InsertIntoQueue (TRunningTask *Task).

{int i = 0, j;

TRunningTask Bufo, Bufn;

for (i=0; i.

{if (Task[i]. priority.

{if (Task[i]. priority≠-1).

{j=i+1;

Bufo = Task[i];

while ((Task[j]. priority≠-1) & (j.

{Bufn = Task[j];

Task[j] = Bufo;

Bufo = Bufn;

}Task[j] = Bufo;

break;

}else break;}}.

Task[i] = RunningTask;}.

Event.cpp.

/*******************************************************/.

/* Управление событиями — события принадлежат задаче */.

/*******************************************************/.

#include.

#include «rtos_api.h» .

/* Генерация событий для задачи Task */.

void SetEvent (TTask *Task, TEventMask Mask).

{int i = 0;

bool flag = false, comma = true;

printf («Setting for %s «, (*Task).name);

/* Устанавливаем маску произошедших событий */.

for (int i=0; i.

{if (Mask.mask[i]).

{if (comma) { printf («Event_%i», i + 1); comma = false; }.

else printf («, Event_%i», i + 1);

(*Task).mask_h.mask[i] = Mask. mask[i]; }.

if (((*Task).mask_w.mask[i])&((*Task).mask_h.mask[i])).

{flag = true;

• (*Task).mask_h.mask[i] = false;
• (*Task).mask_w.mask[i] = false;}}

printf (««);

if (flag).

{int TaskNumber = atoi (&(*Task).name[4]) — 1;

Schedule ((*Task).priority, TaskNumber);}.

printf («Setting events for %s completed «, (*Task).name);}.

void GetEvent (TTask Task, TEventMask *Mask).

{(*Mask) = Task. mask_h;}.

/* Для вызвавшей задачи устанавливается маска ожидаемых событий, задаваемая Mask */.

void WaitEvent (TEventMask Mask).

{bool flag = false, temp = false, comma = true;

int count = 0, i = 0, addr = 0;

SIZE_T sz;

printf («Waiting (Task%i) «, RunningTask. task + 1);

/* Устанавливаем маску ожидаемых событий */.

for (i=0; i.

{if (Mask.mask[i]).

{if (comma) { printf («Event_%i», i + 1); comma = false; }.

else printf («, Event_%i», i + 1);

count++;

TaskQueue[RunningTask.priority][RunningTask.task]. mask_w.mask[i] = Mask. mask[i]; }}.

printf (««); comma = true;

/* Проверка установленной маски */.

for (i=0; i.

{if ((TaskQueue[RunningTask.priority][RunningTask.task]. mask_w.mask[i]) & (TaskQueue[RunningTask.priority][RunningTask.task]. mask_h.mask[i])).

{/* если ожидаемые события уже произошли сбрасываем маску */.

TaskQueue[RunningTask.priority][RunningTask.task]. mask_w.mask[i] = false;

TaskQueue[RunningTask.priority][RunningTask.task]. mask_h.mask[i] = false;

if (!flag) printf («Events which have already happened: «);

flag = true;

count-; temp = true;

if (comma) { printf («Event_%i», i + 1); comma = false; }.

else printf («, Event_%i», i + 1);}}.

if (temp) printf (««);

/* Если все события произошли, то ничего не делаем, в противном случае задача переходит в состояние waiting и запускаем другую задачу */.

if (count≠0).

{/* Есть события, появление которых нужно ожидать */.

/* Приостанавливаем запущенную задачу и устанавливаем флаг, сигнализирующий о том, что есть события, появления которых.

нужно ожидать */.

TaskQueue[RunningTask.priority][RunningTask.task]. state = -1;

TaskQueue[RunningTask.priority][RunningTask.task]. eventwaiting = true;

/* Сохраняем контекст задачи и запускаем другую задачу */.

TaskQueue[RunningTask.priority][RunningTask.task]. context. ContextFlags = CONTEXT_ALL;

RtlCaptureContext (&(TaskQueue[RunningTask.priority][RunningTask.task]. context));

if (TaskQueue[RunningTask.priority][RunningTask.task]. eventwaiting).

{TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size = (int)SP — (int)&addr;

TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack = malloc (TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size);

if (ReadProcessMemory (MainProcess, (LPVOID)(TaskQueue[RunningTask.priority][RunningTask.task]. context. Rsp),.

TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack,.

TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size, &sz)).

{printf («Reading memory… Ok %i bytes «, sz);}.

else{printf («Error: ReadProcessMemory %i «, GetLastError ());}.

if (FreeTask[0]. priority≠-1).

{Dispatch (FreeTask[0]. priority, FreeTask[0]. task);}.

else.

{printf («Error: Deadlock in WaitEvent routine! «);

_getch ();

exit (1);}}.

if (RestoreStack).

{RestoreStack = false;

CONTEXT Ctx = TaskQueue[RunningTask.priority] [RunningTask.task]. context;

if (WriteProcessMemory (GetCurrentProcess (), (void *)(Ctx.Rsp),.

TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack,.

TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size, &sz)).

{printf («Writing memory… Ok %i bytes «, sz);}.

Else.

{printf («Error: WriteProcessMemory %i «, GetLastError ());}}}.

else.

{printf («All events have already happened! «);}.

if (RunningTask.task≠-1) printf («Waiting events (Task%i) completed «, RunningTask. task + 1);}.

void ClearEvent (TEventMask Mask).

{TaskQueue[RunningTask.priority][RunningTask.task]. mask_h = Mask;}.

void ClearMask (TTask *Task).

{for (int i=0; i.

{(*Task).mask_w.mask[i] = false;

(*Task).mask_h.mask[i] = false;}}.

void ClearMask (TEventMask *Mask).

{for (int i=0; i.

{(*Mask).mask[i] = false;

(*Mask).mask[i] = false;}}.

Global.cpp.

/****************************************************/.

/* Описание глобальных переменных */.

/****************************************************/.

#include «rtos_api.h» .

TTask TaskQueue[MAX_PRIOR][MAX_TASK];

TRunningTask RunningTask;

TRunningTask FreeTask[MAX_TASK];

TRunningTask SemaphoreWaitingTask[MAX_TASK];

TSemaphore Semaphore;

void *SP;

bool RestoreStack;

HANDLE MainProcess;

Os.cpp.

/*******************************************/.

/* Управление ОС */.

/*******************************************/.

#include «rtos_api.h» .

/* Инициализация очереди задач и очереди указателей на активные задачи */.

void InitializeTaskQueue ().

{for (int i=0; i.

{for (int j=0; j.

{TaskQueue[i][j]. priority=0;

TaskQueue[i][j]. state = -1;

TaskQueue[i][j]. entry=NULL;

TaskQueue[i][j]. name=NULL;

TaskQueue[i][j]. eventwaiting = false;

TaskQueue[i][j]. semaphorewaiting = false;

TaskQueue[i][j]. Rsp. stack = NULL;

TaskQueue[i][j]. Rsp. size = 0;

ClearMask (&TaskQueue[i][j]);}}.

for (int i=0; i.

{FreeTask[i]. priority = -1;

FreeTask[i]. task = -1;

SemaphoreWaitingTask[i]. priority = -1;

SemaphoreWaitingTask[i]. task = -1;}}.

/* Инициализация очереди задач и очереди ресурсов, запуск первой задачи */.

int StartOS (TTask Task).

{int tmp = 0;

SP = &tmp;

RunningTask.priority = -1;

RunningTask.task = -1;

RestoreStack = false;

TSemaphore Sem;

Sem.isfree = true; Sem. sem_id = 1;

printf («Starting OS… «);

InitPVS (Sem);

InitializeTaskQueue (); // Инициализируем очереди ресурсов и задач.

ActivateTask (Task); // запускаем задачу.

return 0;}.

/* Завершение работы ОС */.

void ShutdownOS ().

{printf («Shutdown OS… «);}.

Resource.cpp.

/*********************************************/.

/* Управление ресурсами — простые семафоры */.

/*********************************************/.

#include «rtos_api.h» .

/* Инициалищация семафоров */.

void InitPVS (TSemaphore semaphore).

{Semaphore.isfree = semaphore. isfree;

Semaphore.sem_id = semaphore. sem_id;

Semaphore.task_id = -1;}.

/* Захват семафора */.

void P (TSemaphore semaphore).

{int addr = 0;

SIZE_T sz;

printf («Trying to obtain semaphore (Task%i)…», RunningTask. task + 1);

if (!Semaphore.isfree).

{printf («semaphore is busy «);

/* Сохоаняем контекст задачи и запускаем другую задачу */.

TaskQueue[RunningTask.priority][RunningTask.task]. semaphorewaiting = true;

TaskQueue[RunningTask.priority][RunningTask.task]. state = -1;

/* Ставим задачу в очередб задач ожидающих семафора */.

InsertIntoQueue (SemaphoreWaitingTask);

TaskQueue[RunningTask.priority][RunningTask.task]. context. ContextFlags = CONTEXT_ALL;

RtlCaptureContext (&(TaskQueue[RunningTask.priority][RunningTask.task]. context));

if (TaskQueue[RunningTask.priority][RunningTask.task]. semaphorewaiting).

{TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size = (int)SP — (int)&addr;

TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack = malloc (TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size);

if (ReadProcessMemory (GetCurrentProcess (), (LPVOID)(TaskQueue[RunningTask.priority][RunningTask.task]. context. Rsp),.

TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack,.

TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size, &sz)).

{printf («Reading memory… Ok %i bytes «, sz);}.

else.

{printf («Error: ReadProcessMemory %i «, GetLastError ());}.

if (FreeTask[0]. priority≠-1).

{Dispatch (FreeTask[0]. priority, FreeTask[0]. task);}.

else.

{printf («Error: Deadlock in primitive P! «);

_getch ();

exit (1);}}.

if (RestoreStack).

{RestoreStack = false;

CONTEXT Ctx = TaskQueue[RunningTask.priority][RunningTask.task]. context;

if (WriteProcessMemory (GetCurrentProcess (), (void *)(Ctx.Rsp),.

TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack,.

TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size, &sz)).

{printf («Writing memory… Ok %i bytes «, sz);}.

else.

{printf («Error: WriteProcessMemory %i «, GetLastError ());}}}.

printf («Semaphore is obtained (Task%i) «, RunningTask. task + 1);

Semaphore.isfree = false;

Semaphore.task_id = RunningTask. task;}.

/* Освобождение семафора */.

void V (TSemaphore semaphore).

{int prt, tsk;

if (RunningTask.task≠-1).

{if (RunningTask.task == Semaphore. task_id).

{printf («Retrieving semaphore (Task%i)… «, RunningTask. task + 1);

prt = SemaphoreWaitingTask[0]. priority;

tsk = SemaphoreWaitingTask[0]. task;

SemaphoreWaitingTask[0]. priority = -1;

SemaphoreWaitingTask[0]. task = -1;

Sort (SemaphoreWaitingTask);

Semaphore.isfree = true;

Semaphore.task_id = -1;

if ((prt≠-1)&(tsk≠-1)) Schedule (prt, tsk);}.

else.

{printf («Error: Can not retrieve semaphore, it belongs to another task!»);

_getch (); exit (1);}}}.

Task.cpp.

/*********************************/.

/* Управление задачами */.

/*********************************/.

#include.

#include «rtos_api.h» .

/* Проверка наличия задачи в очереди и её состояния.

Завершение программы произойдет в следующих случаях: данная задача уже запущена, неправильный приоритет или номер задачи */.

void CheckTask (int prt, int tasknumber).

{if (prt.

{if (tasknumber.

{if (TaskQueue[prt][tasknumber]. state==1).

{printf («Checking… Error: Task%i is running «, tasknumber);

_getch (); exit (1);}}.

else.

{printf («Checking… Error: Trying to activate wrong task — Task%i «, tasknumber);

_getch (); exit (1);}.

printf («Checking… Ok «, tasknumber);}.

else.

{printf («Checking… Error: Trying to activate task with wrong priority %i «, prt);

_getch (); exit (1);}}.

/* Активизация задачи */.

void ActivateTask (TTask tsk).

{printf («Activating %s «, tsk.name);

int TaskNumber = atoi (&tsk.name[4]) — 1;

CheckTask (tsk.priority, TaskNumber);

// Задача вносится в очередь задач.

TaskQueue[tsk.priority][TaskNumber]. priority = tsk. priority;

TaskQueue[tsk.priority][TaskNumber]. name = tsk.name;

TaskQueue[tsk.priority][TaskNumber]. entry = tsk. entry;

TaskQueue[tsk.priority][TaskNumber]. eventwaiting = false;

TaskQueue[tsk.priority][TaskNumber]. semaphorewaiting = false;

Schedule (tsk.priority, TaskNumber); // запускаем планировщик.

printf («Activation of %s completed «, tsk.name);

if (RunningTask.priority==-1) Dispatch (tsk.priority, TaskNumber); // запускаем диспетчер}.

/* Завершение задачи */.

void TerminateTask (void).

{if (RunningTask.task≠-1).

{printf («Terminating %s «, TaskQueue[RunningTask.priority][RunningTask.task]. name);

printf («Termination of %s completed «, TaskQueue[RunningTask.priority] [RunningTask.task]. name);

TaskQueue[RunningTask.priority][RunningTask.task]. state = -1;

RunningTask.priority = -1;

RunningTask.task = -1;}.

// Изменяем состояние задачи.

// Запускаем следующую в очереди задачу.

if (FreeTask[0]. priority≠-1).

{Dispatch (FreeTask[0]. priority, FreeTask[0]. task);}}.

/* Планировщик */.

void Schedule (int prt, int task).

{int i = 0, j;

TRunningTask Bufo, Bufn;

printf («Sheduling %s, priority — %i «, TaskQueue[prt][task]. name, TaskQueue[prt][task]. priority);

// Меняем состояние задачи.

TaskQueue[prt][task]. state = 0;

/* Подготавливаем место в очереди готовых задач Очередь отсортирована по убыванию приоритета, и содержит только указатели на задачи в очереди TaskQueue */.

for (i=0; i.

{if (FreeTask[i]. priority.

{if (FreeTask[i]. priority≠-1).

{j=i+1;

Bufo = FreeTask[i];

while ((FreeTask[j]. priority≠-1) & (j.

{Bufn = FreeTask[j];

FreeTask[j] = Bufo;

Bufo = Bufn;}.

FreeTask[j] = Bufo;

break;}.

else break;}}.

// Вставляем задачу в очередь готовых задач.

FreeTask[i]. priority = prt;

FreeTask[i]. task = task;

printf («Scheduling of %s completed «, TaskQueue[prt][task]. name);}.

/* Диспетчер */.

void Dispatch (int prt, int task).

{printf («Dispatching… «);

// Выбираем первую задачу в очереди готовых задач на исполнение.

RunningTask.priority = FreeTask[0]. priority;

RunningTask.task = FreeTask[0]. task;

// Удаляем выбранную задачу из очереди.

FreeTask[0]. priority = -1;

FreeTask[0]. task = -1;

Sort (FreeTask);

TaskQueue[prt][task]. state = 1;

// Запускаем задачу.

if (TaskQueue[prt][task]. eventwaiting | TaskQueue[prt][task]. semaphorewaiting).

{/* Запускаем приостановленную задачу */.

TaskQueue[RunningTask.priority][RunningTask.task]. context. ContextFlags = CONTEXT_ALL;

TaskQueue[prt][task]. eventwaiting = false;

TaskQueue[prt][task]. semaphorewaiting = false;

RestoreStack = true;

RtlRestoreContext (&(TaskQueue[RunningTask.priority][RunningTask.task]. context), NULL);}.

else.

{TaskQueue[prt][task]. entry ();}.

if (RunningTask.task≠-1) printf («Dispatching of Task%i completed «, task+1);}.

Test.cpp.

/*********************************/.

/* test. cpp */.

/*********************************/.

#include.

#include «rtos_api.h» .

DeclareTask (Task1,0);

DeclareTask (Task2,1);

DeclareTask (Task3,2);

DeclareTask (Task4,3);

DeclareTask (Task5,4);

DeclareTask (Task6,5);

DeclareTask (Task7,6);

DeclareTask (Task8,7);

DeclareTask (Task9,8);

DeclareTask (Task10,9);

DeclareEvent (Event1,0);

DeclareEvent (Event2,1);

DeclareEvent (Event3,2);

DeclareEvent (Event4,3);

DeclareEvent (Event5,4);

DeclareEvent (Event6,5);

DeclareEvent (Event7,6);

DeclareEvent (Event8,7);

DeclareEvent (Event9,8);

DeclareEvent (Event10,9);

TASK (Task1).

{printf («Starting Task1… «);

TTask task2, task3;

TEventMask msk;

task2.priority = Task2prior;

task2.state = -1;

task2.name = «Task2» ;

task2.entry = Task2;

task2.eventwaiting = false;

task2.semaphorewaiting = false;

ClearMask (&task2); ClearMask (&msk);

msk.mask[Event1] = true; msk. mask[Event2] = true;

task3.priority = Task3prior;

task3.state = -1;

task3.name = «Task3» ;

task3.entry = Task3;

task3.eventwaiting = false;

task3.semaphorewaiting = false;

ClearMask (&task3);

ActivateTask (task2);

ActivateTask (task3);

P (Semaphore);

WaitEvent (msk);

V (Semaphore);

if (RunningTask.task≠-1) printf («Executing Task1… «);

TerminateTask ();}.

TASK (Task2).

{printf («Starting Task2… «);

TEventMask msk;

ClearMask (&msk);

msk.mask[0] = true; msk. mask[1] = true;

SetEvent (&(TaskQueue[0][0]), msk);

printf («Executing Task2… «);

TerminateTask ();}.

TASK (Task3).

{printf («Starting Task3… «);

TEventMask msk;

ClearMask (&msk);

msk.mask[0] = true; msk. mask[1] = true;

P (Semaphore);

printf («Executing Task3… «);

V (Semaphore);

TerminateTask ();}.

TASK (Task4).

{printf («Starting Task4… «);

TTask task5, task6;

TEventMask msk;

task5.priority = Task5prior;

task5.state = -1;

task5.name = «Task5» ;

task5.entry = Task5;

task5.eventwaiting = false;

task5.semaphorewaiting = false;

ClearMask (&task5); ClearMask (&msk);

msk.mask[Event3] = true; msk. mask[Event4] = true; msk. mask[Event5] = true;

task6.priority = Task6prior;

task6.state = -1;

task6.name = «Task6» ;

task6.entry = Task6;

task6.eventwaiting = false;

task6.semaphorewaiting = false;

ClearMask (&task6);

ActivateTask (task5);

ActivateTask (task6);

WaitEvent (msk);

if (RunningTask.task≠-1) printf («Executing Task4… «);

TerminateTask ();}.

TASK (Task5).

{printf («Starting Task5… «);

TEventMask msk;

ClearMask (&msk);

msk.mask[Event5] = true;

SetEvent (&(TaskQueue[3][3]), msk); // Task4 3.

ClearMask (&msk);

msk.mask[Event10] = true;

SetEvent (&(TaskQueue[6][6]), msk); // Task7 6.

printf («Executing Task5… «);

TerminateTask ();}.

TASK (Task6).

{printf («Starting Task6… «);

TTask task7;

task7.priority = Task7prior;

task7.state = -1;

task7.name = «Task7» ;

task7.entry = Task7;

task7.eventwaiting = false;

task7.semaphorewaiting = false;

ClearMask (&task7);

P (Semaphore);

ActivateTask (task7);

V (Semaphore);

printf («Executing Task6… «);

TerminateTask ();}.

TASK (Task7).

{printf («Starting Task7… «);

TEventMask msk;

ClearMask (&msk);

msk.mask[Event10] = true;

WaitEvent (msk);

printf («Executing Task7… «);

TerminateTask ();}.

void Test (int testNumber).

{TTask InitialTask;

InitialTask.state = -1;

InitialTask.eventwaiting = false;

InitialTask.semaphorewaiting = false;

ClearMask (&InitialTask);

switch (testNumber).

{case (0):

{InitialTask.priority = Task1prior;

InitialTask.name = «Task1» ;

InitialTask.entry = Task1;

break;}.

case (1):

{InitialTask.priority = Task4prior;

InitialTask.name = «Task4» ;

InitialTask.entry = Task4;

break;}}.

StartOS (InitialTask);

ShutdownOS ();}.

int main (void).

{HANDLE Temporary = GetCurrentProcess ();

if (DuplicateHandle (GetCurrentProcess (), Temporary, GetCurrentProcess (), &MainProcess, 0, FALSE, DUPLICATE_SAME_ACCESS)).

{printf («DupliicateHandle… Ok «);}.

printf («****************************************** «);

Test (0);

_getch ();

return 0;}.