home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 550b.lha / Term_v1.8a / Source.LZH / ColourPatch.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-06  |  13.9 KB  |  667 lines
  1. /* $Revision Header * Header built automatically - do not edit! *************
  2.  *
  3.  *    (C) Copyright 1990 by Olaf 'Olsen' Barthel & MXM
  4.  *
  5.  *    Name .....: ColourPatch.c
  6.  *    Created ..: Tuesday 19-Feb-91 14:07
  7.  *    Revision .: 1
  8.  *
  9.  *    Date            Author          Comment
  10.  *    =========       ========        ====================
  11.  *    25-Mar-91       Olsen           Updated for term 1.6
  12.  *    19-Feb-91       Olsen           Created this file!
  13.  *
  14.  * $Revision Header ********************************************************/
  15.  
  16. enum    {    EMULATION_ANSIVT100,EMULATION_ATOMIC,EMULATION_TTY };
  17. enum    {    COLOUR_AMIGA,COLOUR_EIGHT,COLOUR_SIXTEEN,COLOUR_MONO };
  18.  
  19. struct TermInfo
  20. {
  21.     UWORD    Version;
  22.     UWORD    Revision;
  23. };
  24.  
  25. extern LONG TermVersion,TermRevision;
  26. extern UBYTE TermName[],TermDate[],TermString[];
  27.  
  28. struct Configuration
  29. {
  30.     /* Serial Preferences. */
  31.  
  32.     ULONG    BaudRate;
  33.     BYTE    BitsPerChar;
  34.     BYTE    Parity;
  35.     BYTE    StopBits;
  36.     BYTE    Handshaking;
  37.     BYTE    Duplex;
  38.     BYTE    HighSpeed;
  39.     ULONG    BreakLength;
  40.     UBYTE    SerialDevice[40];
  41.     LONG    UnitNumber;
  42.  
  43.     /* Modem Preferences. */
  44.  
  45.     UBYTE    ModemInit[80];
  46.     UBYTE     ModemExit[80];
  47.     UBYTE    DialPrefix[80];
  48.     LONG    RedialDelay;
  49.     LONG    DialRetries;
  50.     LONG    DialTimeout;
  51.     BYTE    ConnectAutoBaud;
  52.     UBYTE    NoCarrier[16];
  53.     UBYTE    Connect[16];
  54.     UBYTE    Error[16];
  55.     UBYTE    Voice[16];
  56.     UBYTE    Ring[16];
  57.     UBYTE    Busy[16];
  58.     UBYTE    Okay[16];
  59.  
  60.     /* Transfer Preferences. */
  61.  
  62.     UBYTE    Protocol[40];
  63.  
  64.     /* Startup macro. */
  65.  
  66.     UBYTE    StartupMacro[256];
  67.  
  68.     /* Macro Preferences. */
  69.  
  70.     UBYTE    MacroFile[256];
  71.  
  72.     /* Screen Preferences. */
  73.  
  74.     ULONG    DisplayMode;
  75.     UWORD    Colours[16];
  76.     BYTE    MakeScreenPublic;
  77.     BYTE    ShanghaiWindows;
  78.  
  79.     /* Terminal Preferences. */
  80.  
  81.     BYTE    CaptureFilter;
  82.     BYTE    DestructiveBackspace;
  83.     BYTE    AudibleBell;
  84.     BYTE    VisibleBell;
  85.     BYTE    EightyColumns;
  86.     BYTE    SendCR;
  87.     BYTE    SendLF;
  88.     BYTE    ColourMode;
  89.     BYTE    Emulation;
  90.     BYTE    Font;
  91. };
  92.  
  93.     /* A phone book entry. */
  94.  
  95. struct PhoneEntry
  96. {
  97.     UBYTE            Name[40];
  98.     UBYTE            Number[40];
  99.     UBYTE            Password[40];
  100.  
  101.     LONG            PayPerUnit;
  102.     LONG            MinPerUnit;
  103.  
  104.     struct Configuration    Config;
  105. };
  106.  
  107. struct NewConfiguration
  108. {
  109.     /* Serial Preferences. */
  110.  
  111.     ULONG    BaudRate;
  112.     BYTE    BitsPerChar;
  113.     BYTE    Parity;
  114.     BYTE    StopBits;
  115.     BYTE    Handshaking;
  116.     BYTE    Duplex;
  117.     BYTE    HighSpeed;
  118.     ULONG    BreakLength;
  119.     UBYTE    SerialDevice[40];
  120.     LONG    UnitNumber;
  121.  
  122.     /* Modem Preferences. */
  123.  
  124.     UBYTE    ModemInit[80];
  125.     UBYTE     ModemExit[80];
  126.     UBYTE     ModemHangup[80];
  127.     UBYTE    DialPrefix[80];
  128.     LONG    RedialDelay;
  129.     LONG    DialRetries;
  130.     LONG    DialTimeout;
  131.     BYTE    ConnectAutoCapture;
  132.     BYTE    ConnectAutoBaud;
  133.     BYTE    LogActions;
  134.     UBYTE    NoCarrier[16];
  135.     UBYTE    Connect[16];
  136.     UBYTE    Voice[16];
  137.     UBYTE    Ring[16];
  138.     UBYTE    Busy[16];
  139.  
  140.     /* Transfer Preferences. */
  141.  
  142.     UBYTE    Protocol[40];
  143.  
  144.     /* Startup macro. */
  145.  
  146.     UBYTE    StartupMacro[256];
  147.  
  148.     /* Macro Preferences. */
  149.  
  150.     UBYTE    MacroFile[256];
  151.  
  152.     /* Screen Preferences. */
  153.  
  154.     ULONG    DisplayMode;
  155.     UWORD    Colours[16];
  156.     BYTE    MakeScreenPublic;
  157.     BYTE    ShanghaiWindows;
  158.  
  159.     /* Terminal Preferences. */
  160.  
  161.     BYTE    CaptureFilter;
  162.     BYTE    DestructiveBackspace;
  163.     BYTE    AudibleBell;
  164.     BYTE    VisibleBell;
  165.     BYTE    EightyColumns;
  166.     BYTE    DisableBlinking;
  167.     BYTE    SendCR;
  168.     BYTE    SendLF;
  169.     BYTE    ColourMode;
  170.     BYTE    Emulation;
  171.     BYTE    Font;
  172.  
  173.     /* Emulation control. */
  174.  
  175.     BYTE    CursorApp;
  176.     BYTE    FontScale;
  177.     BYTE    JumpScroll;
  178.     BYTE    AutoWrap;
  179.     BYTE    CursorWrap;
  180.     BYTE    NewLine;
  181.     BYTE    InsertChar;
  182.     BYTE    NumApp;
  183.  
  184.     /* Path Preferences. */
  185.  
  186.     UBYTE    DefaultStorage[256];
  187.  
  188.     UBYTE    TextUploadPath[256];
  189.     UBYTE    TextDownloadPath[256];
  190.  
  191.     UBYTE    ASCIIUploadPath[256];
  192.     UBYTE    ASCIIDownloadPath[256];
  193.  
  194.     UBYTE    BinaryUploadPath[256];
  195.     UBYTE    BinaryDownloadPath[256];
  196.  
  197.     UBYTE    CapturePath[256];
  198.     UBYTE    LogFile[256];
  199.     UBYTE    Editor[256];
  200.     UBYTE    BeepSound[256];
  201. };
  202.  
  203. struct NewPhoneEntry
  204. {
  205.     UBYTE            Name[30];
  206.     UBYTE            Number[40];
  207.     UBYTE            Password[40];
  208.  
  209.     LONG            PayPerUnit[2];
  210.     LONG            SecPerUnit[2];
  211.     LONG            TimeOfDay[2];
  212.  
  213.     struct NewConfiguration    Config;
  214. };
  215.  
  216. LONG __saveds            Main(VOID);
  217. struct NewPhoneEntry *        Convert(struct PhoneEntry *Src);
  218. struct PhoneEntry **        CreatePhonebook(LONG Size,LONG *AllocSize,BYTE CreateEntries);
  219. VOID                DeletePhonebook(struct PhoneEntry **PhoneBook,LONG Size,BYTE FreeEntries);
  220. BYTE                SavePhonebook(UBYTE *Name);
  221. BYTE                LoadPhonebook(UBYTE *Name);
  222.  
  223. struct PhoneEntry        **Phonebook;
  224. LONG                 PhoneSize;
  225.  
  226. LONG                 NumPhoneEntries;
  227.  
  228. struct ExecBase            *SysBase;
  229. struct DosLibrary        *DOSBase;
  230. struct Library            *IFFParseBase;
  231.  
  232. UWORD AtomicColours[16] =
  233. {
  234.     0x000,
  235.     0xDDD,
  236.     0x000,
  237.     0x000,
  238.     0x000,
  239.     0x000,
  240.     0x000,
  241.     0x000,
  242.     0x000,
  243.     0x000,
  244.     0x000,
  245.     0x000,
  246.     0x000,
  247.     0x000,
  248.     0x000,
  249.     0x000
  250. };
  251.  
  252. UWORD EGAColours[16] =
  253. {
  254.     0x000,    /* Black. */
  255.     0xA00,    /* Dark red. */
  256.     0x0A0,    /* Dark green. */
  257.     0xA60,    /* Dark yellow (orange). */
  258.     0x00A,    /* Dark blue. */
  259.     0xA0A,    /* Dark magenta.*/
  260.     0x0AA,    /* Dark cyan. */
  261.     0xBBB,    /* Light grey. */
  262.     0x666,    /* Dark grey. */
  263.     0xF00,    /* Red. */
  264.     0x0F0,    /* Green. */
  265.     0xFF0,    /* Yellow. */
  266.     0x00F,    /* Blue. */
  267.     0xF0F,    /* Magenta. */
  268.     0x0FF,    /* Cyan. */
  269.     0xFFF    /* White. */
  270. };
  271.  
  272. UWORD ANSIColours[16] =
  273. {
  274.     0x000,    /* Black. */
  275.     0xF00,    /* Red. */
  276.     0x0F0,    /* Green. */
  277.     0xFF0,    /* Yellow. */
  278.     0x00F,    /* Blue. */
  279.     0xF0F,    /* Magenta. */
  280.     0x0FF,    /* Cyan. */
  281.     0xFFF,    /* White. */
  282.  
  283.     0x000,    /* Black. */
  284.     0xF00,    /* Red. */
  285.     0x0F0,    /* Green. */
  286.     0xFF0,    /* Yellow. */
  287.     0x00F,    /* Blue. */
  288.     0xF0F,    /* Magenta. */
  289.     0x0FF,    /* Cyan. */
  290.     0xFFF    /* White. */
  291. };
  292.  
  293. LONG __saveds
  294. Main()
  295. {
  296.     SysBase = *(struct ExecBase **)4;
  297.  
  298.     if(DOSBase = (struct DosLibrary *)OpenLibrary("dos.library",36))
  299.     {
  300.         if(IFFParseBase = (struct Library *)OpenLibrary("iffparse.library",0))
  301.         {
  302.             UBYTE **ArgArray;
  303.  
  304.             if(ArgArray = (UBYTE **)AllocVec(sizeof(UBYTE *),MEMF_PUBLIC | MEMF_CLEAR))
  305.             {
  306.                 struct RDArgs *ArgsPtr;
  307.  
  308.                 if(ArgsPtr = (struct RDArgs *)ReadArgs("File",(LONG *)ArgArray,NULL))
  309.                 {
  310.                     if(ArgArray[0])
  311.                     {
  312.                         if(LoadPhonebook(ArgArray[0]))
  313.                         {
  314.                             LONG i;
  315.  
  316.                             for(i = 0 ; i < NumPhoneEntries ; i++)
  317.                             {
  318.                                 switch(Phonebook[i] -> Config . ColourMode)
  319.                                 {
  320.                                     case COLOUR_EIGHT:    CopyMem(&ANSIColours[0],&Phonebook[i] -> Config . Colours[0],sizeof(UWORD) * 16);
  321.                                                 break;
  322.  
  323.                                     case COLOUR_SIXTEEN:    CopyMem(&EGAColours[0],&Phonebook[i] -> Config . Colours[0],sizeof(UWORD) * 16);
  324.                                                 break;
  325.  
  326.                                     case COLOUR_AMIGA:    if(Phonebook[i] -> Config . Emulation == EMULATION_ATOMIC)
  327.                                                     CopyMem(&AtomicColours[0],&Phonebook[i] -> Config . Colours[0],sizeof(UWORD) * 16);
  328.  
  329.                                                 break;
  330.                                 }
  331.                             }
  332.  
  333.                             if(!SavePhonebook(ArgArray[0]))
  334.                                 Printf("\33[1mColourPatch:\33[0m Couldn't save file \"%s\"!\a\n",ArgArray[0]);
  335.                         }
  336.                         else
  337.                             Printf("\33[1mColourPatch:\33[0m Couldn't load file \"%s\"!\a\n",ArgArray[0]);
  338.  
  339.                         if(Phonebook && PhoneSize)
  340.                             DeletePhonebook(Phonebook,PhoneSize,TRUE);
  341.                     }
  342.  
  343.                     FreeArgs(ArgsPtr);
  344.                 }
  345.  
  346.                 FreeVec(ArgArray);
  347.             }
  348.  
  349.             CloseLibrary(IFFParseBase);
  350.         }
  351.  
  352.         CloseLibrary(DOSBase);
  353.     }
  354.  
  355.     return(RETURN_OK);
  356. }
  357.  
  358.     /* Convert(struct PhoneEntry *Src):
  359.      *
  360.      *    Convert a phonebook entry.
  361.      */
  362.  
  363. struct NewPhoneEntry *
  364. Convert(struct PhoneEntry *Src)
  365. {
  366.     STATIC struct NewPhoneEntry Dst;
  367.  
  368.     CopyMem(Src -> Name,Dst . Name,30);
  369.  
  370.     Dst . Name[29] = 0;
  371.  
  372.     strcpy(Dst . Number,Src -> Number);
  373.  
  374.     strcpy(Dst . Password,Src -> Password);
  375.  
  376.     Dst . PayPerUnit[0] = Src -> PayPerUnit;
  377.     Dst . SecPerUnit[0] = Src -> MinPerUnit * 60;
  378.  
  379.     Dst . Config . BaudRate            = Src -> Config . BaudRate;
  380.     Dst . Config . BitsPerChar        = Src -> Config . BitsPerChar;
  381.     Dst . Config . Parity            = Src -> Config . Parity;
  382.     Dst . Config . StopBits            = Src -> Config . StopBits;
  383.     Dst . Config . Handshaking        = Src -> Config . Handshaking;
  384.     Dst . Config . Duplex            = Src -> Config . Duplex;
  385.     Dst . Config . HighSpeed        = Src -> Config . HighSpeed;
  386.     Dst . Config . BreakLength        = Src -> Config . BreakLength;
  387.  
  388.     strcpy(Dst . Config . SerialDevice,Src -> Config . SerialDevice);
  389.  
  390.     Dst . Config . UnitNumber        = Src -> Config . UnitNumber;
  391.  
  392.     strcpy(Dst . Config . ModemInit,Src -> Config . ModemInit);
  393.     strcpy(Dst . Config . ModemExit,Src -> Config . ModemExit);
  394.     strcpy(Dst . Config . ModemHangup,"~~~~~~+++~~ATH0\\r");
  395.     strcpy(Dst . Config . DialPrefix,Src -> Config . DialPrefix);
  396.  
  397.     Dst . Config . RedialDelay        = Src -> Config . RedialDelay;
  398.     Dst . Config . DialRetries        = Src -> Config . DialRetries;
  399.     Dst . Config . DialTimeout        = Src -> Config . DialTimeout;
  400.     Dst . Config . ConnectAutoBaud        = Src -> Config . ConnectAutoBaud;
  401.  
  402.     strcpy(Dst . Config . NoCarrier,Src -> Config . NoCarrier);
  403.     strcpy(Dst . Config . Connect,Src -> Config . Connect);
  404.     strcpy(Dst . Config . Voice,Src -> Config . Voice);
  405.     strcpy(Dst . Config . Ring,Src -> Config . Ring);
  406.     strcpy(Dst . Config . Busy,Src -> Config . Busy);
  407.  
  408.     strcpy(Dst . Config . Protocol,Src -> Config . Protocol);
  409.  
  410.     strcpy(Dst . Config . StartupMacro,Src -> Config . StartupMacro);
  411.  
  412.     strcpy(Dst . Config . MacroFile,Src -> Config . MacroFile);
  413.  
  414.     Dst . Config . DisplayMode        = Src -> Config . DisplayMode;
  415.  
  416.     CopyMem(Src -> Config . Colours,Dst . Config . Colours,sizeof(UWORD) * 16);
  417.  
  418.     Dst . Config . MakeScreenPublic        = Src -> Config . MakeScreenPublic;
  419.     Dst . Config . ShanghaiWindows        = Src -> Config . ShanghaiWindows;
  420.  
  421.     Dst . Config . CaptureFilter        = Src -> Config . CaptureFilter;
  422.     Dst . Config . DestructiveBackspace    = Src -> Config . DestructiveBackspace;
  423.     Dst . Config . AudibleBell        = Src -> Config . AudibleBell;
  424.     Dst . Config . VisibleBell        = Src -> Config . VisibleBell;
  425.     Dst . Config . EightyColumns        = Src -> Config . EightyColumns;
  426.     Dst . Config . SendCR            = Src -> Config . SendCR;
  427.     Dst . Config . SendLF            = Src -> Config . SendLF;
  428.     Dst . Config . ColourMode        = Src -> Config . ColourMode;
  429.     Dst . Config . Emulation        = Src -> Config . Emulation;
  430.     Dst . Config . Font            = Src -> Config . Font;
  431.  
  432.     strcpy(Dst . Config . DefaultStorage,"ENVARC:sys");
  433.  
  434.     return(&Dst);
  435. }
  436.  
  437.     /* CreatePhonebook(LONG Size,LONG *AllocSize,BYTE CreateEntries):
  438.      *
  439.      *    Create a new phone entry array (so-called phone book).
  440.      */
  441.  
  442. struct PhoneEntry **
  443. CreatePhonebook(LONG Size,LONG *AllocSize,BYTE CreateEntries)
  444. {
  445.     struct PhoneEntry **PhoneEntry = NULL;
  446.  
  447.     if(Size)
  448.     {
  449.             /* Round the number of phone entries to a
  450.              * multiple of eight.
  451.              */
  452.  
  453.         *AllocSize = (((Size + 7) >> 3) << 3);
  454.  
  455.             /* Create the list of pointers. */
  456.  
  457.         if(PhoneEntry = (struct PhoneEntry **)AllocMem(*AllocSize * sizeof(struct PhoneEntry *),MEMF_PUBLIC|MEMF_CLEAR))
  458.         {
  459.                 /* And create some entries if necessary. */
  460.  
  461.             if(CreateEntries)
  462.             {
  463.                 LONG i;
  464.  
  465.                 for(i = 0 ; i < Size ; i++)
  466.                 {
  467.                     if(!(PhoneEntry[i] = (struct PhoneEntry *)AllocMem(sizeof(struct PhoneEntry),MEMF_PUBLIC|MEMF_CLEAR)))
  468.                     {
  469.                         LONG j;
  470.  
  471.                         for(j = 0 ; j < i ; j++)
  472.                             FreeMem(PhoneEntry[j],sizeof(struct PhoneEntry));
  473.  
  474.                         FreeMem(PhoneEntry,*AllocSize * sizeof(struct PhoneEntry *));
  475.  
  476.                         return(NULL);
  477.                     }
  478.                 }
  479.             }
  480.         }
  481.     }
  482.  
  483.     return(PhoneEntry);
  484. }
  485.  
  486.     /* DeletePhonebook(struct PhoneEntry **PhoneBook,LONG Size,BYTE FreeEntries):
  487.      *
  488.      *    Deallocates a given phone book and its entries if necessary.
  489.      */
  490.  
  491. VOID
  492. DeletePhonebook(struct PhoneEntry **PhoneBook,LONG Size,BYTE FreeEntries)
  493. {
  494.     if(FreeEntries)
  495.     {
  496.         LONG i;
  497.  
  498.         for(i = 0 ; i < Size ; i++)
  499.         {
  500.             if(PhoneBook[i])
  501.                 FreeMem(PhoneBook[i],sizeof(struct PhoneEntry));
  502.         }
  503.     }
  504.  
  505.     FreeMem(PhoneBook,Size * sizeof(struct PhoneEntry *));
  506. }
  507.  
  508.     /* SavePhonebook(UBYTE *Name):
  509.      *
  510.      *    Save the current phone book to a disk file.
  511.      */
  512.  
  513. BYTE
  514. SavePhonebook(UBYTE *Name)
  515. {
  516.     struct IFFHandle    *Handle;
  517.     BYTE             Success = FALSE;
  518.     LONG             i;
  519.  
  520.     if(Phonebook && NumPhoneEntries)
  521.     {
  522.         if(Handle = AllocIFF())
  523.         {
  524.             if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  525.             {
  526.                 InitIFFasDOS(Handle);
  527.  
  528.                 if(!OpenIFF(Handle,IFFF_WRITE))
  529.                 {
  530.                     if(!PushChunk(Handle,'TERM','FORM',IFFSIZE_UNKNOWN))
  531.                     {
  532.                         if(!PushChunk(Handle,0,'VERS',IFFSIZE_UNKNOWN))
  533.                         {
  534.                             struct TermInfo TermInfo;
  535.  
  536.                             TermInfo . Version    = TermVersion;
  537.                             TermInfo . Revision    = TermRevision;
  538.  
  539.                             if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  540.                             {
  541.                                 if(PopChunk(Handle))
  542.                                     Success = FALSE;
  543.                                 else
  544.                                 {
  545.                                     if(!PushChunk(Handle,0,'DIAL',IFFSIZE_UNKNOWN))
  546.                                     {
  547.                                         if(WriteChunkBytes(Handle,&NumPhoneEntries,sizeof(LONG)) == sizeof(LONG))
  548.                                         {
  549.                                             Success = TRUE;
  550.  
  551.                                             for(i = 0 ; i < NumPhoneEntries ; i++)
  552.                                             {
  553.                                                 if(WriteChunkBytes(Handle,Convert(Phonebook[i]),sizeof(struct NewPhoneEntry)) != sizeof(struct NewPhoneEntry))
  554.                                                 {
  555.                                                     Success = FALSE;
  556.                                                     break;
  557.                                                 }
  558.                                             }
  559.                                         }
  560.  
  561.                                         if(PopChunk(Handle))
  562.                                             Success = FALSE;
  563.                                     }
  564.                                 }
  565.                             }
  566.                         }
  567.  
  568.                         if(PopChunk(Handle))
  569.                             Success = FALSE;
  570.                     }
  571.  
  572.                     CloseIFF(Handle);
  573.                 }
  574.  
  575.                 Close(Handle -> iff_Stream);
  576.             }
  577.  
  578.             FreeIFF(Handle);
  579.         }
  580.     }
  581.  
  582.     if(Success)
  583.         SetProtection(Name,FIBF_EXECUTE);
  584.  
  585.     return(Success);
  586. }
  587.  
  588.     /* LoadPhonebook(UBYTE *Name):
  589.      *
  590.      *    Restore a phone book from a disk file.
  591.      */
  592.  
  593. BYTE
  594. LoadPhonebook(UBYTE *Name)
  595. {
  596.     struct PhoneEntry    **PrivatePhonebook;
  597.     LONG             PrivatePhoneSize;
  598.     LONG             Size,i;
  599.     struct IFFHandle    *Handle;
  600.     BYTE             Success = FALSE;
  601.  
  602.     if(Handle = AllocIFF())
  603.     {
  604.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  605.         {
  606.             InitIFFasDOS(Handle);
  607.  
  608.             if(!OpenIFF(Handle,IFFF_READ))
  609.             {
  610.                 if(!StopChunk(Handle,'TERM','DIAL'))
  611.                 {
  612.                     if(!ParseIFF(Handle,IFFPARSE_SCAN))
  613.                     {
  614.                         if(ReadChunkRecords(Handle,&Size,sizeof(LONG),1))
  615.                         {
  616.                             if(Size)
  617.                             {
  618.                                 if(PrivatePhonebook = CreatePhonebook(Size,&PrivatePhoneSize,TRUE))
  619.                                 {
  620.                                     for(i = 0 ; i < Size ; i++)
  621.                                     {
  622.                                         if(!ReadChunkRecords(Handle,PrivatePhonebook[i],sizeof(struct PhoneEntry),1))
  623.                                         {
  624.                                             if(i)
  625.                                                 Size = i - 1;
  626.                                             else
  627.                                                 Size = 0;
  628.  
  629.                                             break;
  630.                                         }
  631.                                     }
  632.  
  633.                                     if(Size)
  634.                                     {
  635.                                         if(Phonebook)
  636.                                             DeletePhonebook(Phonebook,PhoneSize,TRUE);
  637.  
  638.                                         Phonebook = PrivatePhonebook;
  639.                                         PhoneSize = PrivatePhoneSize;
  640.  
  641.                                         NumPhoneEntries = Size;
  642.  
  643.                                         Success = TRUE;
  644.                                     }
  645.                                     else
  646.                                     {
  647.                                         DeletePhonebook(PrivatePhonebook,PrivatePhoneSize,TRUE);
  648.                                         Success = FALSE;
  649.                                     }
  650.                                 }
  651.                             }
  652.                         }
  653.                     }
  654.                 }
  655.  
  656.                 CloseIFF(Handle);
  657.             }
  658.  
  659.             Close(Handle -> iff_Stream);
  660.         }
  661.  
  662.         FreeIFF(Handle);
  663.     }
  664.  
  665.     return(Success);
  666. }
  667.