
harderr

㭪            ⠭ ணࠬ     ࠡ⪨     訡
                   ஭ 㤮.

⠪          #include<dos.h>
                   void harderr(*handler)());

, ᮤঠ騩   dos.h
⨯

ᠭ           㭪 harderr      ⠭     ணࠬ
                   ࠡ⪨  ᡮ  ஭   㤮   
                   ⥪饩 ணࠬ.  ணࠬ 뢠 
                   ࠡ,   ⮫쪮  뢠 0x24. (.
                   㬥  "ࠢ筮  㪮⢮ ணࠬ 
                   DOS").

                       렭 ந室 맮
                   㭪樨 handler.  㭪     맢  
                   ᫥騬 㬥⠬:

                   handler(int errval, int ax, int bp, int si);

                   ६ errval -  訡, ⠭ DOS
                    ॣ DI.  ax,  bp  si  -  祭,  
                   MS-DOS 頥 ᮮ⢥⢥  ॣ AX,BP,SI.

                   - ࠬ ax 砥, ந諠  訡 ᪠
                      - 㣮 ன⢠.  ᫨  ax  
                     ⥫쭮,   ந諠   ᪮   訡,  
                     ⨢ 砥,   訡 㣮 ன⢠.
                        ᪮   訡  祭  ax,  ᫮
                     ᪨ (樥 AND)   0x00FF,    
                     ᪮,   ஬ ந襫 ᡮ (1=A; 2=B; 
                     ..).

                   - bp  si  㪠뢠      ࠩ
                     ன⢠,  ஬ ந襫 ᡮ. bp ᮤন
                      ᥣ,  si ᬥ饭.

                          㭪            뢠
                   ।⢥.   㭪   harderr  ⠭
                   ணࠬ  ࠡ⪨  뢠  DOS,   
                   뢠   㭪.    祭  ଠ樨  
                    ࠩ  ᯮ짮 㭪樨  peek
                    peekb.

                   ணࠬ -     ࠡ稪     뢠     
                   ᯮ짮 ⥬ 맮 DOS  1  0xC,  
                   ⠫ 맮  DOS.   ⭮,  
                    ᯮ짮   ⠭ ணࠬ
                   /뢮 C,    ணࠬ /뢮
                   樨 UNIX.

                   ணࠬ ࠡ⪨ 뢠   0,
                   ᫨ 室 ஢ 訡,  1, ᫨ 㦭
                      2  襭 ணࠬ.

頥       .
祭

७ᨬ      㭪 㭨쭠  DOS.  㭪  ᮢ⨬ 
                   Windows.

 ⠪     hardresume, hardretn, peek, poke.

ਬ:
                
/*  ணࠬ ᫥ 訡 ᪮ 権 /뢮 
   訢  짮⥫ 쭥訥 樨. ஡
    ,  ᪥  ᪮ : */

#include <stdio.h>
#include <conio.h>
#include <dos.h>

#define IGNORE 0
#define RETRY  1
#define ABORT  2

/* । ᮮ饭  訡  ᪮ */
static char *err_msg[] = {" 饭  ",
                          "⭮ ன⢮",
                          "᪮  ⮢",
                          "⭠ ",
                          "訡  (CRC)",
                          "訡 ᪠",
                          " ⨯ ⥫",
                          " ᥪ",
                          " ਭ  㬠",
                          "ᡮ  ",
                          "訡  ⥭",
                          "࠭ 訡",
                          "१ࢨ஢",
                          "१ࢨ஢",
                          "ୠ ᬥ ᪠"
                          };

error_win(char *msg)
{
   int retval;
   cputs(msg);
                   
   /*   짮⥫ 쭥 ⢨ */
   while(1)
   {
      retval = getch();
      if(retval == 'a' || retval == 'A')
      {
         retval = ABORT;
         break;
      }
      if(retval == 'r' || retval == 'R')
      {
         retval = RETRY;
         break;
      }
      if(retval == 'i' || retval == 'I')
      {
         retval = IGNORE;
         break;
      }
   }
   return(retval);
}
/* ࠣ warn -par ᪫砥 뤠 ।०  ⮬, 
    ணࠬ  ᯮ ࠬ errval,bp  si */

#pragma warn -par

int handler(int errval, int ax, int bp, int si)
{
   static char msg[80];
   unsigned di;
   int drive;
   int errno;
   di = _DI;
/* ᫨   訡 ᪠,  ஡  
   㣮 - */
   if(ax<0)
   {
      /* ᮮ  訡 */
      error_win("訡 ன⢠");
      /*   ࠢ ணࠬ */
      hardretn(ABORT);
   }
   /*   訡 ᪠ */
   drive = ax&0x00ff;
   errno = di & 0xff;
   /* ᮮ,   訡 */
   sprintf(msg,"訡: %s  ᪮ %c\r\nA)bort, R)etry,
               I)gnore:",err_msg[errno],'A'+drive);
   /*  ࠢ ணࠬ */
   hardresume(error_win(msg));
   return ABORT;
}
#pragma warn +par

int main(void)
{
   /* ⠭ ணࠬ ࠡ⪨ 뢠 */
   harderr(handler);
   printf("Make sure there is no disk in drive A:\n");
   printf("Press a key when ready...\n");
   getch();
   printf("Attempting to access A:\n);
   fopen("A:ANY.FIL","r");
   return 0;
}


hardresume

㭪            㭪 ࠡ⪨       訡        ஭
                   㤮.

⠪          #include<dos.h>
                   void hardresume(int rescode);

, ᮤঠ騩   dos.h
⨯

ᠭ           ணࠬ ࠡ⪨      訡      ﭨ,
                   ⠭     㭪樥     harderr     
                   ᯮ짮   㭪   hardresume    
                   ࠢ  DOS.  頥  祭   rescode
                        ᮤঠ    ,    ।騩
                   ஢ 訡 (0),  ७ 樨 (1)
                    襭 ணࠬ (2). 襭 ணࠬ
                   믮 ।⢮ 뢠 DOS 0x23.

                   ணࠬ ࠡ⪨  뢠   
                   0,  ᫨ 室 ஢ 訡,  1,  ᫨
                   㦭         2    襭
                   ணࠬ.

頥       .
祭

७ᨬ      㭪 㭨쭠  DOS. 㭪  ᮢ⨬ 
                   Windows.

 ⠪     harderr, hardretn.

ਬ:

/*  ணࠬ  ᫥  訡,  訢 
   짮⥫ 쭥訥 ⢨.  ⮣, ⮡ 뫠 맢-
    ணࠬ ࠡ⪨ 訡, ᪠ ணࠬ, 
    ᪮ : . */

#include <stdio.h>
#include <conio.h>
#include <dos.h>

#define IGNORE 0
#define RETRY  1
#define ABORT  2

/* । ᮮ饭  訡  ᪮ */
static char *err_msg[] = {" 饭  ",
                          "⭮ ன⢮",
                          "᪮  ⮢",
                          "⭠ ",
                          "訡  (CRC)",
                          "訡 ᪠",
                          " ⨯ ⥫",
                          " ᥪ",
                          " ਭ  㬠",
                          "ᡮ  ",
                          "訡  ⥭",
                          "࠭ 訡",
                          "१ࢨ஢",
                          "१ࢨ஢",
                          "ୠ ᬥ ᪠"
                          };

error_win(char *msg)
{
   int retval;
   cputs(msg);
   /*   짮⥫ 쭥 ⢨ */
   while(1)
   {
      retval = getch();
      if(retval == 'a' || retval == 'A')
      {
         retval = ABORT;
         break;
      }
      if(retval == 'r' || retval == 'R')
      {
         retval = RETRY;
         break;
      }
      if(retval == 'i' || retval == 'I')
      {
         retval = IGNORE;
         break;
      }
   }
   return(retval);
}
/* ࠣ warn -par ᪫砥 뤠 ।०  ⮬, 
  ஫ࠬ  ᯮ ࠬ errval,bp  si */
#pragma warn -par

int handler(int errval, int ax, int bp, int si)
{
   static char msg[80];
   unsigned di;
   int drive;
   int errno;
   di = _DI;
/* ᫨   訡 ᪠,   ஡ 
   㣮 - */
   if(ax<0)
   {
      /* ᮮ  訡 */
      error_win("訡 ன⢠");
      /*   ࠢ ணࠬ */
      hardretn(ABORT);
   }
   /*   訡 ᪠ */
   drive = ax&0x00ff;
   errno = di & 0xff;
   /* ᮮ,   訡 */
   sprintf(msg,"訡: %s  ᪮ %c\r\nA)bort, R)etry,
               I)gnore:",err_msg[errno],'A'+drive);
   /*  ࠢ ணࠬ */
   hardresume(error_win(msg));
   return ABORT;
}
#pragma warn +par

int main(void)
{
   /* ⠭ ணࠬ ࠡ⪨ 뢠 */
   harderr(handler);
   printf("Make sure there is no disk in drive A:\n");
   printf("Press a key when ready...\n");
   getch();
   printf("Attempting to access A:\n);
   fopen("A:ANY.FIL","r");
   return 0;
}


hardretn

㭪            㭪 ࠡ⪨        訡       ஭
                   㤮.

⠪          void hardretn(int errcode);

, ᮤঠ騩   dos.h
⨯

ᠭ           ணࠬ ࠡ⪨      訡      ﭨ,
                   ⠭   ணࠬ   harderr,   
                   ⢨        ࠢ    ਪ
                   ணࠬ   㭪樨 hardretn.

                   ணࠬ ࠡ⪨  뢠   
                   0,  ᫨ 室 ஢ 訡,  1,  ᫨
                   㦭         2    襭
                   ணࠬ.

頥       .
祭

७ᨬ      㭪 㭨쭠  DOS. 㭪  ᮢ⨬ 
                   Windows.

 ⠪     harderr, hardresume.

ਬ:

/*  ணࠬ  ᫥  訡,  訢 
   짮⥫ 쭥訥 ⢨.  ⮣, ⮡ 뫠 맢-
    ணࠬ ࠡ⪨ 訡, ᪠ ணࠬ, 
    ᪮ : . */

#include <stdio.h>
#include <conio.h>
#include <dos.h>

#define IGNORE 0
#define RETRY  1
#define ABORT  2

/* । ᮮ饭  訡  ᪮ */
static char *err_msg[] = {" 饭  ",
                          "⭮ ன⢮",
                          "᪮  ⮢",
                          "⭠ ",
                          "訡  (CRC)",
                          "訡 ᪠",
                          " ⨯ ⥫",
                          " ᥪ",
                          " ਭ  㬠",
                          "ᡮ  ",
                          "訡  ⥭",
                          "࠭ 訡",
                          "१ࢨ஢",
                          "१ࢨ஢",
                          "ୠ ᬥ ᪠"
                          };

error_win(char *msg)
{
   int retval;
   cputs(msg);
   /*   짮⥫ 쭥 ⢨ */
   while(1)
   {
      retval = getch();
      if(retval == 'a' || retval == 'A')
      {
         retval = ABORT;
         break;
      }
      if(retval == 'r' || retval == 'R')
      {
         retval = RETRY;
         break;
      }
      if(retval == 'i' || retval == 'I')
      {
         retval = IGNORE;
         break;
      }
   }
   return(retval);
}
/* ࠣ warn -par ᪫砥 뤠 ।०  ⮬, 
  ஫ࠬ  ᯮ ࠬ errval,bp  si */
#pragma warn -par

int handler(int errval, int ax, int bp, int si)
{
   static char msg[80];
   unsigned di;
   int drive;
   int errno;
   di = _DI;
/* ᫨   訡 ᪠,   ஡ 
   㣮 - */
   if(ax<0)
   {
      /* ᮮ  訡 */
      error_win("訡 ன⢠");
      /*   ࠢ ணࠬ */
      hardretn(ABORT);
   }
   /*   訡 ᪠ */
   drive = ax&0x00ff;
   errno = di & 0xff;
   /* ᮮ,   訡 */
   sprintf(msg,"訡: %s  ᪮ %c\r\nA)bort, R)etry,
               I)gnore:",err_msg[errno],'A'+drive);
   /*  ࠢ ணࠬ */
   hardresume(error_win(msg));
   return ABORT;
}
#pragma warn +par

int main(void)
{
   /* ⠭ ணࠬ ࠡ⪨ 뢠 */
   harderr(handler);
   printf("Make sure there is no disk in drive A:\n");
   printf("Press a key when ready...\n");
   getch();
   printf("Attempting to access A:\n);
   fopen("A:ANY.FIL","r");
   return 0;
}


heapcheck

㭪            ᬠਢ  ஢ .

⠪          #include<alloc.h>
                   int heapcheck(void);

, ᮤঠ騩   alloc.h
⨯

ᠭ           heapcheck 室         ஢  
                   ,  ஢ 㪠⥫, ࠧ  㣨 
                   ࠬ.          heapcheck
                   ᮢ  farheapcheck.

饬         訡  祭 < 0,  ᯥ譮
祭           襭 頥 祭 > 0.

                   ᫨    ,      頥    祭
                   _HEAPEMPTY (1).
                   
                   ᫨  ஢७, 頥_HEAPOK (2).
                   
                   ᫨      祭,          頥
                   _HEAPCORRUPT(-1).

७ᨬ      heapcheck 㭨쭠  DOS. 㭪  ᮢ⨬
                    Windows.

 ⠪     farheapcheck.

ਬ:

#include<stdio.h>
#include<alloc.h>

#define NUM_PTRS    10
#define NUM_BYTES   16

int main(void)
{
   char *array[NUM_PTRS];
   int i;
   for(i=0; i<NUM_PTRS; i++)
     array[i] = malloc(NUM_BYTES);
   for(i=0; i<NUM_PTRS; i+=2)
     free(array[i]);
   if(heapcheck() == _HEAPCORRUPT)
     printf("  祭\n");
   else
     printf(" ଠ쭮\n");
   return 0;
}


heapcheckfree

㭪            ஢ ᢮       ⠭⭮
                   祭.

⠪          #include<alloc.h>
                   int heapcheckfree(unsigned int fillvalue);

, ᮤঠ騩   alloc.h
⨯

ᠭ           ????????????????

饬         訡  祭 < 0,  ᯥ譮
祭           襭 頥 祭 > 0.

                   ᫨     ,      頥   祭
                   _HEAPEMPTY (1).
                   
                   ᫨  ஢७, 頥_HEAPOK (2).
                   
                   ᫨      祭,          頥
                   _HEAPCORRUPT(-1).
                   
                   ᫨ 祭    ⫨砥  fillvalue,
                    頥 _BADVALUE (-3).

७ᨬ      heapcheckfree 㭨쭠      DOS.   㭪  
                   ᮢ⨬  Windows.

 ⠪     farheapcheckfree.

ਬ:

#include<mem.h>
#include<stdio.h>
#include<alloc.h>

#define NUM_PTRS    10
#define NUM_BYTES   16

int main(void)
{
   char *array[NUM_PTRS];
   int i;
   int res;
   for(i=0; i<NUM_PTRS; i++)
     array[i] = malloc(NUM_BYTES);
   for(i=0; i<NUM_PTRS; i+=2)
     free(array[i]);
   if(heapfillfree(1) < 0)
   {
     printf("  祭\n");
     return 1;
   }
   for(i=0; i<NUM_PTRS; i+=2)
     memset(array[i],0,NUM_BYTES);
   res = heapcheckfree(1);
   if(res<0)
      switch(res)
      {
      case _HEAPCORRUPT:
           printf("  祭\n");
           return 1;
      case _BADVALUE:
           printf("୮ ᮤন ⮩  \n");
           return 1;
      default:
           printf(" ᯮ 訡\n");
           return 1;
      }
   printf(" ଠ쭮\n");
   return 0;
}


heapchecknode

㭪              ஢ ⤥ 㧥 .

⠪          #include<alloc.h>
                   int heapchecknode(void *node);

, ᮤঠ騩   alloc.h
⨯

ᠭ           ᫨ 㧥      ᢮        heapchecknode
                   뢠  㪠⥫  ᢮ 㧥,  
                   heapchecknode      祭  _BADNODE,
                    । _FREEENTRY.   ந室
                   ⮬,   ᥤ ᢮  ᫨, 
                   ,  㪠    맮  㭪樨,   
                   .

饬         訡  祭 < 0,  ᯥ譮
祭           襭 頥 祭 > 0.

                   ᫨    ,      頥    祭
                   _HEAPEMPTY (1).
                   
                   ᫨      祭,          頥
                   _HEAPCORRUPT(-1).
                   
                   ᫨ 㧥    ,    頥  _BADNODE
                   (-2).
                   
                   ᫨ 㧥 ᢮,   頥  _FREEENTRY
                   (3).
                   
                   ᫨ 㧥,   ᯮ㥬 ,  頥
                   _USEDENTRY (4)

७ᨬ      heapcheckfree 㭨쭠     DOS.   㭪   
                   ᮢ⨬  Windows.

 ⠪     farheapchecknode.

ਬ:

#include<stdio.h>
#include<alloc.h>

#define NUM_PTRS    10
#define NUM_BYTES   16

int main(void)
{
   char *array[NUM_PTRS];
   int i;
   for(i=0; i<NUM_PTRS; i++)
     array[i] = malloc(NUM_BYTES);
   for(i=0; i<NUM_PTRS; i+=2)
     free(array[i]);
   for(i=0; i<NUM_PTRS; i++)
   {
      printf(" %2d",i);
      switch(heapchecknode(array[i]))
      {
         case _HEAPEMPTY:
             printf("  \n");
             break;
         case HEAPCORRUPT:
             printf("  祭\n");
             break;
         case _BADNODE:
             printf("  㧥\n");
             break;
         case _FREEENTRY:
             printf("  \n");
             break;
         case _USEDENTRY:
             printf("  \n");
             break;
         default:
             printf(" ⭮ 頥 祭\n");
             break;
     }
  }
  return 0;
}


heapfillfree

㭪             ᢮          
                   祭.

⠪          #include<alloc.h>
                   int heapfillfree(unsigned int fillvalue);

, ᮤঠ騩   alloc.h
⨯

ᠭ           ????????????????

饬         訡  祭 < 0,  ᯥ譮
祭           襭 頥 祭 > 0.

                   ᫨     ,      頥   祭
                   _HEAPEMPTY (1).
                   
                   ᫨  ஢७, 頥_HEAPOK (2).
                   
                   ᫨      祭,          頥
                   _HEAPCORRUPT(-1).
                   
                   ᫨ 祭    ⫨砥  fillvalue,
                    頥 _BADVALUE (-3).

७ᨬ      heapfillfree 㭨쭠      DOS.   㭪   
                   ᮢ⨬  Windows.

ਥ ⠪     farheapfillfree.

ਬ:

#include<mem.h>
#include<stdio.h>
#include<alloc.h>

#define NUM_PTRS    10
#define NUM_BYTES   16

int main(void)
{
   char *array[NUM_PTRS];
   int i;
   int res;
   for(i=0; i<NUM_PTRS; i++)
     array[i] = malloc(NUM_BYTES);
   for(i=0; i<NUM_PTRS; i+=2)
     free(array[i]);
   if(heapfillfree(1) < 0)
   {
     printf("  祭\n");
     return 1;
   }
   for(i=0; i<NUM_PTRS; i+=2)
     memset(array[i],0,NUM_BYTES);
   res = heapcheckfree(1);
   if(res<0)
      switch(res)
      {
      case _HEAPCORRUPT:
           printf("  祭\n");
           return 1;
      case _BADVALUE:
           printf("୮ ᮤন ⮩  \n");
           return 1;
      default:
           printf(" ᯮ 訡\n");
           return 1;
      }
   printf(" ଠ쭮\n");
   return 0;
}


heapwalk

㭪            ᯮ  ६饭    㧫  
                   㧫.

⠪          #include<alloc.h>
                   int heapwalk(struct heapinfo *hi);

, ᮤঠ騩   alloc.h
⨯

ᠭ           heapwalk ࠧ㬥,      祭.
                     ஢ન,  ।   ᯮ짮   heapwalk,
                   맮   heapcheck.    ⨦  ᫥
                   ,  㭪 頥 _HEAPOK.   ᫥饬
                   맮 heapwalk,  ୥ _HEAPEND.

                   heapwalk 砥  㪠⥫       ⨯
                   heapinfo (।  䠩 alloc.h).   ࢮ
                   맮  heapwalk  ⠭    hi.ptr     0.
                   farheapwalk  ୥    ⮬   ࢮ
                    .   hi.size ᮤন ࠧ  ⮣
                       .  hi.in_use  -  䫠,  
                   ⠭,  ᫨     ᯮ  
                   騩 .

饬        ᫨  ,  頥 祭
祭           _HEAPEMPTY  (1).
                   
                   ᫨ hiapinfo  ᮤন  ⨬   ,   
                   頥 _HEAPOK (2).
                   
                   ᫨ ⨣      ,    頥
                   _HEAPEND (5).

७ᨬ      heapwalk 㭨쭠  DOS.  㭪  ᮢ⨬
                    Windows.

 ⠪     farheapwalk.

ਬ:

#include<stdio.h>
#include<alloc.h>

#define NUM_PTRS    10
#define NUM_BYTES   16

int main(void)
{
   struct heapinfo hi;
   char *array[NUM_PTRS];
   int i;
   for(i=0; i<NUM_PTRS; i++)
     array[i] = malloc(NUM_BYTES);
   for(i=0; i<NUM_PTRS; i+=2)
     free(array[i]);
   hi.ptr = NULL;
   printf("            \n");
   printf("   ------      ------   \n");
   while(heapwalk(&hi) == _HEAROK)
      printf(" %7u      %s\n",fi.size,hi.in_use ? "ᯮ" :
          " ᯮ");
   return 0;
}


highvideo

㭪            ⠭  ⥭ᨢ.

⠪          #include<conio.h>
                   void highvideo(void);

, ᮤঠ騩   conio.h
⨯

ᠭ           highvideo ⠭,    뢮
                   ᨬ  ᮪ ⥭ᨢ.    ,
                   ⠭    ⥭ᨢ   ⥪饬 梥.
                   
                     㭪        ⥪饥   ᮤন
                   ࠭,      ࠡ  㭪権,  ⢫
                   אַ 뢮  ࠭    ⥪⮢  ०  (⨯
                   cprintf).

頥       .
祭

७ᨬ      highvideo ࠡ⠥ ⮫쪮  設, ᮢ⨬ 
                   IBM PC.  筠  㭪   Turbo Pascal.
                   㭪  ᮢ⨬  Windows.

 ⠪     cprintf, cputs, gettextinfo, lowvideo, normvideo,
                   textattr, textcolor.

ਬ:

#include<conio.h>

int main(void)
{
   lowvideo();
   cprintf("  ⥭ᨢ");
   highvideo();
   gotoxy(1,2);
   cprintf(" ᮪ ⥭ᨢ");
   return 0;
}


hypot

㭪             ⥭ אַ㣮쭮 㣮쭨.

⠪          #include<math.h>
                   double hypot(double x, double y);

, ᮤঠ騩   math.h
⨯

ᠭ           㭪 hypot  祭 z, 

                   z^2 = x^2 + y^2

                       z >= 0

                   ( -   ⥭  אַ㣮쭮
                   㣮쭨, ᫨    ஭ x  y).

頥        ᯥ譮 襭, 㭪 hypot 頥
祭           ᫮ z-  筮.  訡 (⠪,
                   ਬ,     ९),    㭪   hypot
                   ᢠ 쭮 ६ errno 祭:

                   ERANGE  -  ॢ蠥 ⨬ 祭.

                    ᠬ 頥 祭 HUGE_VAL.

                   ࠡ⪠ 訡    㭪樨  hypot    
                   ஢ ।⢮ 㭪樨 matherr.

७ᨬ      㭪 ন  ⥬ UNIX.

ਬ:

#include<stdio.h>
#include<math.h>

int main(void)
{
   double result;
   double x = 3.0;
   double y = 4.0;
   result = hypot(x,y);
   printf("⥭㧠 = %lf\n",result);
   return 0;
}
