














        HISOFT  C  Compiler V1.1




















                      Copyright  C  1984  HISOFT











     ⠪,   ਬ:

     main()
     { printf ("Pierwszy program");
     };

     ᫥  ணࠬ    ⬥   (EOF), 
SS+I, ᫥ 祣  ᮮ饭:
                Type  y  to run
 ⮬  ணࠬ 㤥  ᪮஢  ⢥ y ਢ 
믮  ணࠬ!!!
     ந  㪠 樨,  ,, 㢨
 ࠭:
          Pierwszy program
          Type y to run:
     ᫨  y     ,  ⥬ HiSoft
३  砫쭮 ﭨ  ⥪ ணࠬ.
     ᠭ ᯮᮡ 樨 ᯮ ⮫쪮  樨
 ணࠬ. ⥫쭠   ணࠬ ⠢
᭠砫   ⮫쪮 ᫥ ⮣ .
     ᫨ ⥬ HiSoft 室  ० ஢,  
맮 ।  EDIT (CS+1),  ⥬ ENTER.  ⮬ 
࠭  '>'.  ப  ० ।஢ 㬥.
᫥⥫쭮  ஢ ஫  ࠥ; । ᠬ ᯮ-
   浪 ⠭.
        㤠 ப  - ஬ -
祭   㤠  Basic.  祭 ⨭ 
४⨢ L.
     ᫥ ⮣,   ।஢ 室 ⥪,  
᪮஢, ࠢ ४⨢ . ᫥ 맮  -
 ᯮ짮 ᯥ樠 ४⨢   #include    -  -
 ਢ    室 ⥪⮬ 㥬
ணࠬ  ।⢥  樨  ணࠬ. ᫨ ணࠬ
  訡,  ᫥  権  SS+I (EOF).
     ᫨ ᫥ 樨  ୥  ।   ४⨢
L,    㢨 室 ⥪ ணࠬ, ᫥⥫쭮, 
 㤠  樨.    ணࠬ 室
 㤠 ४⨢ Dm,n -  m,n - ப ணࠬ.
     ਬ:

200   main  ()
210   {
220   printf(Trzeci program");
230   }

᫥  ४⨢   #include  뤠  ᮮ饭:
   ERROR 37 - । ६,   砥 - -
⢨  祪 ". ᫨ ᫥ ⮣ 맢 ४⨢ Q, 
 ࠭   ப  訡.




                        2.  ணࠬ

      ⥬ HiSoft १ࢨ஢ ᫥騥 祢 ᫮:

     auto       else            long            typedef
     break      entry           register        union
     case       extern          return          unsigned
     chare      float           short           while
     continue   for             sizeof
     default    goto            static          ---------
     do         if              struct          fortran
     double     int             switch          asm

஬ ⮣: inline  cast.

     䨪ࠬ    ⫨  祢 ᫮
᫥⥫쭮   㪢, 稭騥  㪢. 訥  
㪢 ᯮ  ࠧ 䨪. ᯮ 
䨪 ࠢ 8 .
     ࠫ 뢠 ᫮ (᫠), ᨬ (ᨬ) 
ப ⠭. ᫮ ࠫ ⮨  ᫥⥫쭮
 .  ࠫ   '',   
ᨬ, ⫨  '  \,  ᠭ ᨬ ( \0 - ᠭ
ᨬ   ࠢ , \n - ᠭ ᨬ ' ப' ,
\r - ᠭ ᨬ ' ⪨', \t - ⠡, \' -
, \\ -  ).  ࠫ   's',
 s -  ᫥⥫쭮 ᨬ   ᠭ. ப
ࠫ ।⠢ ᮡ 뫪   ᨬ ᫥⥫쭮
ᨬ  ,  ᨬ   0  ⢥ -
⥫ ⮩ ᫥⥫쭮.
      ⫨稥  㣨 몮, ᨬ ࠫ  
 砥 ப.  'J' ।⠢ ᮡ ᨬ-
 , ஥  稭, ࠢ  㪢 J,   ६
 "J" ।⠢ ᮡ , 㪠뢠饥   ᨬ
᫥⥫쭮 ᨬ, 饩   J  ᨬ  
0.
      ࠧ ਬ:

     int Age=44; /* 1987 */
     main ()
     {
         printf("Jan %c is %d\" %s\"",'B', Age, "now");
     }

ᮤন ਩ /*...*/, 祢 ᫮ int, 䨪
Age, main  printf, ᨬ ࠫ 'B', ப ࠫ
"now",  =  ..  ⮣ 稬   JanB is 44 "now".
 



              3. ᠭ ६, 㭪権  ⨯

        ६묨  ⠭⠬  ।⠢
᢮ . ⥩訬  ⠭  ࠫ, 
६ - 䨪.  饬 砥   ।⠢-
 ࠦﬨ.
      , ।⠢ ࠫ, ᫥  ᠬ 
ࠫ, ᫥⥫쭮 ᠭ ࠫ 譥. ६ 
  易⥫쭮 ᠭ ।  ᯮ짮  ணࠬ.
     ᠭ ()  :
       ।-⨯ ᯨ᮪-஢;
 ਬ; int a,b,c. ᮪ ஢     ᫮
; int*(*(*fun())[2]().
     ࠢ ஢ ஢ ᫥騥:
᫨   Dec  ஬,  ࠬ
⠪  : (Dec),    ᠬ,   Dec;
Dec[w],  ᨢ  w ⮢; *Dec,  㪠-
⥫  ꥪ  Dec(),  㭪. 訬 ਮ⮬
 㣫 ᪮, ⤥騥 ᠬ ,  訬 -
 *.
     ਬ:
          int (*Name())[2] ࠢᨫ쭮 int(*(Name()))[2];
-  㭪樨 Name, १⮬ ன  㪠⥫
⭮ ᨢ  ⨯ (int). 訡筮 樥
: char Fun()[3], ⭠ har (Fun())[3], ..
  㭪, १⮬ ன  
ᨢ  ⨯ (char),  १⮬ 㭪樨   ⮫쪮
᪠ୠ 稭.
      ⬥,  ᫨  ꥪ ணࠬ 
  樨:
     ।-⨯ ,
  ਭ ࠢ ।:
     (।-⨯ ᥢ),
 ஬  ⫨砥  ᥢ ⥬, 
᫥  ᮤন 䨪 ꥪ.
     ਬ: ६ Ptr,   int(*Ptr)[2][3], 
⨯ (int(*)[2][3])

     -1  ६-0

# ६ ⨯ (char)  ਭ 祭 0...255;
# ६ ⨯ (int)  ਭ 祭 -32768...32767;
# ६ ⨯ (unsigned)  ਭ 祭 0...65535;
# 㪠뢠騥 ६ ⨯ (char)  ਭ 祭
㪠⥫  ६.
      ६  ᮢ  ᢮ 
砫쭮 祭  ⥬ ᫮,   祭  
᫥  । 믮 ணࠬ.





     -1UWAGA-0:   ॠ樨 몠  ᢠ 砫-
  ᪠ ⮫쪮  譨  ⭮襭 
। 㭪樨 :
        char Initial = 'J',
                Name = 'B';
        int  Age = 44;
        main()
        {
          int Year;
          Year = 1987;
            printf("%% is %d in %d", Initial, Name, Age, Year);
        }

     ᠭ  ᢮ 祭 ६ Year ॠ
ࠧ묨 ࠬ (..  ।   㭪樨),  
६ Age - .
     ᫨ ६ 砫   ᢠ,  ਭ
祭 0.
     ᬮਬ  㪠뢠騥  ६ .     ,
।騥  㣨 .  ८ࠧ ࠦ,
।⠢  ।  ,    ࠦ, ।⠢騥
㪠⥫   , ᯮ &.  ஬  *.

      ਬ, ⠪  ப ࠫ ।⠢ ,
㪠뢠饥    ᫥⥫쭮, । ⨬
ࠫ ( ࠫ "JB" ।⠢ , 㪠뢠饥  
J ),  ࠦ *"JB" ।⠢  J ᫥⥫쭮,
饩   J, B     .
        ࠦ  㪠⥫ﬨ ᪠ 樨 ᫮ 
⠭. , ᫨ Ptr  ࠦ, 㪠뢠饥  i- 
᫥⥫쭮 ,   Ptr + Num,  Num - 楫, 㪠뢠
 i + Num  ⮩ ᫥⥫쭮.
       *(Ptr + Num) ⭮ Ptr[Num]  Num[Ptr].
      ᪮ [ ]  쭥襬 㤥 뢠 ஬ -
஢.
     ਬ:

              char *Ref="Jan";
              main()
              {
                printf("%s=%c%c%c", Ref,*Ref,*(Ref+1),Ref[2]);
              }

      ⮩ ணࠬ Ref   ६, ன 
⠢  ᮮ⢥⢨ 㪠⥫  ⨯ (char). ..,
६, ।⠢  ணࠬ 䨪஬ Ref, 
⨯ (char *).   ६ Ref ᢮ 祭,
㪠뢠饥  㪢 J 4-  ᫥⥫쭮 J,a,n  
  .   믮 ,  ன 뢠





㭪 printf, ந室 뢠 蠡 %s  㪠⥫,
᢮ ६ Ref. ..  ࠭ 뢮  ᫥⥫-
 , 稭  㪠 ,     ,
᪫ ᫥, .. ᫮ Jan. ᫨ Ref ।⠢ 㪠⥫
  J,  *Ref ।⠢ ᠬ 㪢 J. ⥫쭮,
뢠 ࢮ 蠡 %  㬥⮬ *Ref ਢ   㪢
J. Ref + 1 ।⠢ 㪠⥫  㪢  ,  *(Ref + 1) - 㪢
. ࠦ Ref[2]  饭 ।⠢ *(Ref + 2), ,
᫥⥫쭮, ।⠢ 㪢 n.  ⮣ 稬 ᫮ Jan =
Jan.

      ࠧ:
       int Num; -  ६ ⨯ (int)
       int *Ptr;-                            (int *)
       int **Ref;-                           (int **)

                        -1 ᨢ-0

     ᨢ - ६ ᫮ ⨯,   ன 
  ⨯,   ᠬ ᨢ.     
ᨢ. ᨢ,   । 㭪樨,  
ᢠ 砫 祭. , । 砫 -
祭, 뢠 樠஬  ⮨  ᯨ᪠ ࠫ  { }.
 㬮砭 ⠬ ᨢ ᢠ 0.

      char Source [3][3] = {{'E','w','a'}, {'I','z','a'},
                                           {'J','a','n'}}
      main()
      {
           char Target [4]; /*  ண ᨢ */
           int i;

           for (i=0; i<4; i++)
                Target[i]=Source[2][i];
                Target[3]='\0';
                printf ("%s", Target);
       }

     .. Target [0]... Target [3] = J a n  0
      몥 ਭ,   ࠦ, ।⠢饥 ᨢ,
ࠧ   ८ࠧ  ࠦ, ।⠢饥 
 ᨢ, ᫥⥫쭮:
      printf("%s", Target); ⭮ printf("%s", &Target[0]);
      ᯮᮡ ࠪ⮢  ᨢ,   㪠⥫,
ਢ  ⮬,  믮 権  ᨢ  
 饬 砥  믮 権  㪠뢠騬 묨.
     ஬ ⮣, ⠬ ᨢ   , 㭨 
㪠뢠騥 ६:
 



        char *Family[3] = {"Ewa", "Iza", "Jan"};
         main ()
         {
                printf("%c&%c", **Family, *Family[2]);
         }

      ⠬ ᨢ  㪠⥫  ⨯ (char).
 । ᨢ,   Family[0] ᢮ 㪠 
  ᫥⥫쭮 Ewa, 筮, Family[1] - Iza, 
Family[2] - Jan. .. ࠦ Family ।⠢ ᮡ 㪠⥫ 
Family[0], ࠦ *Family ।⠢  Family[0], , ᫥-
⥫쭮, **Family ।⠢ ᮡ ꥪ, 㪠 ࠦ
Family[0], .. 㪢 . 믮 ணࠬ ਢ  
 & J.
      ᪠,  ᫨ ᠬ ᨢ Family  ⨯ (char *[3])
( 3-  ᨢ 㪠⥫  ⨯ (char)),  ࠦ
Family  ⨯ (char *), ࠦ *Family - (char *),  ࠦ
**Family - (char).
      ⫨稥  ।饣,   ਬ ᯮ ६,
 㪠뢠  ᨢ:

         int Array[2][2] = {{3,2}, {1,0}},
               (*Ptr)[2] = Array + 1;
         main ()
         {
              printf ("%d%d", **Ptr, Ptr[-1][0]);
         }

      Arry - 2-  ᨢ, ⠬ ண 
2-  ᨢ  ⠬ ⨯ int. ᨢ Arry 
ᬠਢ  㬥 ᨢ  ⠬ 3,2,1,0.    ६
Ptr  ⮩ ६, 㪠뢠饩  2-  ᨢ
⨯ int.  ਯᠭ 祭 Array+1    ⨯ (int *[2]).
 ᢮ ࠢ筮, .. Ptr  Array+1   ⨯
(int *[2]).


                  -1   㭨-0

     ࠬ  㭨ﬨ  ᫮ ६, 騥 
⮢ ࠧ ⨯.   뢠 ﬨ. ﬨ
   ⮫쪮  ६,   ᨢ,  
㭨.
       ࠧ    浪  , 
   㭨 ࠧ頥 稭    ⮣  .
⥫쭮, ᫨  ணࠬ   Record:

          struct{
             int Fix;
             char Chr;
             int Arr[3];
             char *Ptr[2];
           } Record;




 ﬨ Fix, Chr, Arr  Ptr,    ⮫쪮 , ᪮쪮 
   㬬.  , ᫨  㭨:

          union {
             int Fix;
             char Chr;
             int Arr[3];
             char *Ptr[2];
          }Record

   ⮫쪮 , ᪮쪮  ᠬ  .
뢠,   Hisoft ६ ⨯ (char)   , 
⨯ (int)  㪠뢠騥 -  2 ,    11 ,
 㭨 - 6  . .. ࠧ  㭨ﬨ  ࠬ
 ⮫쪮  ᯮᮡ ࠧ饭     ⮬,  㭨
 ਯ 砫쭮 祭.
       ⮨  祢 ᫮ struct ᫥
ண  { } ⮨ 祭  ,  ᫥  -
   ;.     䨪
,      ᫮ :

     struct {
         int Fix;
         char Chr[2][2];
     } Str, Arr[3], *Ptr[4];

-   Str  ﬨ Fix  Chr, 
3-⭮ ⠡  Arr,  ⠪   4--
 ⠡ 㪠⥫  ⠪  Str  Arr[i].
     ᫨  祢 ᫮ struct  ࢮ ᪮  ⮨
䨪,   쭥     ᯮ짮
 ஢   .  ⭮, 
砥,  ⠪ , :

         struct Tag {
             int Fix;
             char Chr;
         } One, Two [2];

 ன Tg  䨪஬,  쭥襬 뢠
⥫ ,   ࠢ ᯥ宬  
:

         struct Tag {
             int Fix;
             char Chr;
         } One;
         struct Tag Two[2];
 



 ன :

         struct Tag {
             int Fix;
             char Chr;
         };
         struct Tag One, Two[2];

     ᯮ짮 ⥫  楫ᮮࠧ   ,
         室  饭
 ⨯  㦥  :

         struct List {
             int Data;
             struct List *Link;
         } Str;

  Link   ᢮ 㪠⥫  ⨯ (struct
List).

       (  㭨)   ᢮ 室
. 樠  ⮨,  饬 砥,  ᯨ᪠  { }.
⠬ ᯨ᪠   ⠭,  ᥣ ࠫ, 
ᯨ᪨; ⠭   樠樨 ᪠ ,  ᯨ᪨
 樠樨 ,   ᨢ  ࠬ.
ᯨ᮪, ᯮ㥬  樠樨 ,  
䨪 ꥪ  ⨯ ⮣ . ᫨  ᯨ᮪
ᮤন   ⠭ ࠦ, 樨 
,  { }   饭. ᫨  ।  
।  砫 ,    室 
। 㭪樨,  ⠪  ᢠ ࠫ .
 ,   㭪樨,   
᢮ 砫 祭.

         struct {
             char One, Two;
             struct {
                 char Uno, Due;
             } InStr;
             char Arr[2],
                  *Ref;
             } OutStr={1,2,{3,4},{5}};

-  OutStr ᢮  ⠪ ࠧ,  
Arr[0] 㤥 ᢮ 5,   Ref - 0.
     -1UWAGA-0:  Hisoft  饭  ਭ, 
樠    ᮤঠ ᯨ᮪.  ⮣ ᫥,
  ਢ  樨 樠    
᫥騩: {1,2,3,4,5}. 㣨 㯫  , 
᢮  ⭮   ⤥  ,   
 , 뤥 . 뢠,  ⮬ ᯨ᪠




樠  ࠦ  祭 0 - 255,  樨
     , ᢮ :

         struct {
             int Uno, Due;
         } Str = {1,1};

-᢮  Uno , 稭 257,   Due - 0, 
1   .


                     -1 㭪権-0

      㭪権 ⮨    ⥫ 㭪樨.
 ᮤন  㭪樨,  㣫 ᪮ ᯨ᮪ ࠬ஢
㭪樨   ࠬ஢.  㭪樨  㯯
, 稭饩 {  饩 }. E᫨ 믮 㭪樨
稢 :
          return exp;
 exp - ࠦ,    맮 㭪樨 ⠭ 㯭묨
 exp.   ।  ᭮  
㭪樨.  ᫥饬 ਬ  ࠭ ⠥ Bielecki:

         main ()
          {
           char *Surname ();
           printf ("%s", Surname ("Jan Bielecki",4));
           }
         char *
         Surname (String, Number)
               char *String;
               int Number;
           { return String + Number; }

 ।  㭪樨: 㭪 main()  ࠬ஢ 
㭪 Surname   ࠬࠬ. ࠬ String ⨯ (char *)
易  㬥⮬ "Jan Bielecki",  ࠬ Number ⨯ (int)
易  㬥⮬ 4. ⮬ 㭪樨  ,
㯠饥   return.    ⨯ ( char *) 
ᮮ⢥⢨     㭪樨 ⨯.   맮
㭪樨 ந室 ।  ।,  㭪樨 main ந
।⥫쭠 .     
।  ண  ᯨ᮪  ࠬ஢   .
     ᫨ 믮 㭪樨  稢  return,
ᮤঠ饩 ࠦ,  । ⨯ १ 譥.  
 ᪠  ⨯ १  ࠬ஢ 㭪樨, ᫨
  ⨯ (int).




         int _13=-13;
         int
         main ()
         {
          int Negate ();
          printf ("%d", Negate(_13));
         }
         int
         Negate (Par)
             int Par;
         {  return -Par; }

- 頥 :

         int _13 = -13;
         main ()
         {
          printf ("%d", Negate (_13));
         }
         Negate (Par)
         {
          return -Par;
         }.

      ᫥饩 ணࠬ । 㭪樨 First  Second 
।⥫쭮 樥  㭪権.

         char Name [2] = "bj";
         extern char *First ();  /* First */
         main ()
         {
          printf("%c", *First());
         }
         char *
         First ()
         {
            char *Second();     /* Second  */
            printf ("%c", *Second (Name));
            return Name;
         }
         char *
         Second (Initials)
            char Initial [2];
         {
            return Initial + 1;
         }

 ࠡ ணࠬ -   jb.


 




                         -1ᠭ ⨯-0

      (ᠭ, ८ࠧ) ⨯ 筮 ।
६  ᪫祭 祢 ᫮ typedef.
         typedef har *PTR,
                      VEC [3];
- । ⨯ PTR, 騩 㪠⥫  ⨯ (char) 
 ⨯ VEC, 騩 3-  ᨢ  ⨯ (char).
᫥ ⠪ । ⨯  :
         PTR Arr[2], ChrPtr;
         VEC *Ref;

      ࢮ ப  2-  ᨢ ६ ⨯
(PTR), , ᫥⥫쭮, ᨢ 㪠⥫  ⨯ (char), 
६ ChrPtr, 㪠뢠  ⠪ .  ன - 㪠⥫
 ⨯ VEC, ᫥⥫쭮, 㪠⥫ 3-  ᨢ ⨯
(char).
      ,  ⠪ । ࠢᨫ쭮:

         char *Arr[2], ChrPtr;
         char (*Ref)[3];

     ਬ:

         typedef struct List {
               int Data;
               struct List *Linck;
               } LIST;

- LIST   ⨯ (struct List).  ࠧ 
       List Str[3], *Ref; 筠 struct List Str[3], *Ref

            4. ஥  ࠦ

     ᭮ ⮬ 몠   ࢨ ࠦ. 
:
-䨪:  Volume, Fun  .;
-ࠫ:    13, "JB", '\n'  .;
-஥ ࠦ  㣫 ᪮:   ( + );
-ࠦ, ।⠢饥 㭪,  ன ᫥ ᯨ᮪
㬥⮢  㣫 ᪮:  Fun (a,b);
-ࢨ筮 ࠦ, ᫥ ண ⮨ ࠦ  
᪮: Arr[3+i];
-ࢨ筮 l-ࠦ (.. ࠦ, ஥ ⮨ ᫥  
 ᨬ = ), ।⠢饥 ᮡ , ࠧ ᫥ ன
⮨  .  䨪  :  Str.Chr;
-ࢨ筮 ࠦ, ।⠢饥 㪠⥫ ,
।⢥ ᫥ ண ⮨ ᨬ ->  䨪 
: Ptr -> Chr.
  



   ⥫ ࠢ:
-l-ࠦ   , ।⠢ 㪠⥫ ꥪ:
&Fix;
-  :
      ࢨ筮-ࠦ (ᯨ᮪-ࠦ)
ࢨ筮 ࠦ  ।⠢ 㭪: Fun(a,b);
-  :
      ࢨ筮-ࠦ [ࠦ]
易⥫쭮   ࠦ   㪠⥫  
ᨢ :  2["Jan"].
     ࠦ  ࠦ  ।騬 ஬
ᨨ (-⨯). ᫨ Exp  ࠦ, ।⠢騬
஥ ,  (-⨯)Exp  ࠦ, ।⠢騬
 ⨯ (-⨯).  ⨯  ,  
ᠭ ⨯  . ᫨,  ਬ, Exp-ࠦ ⨯
(int *),  (char *)Exp ।⠢  ⨯ (char *).
     -1UWAGA-0:  ⥬ Hisoft  (-⨯), 㯠 
祭  ᨨ,   ० 祢 ᫮
cast:   cast(char *)Exp.
     ࠦ   ⨯  㣫 ᪮  ।騬
஬ ࠧ sizeof. ᫨ Nam -  ⨯,  sizeof(Nam)
 ࠦ, ।⠢騬 , 稭, ࠢ 
, 室  ࠭   ७  ⨯ (Nam).
     -1UWAGA-0:  ⥬ Hisoft  ⨯   祢
᫮, 騬 ⨯,  ਬ, int  䨪 ⨯.
     -1UWAGA-0:  ⥬ Hisoft  sizeof   ⭮
 ࠦ.
     ࠦ   :
     l-ࠦ   -ᢠ    ࠦ
 -ᢠ - =, *=, |=, %=, +=, -=, <<=, >>=, &=, ^=  
!=.  믮 樨    @=,  @ -   㪠
ᨬ, ࠢᨫ쭮 믮 樨 =@.
     ࠦ   :
     ࠦ? ࠦ-1: ࠦ-2
᫨ ࠦ  祭, ⫨筮  0,  १⮬ 3
㬥⭮ 樨 ?:  , ।⠢ ࠦ-1,
 ⨢ 砥 - ࠦ-2.
     ਬ:

         char Arr[2][2] = {'J', 'a', 'n', 'B'},
              * Ptr;
         main ()
         {
           typedef char *ChrPtr;
           Ptr = cast(Chrtr)(Arr+1)+1;
           printf ("%c%c", **Arr, *Ptr);
         }
   



       .   
ࠦ  ।騬 祢 ᫮ cast (⮫쪮  Hisoft).
 ਬ ਬ  ᨨ  ࠦ (Arr + 1).  ⮬
ࠦ (Arr + 1), ।⠢饥  ⨯ (char(*)[2]),
८ࠧ  ࠦ, ।⠢饥  ⨯ (char *), .. 
ࠦ ⠪  ⨯,   Ptr.
     ᫨  ⨯ (char) ᢠ ६ ⨯ (int)
 (unsigned),   ⮬ ᠬ 訩   ⮩ ६
 ﬨ. , , ᫨  ⨯ (int)  (unsigned)
 ᢮  ६ ⨯ (char),  ६ ᢮
訩  .  ᫨  ⨯ (int) ᢮ ६
⨯ (unsigned)  ,    .
        믮   믮
䬥᪨ 権:
- ᫨  㬥  ⨯ (char),   㤥 ८ࠧ 
⨯ (int);
- ᫨ ⮫쪮  㬥 2-㬥⭮ 樨  ⨯
(unsigned),  ன 㤥 ८ࠧ  ⮬  ⨯;
-  㣨   㬥   ⨯ (int), ⠪ 
㤥  १.


                         5. 믮 

        -ࠦ; , 㯯  稭騥
 祢 ᫮.  ,  ᪫祭 㯯,
ࠧ饩 ⥫ 㭪樨,  ।⢮ ⪠  㯯 ⮪
१ 稥:
         fin: return a+b;
     -ࠦ  :
         exp; -  exp  ந ࠦ.
 믮 ⠪  ந室 ᫥ ,
।⠢ ࠦ exp,  ⥬  ஢. 
᫥ 2+(=5)  , ࠢ 7    ⥬
.  .  2+(=5) 筮 =5.




                           6. 맮 㭪樨

     맮 㭪樨  :
     fun (arg1, arg2,... argN)

ਬ:

         main ()
         {
          int print ();
          output (13, print);
         }
         output (Num, Fun)
             int Num, (*Fun)();
         {
           (*Fun)("%d", Num);
         }
         print (Fmt, Val)
            char *Fmt;
            int Val;
         {
          printf(Fmt, -Val);
         }

-  믮 ਬ 㤥 ⠭  -13. 㬥 print 
८ࠧ  㪠 㭪樨 print, ᫥⥫쭮, *Fun
।⠢ 㭪 printf,  :
           (*Fun)("%d", Num);
믮     printf("%d",Num)

                  7. 室 ८ࠧ ணࠬ

     ⥣ࠫ쭠    Hisoft ࠧ  -
⥬, ⢫ 室 ८ࠧ ணࠬ.
४⨢  ⫨  㣨 ᥩ ⥬,  
 室  ⤥ ப, 稭  '⪨' - #.
       ᯮ㥬 ४⨢  
। ४⨢.  饬 砥:
       #define  䨪  ᫥⥫쭮-᪨-
       樨 ⮩ ४⨢ ᫥⥫쭮-᪨-
 뢠  䨪஬     ⥪
ணࠬ.

         #define   NULL   0
         #define   TRUE   1
         #define   void   int
         main ()
         {
          void out();
          out ("Izabela");
          }




          void
          out (Name)
            char *Name;
          {
            if (Name == NULL)
                return;
             while (TRUE) {
                printf ("%c", *Name);
             if (*Name++ == NULL)
                return;
              }
          }

                         ४⨢  # include

      樨 ४⨢  ࠬ஢  
樨 ணࠬ ⥪   । 砥  
 ⮩ ४⨢ .
     ४⨢ #include  ࠬࠬ:
          #include "" - 祭    ४⨢
⥪  䠩 ''.  ᯮ짮 䮭, ࠧ ᫥
ᯮ짮 ⮩ ४⨢ 室  䮭.
      ⮬ 砥, ᫨ 䠩 ''   ⥪ 㭪権,
   饭  ணࠬ,   ⥫쭮 祭
  ணࠬ 室 ᯮ짮 ४⨢:
          #include ?  ?
ਬ: ᫨  ணࠬ:

         main ()
         {
          sub ();
          fun ();
         }
          sub ()
           { printf ("JanB sub \n"); }

  䠩 LIBRA  ⥪:

          sub ()
           { printf ("Library sub "); }
          fun ()
           { printf ("Library fun"); }

 믮   樨  ४⨢:
                #include
                #include ? LIBRA ?
ਢ   ணࠬ:




         main ()
         {
          sub ();
          fun ();
         }
          sub ()
           { printf ("JanB sub \n"); }
          fun ()
           { printf ("Library fun"); }

                       ४⨢    # translate ''
४⨢ 믮 । 樥,  ਢ  ନ஢
ணࠬ , ࠧ頥  䠩 ''  㦠 
Basic' :

         LOAD "" CODE
         RANDOMIZE USR 25200.


                  8. ᯮ짮 ⥪ 㭪権

     ⭮  ஬ 몠 ଠ Hisoft ⠢ 
; stdio.h    stdio.lib.   ᮤন  
।:
         # define NULL  0
         # define FALSE 0
         # define TRUE -1
         # define EOF  -1
         typedef int FILE;
         extern unsigned strlen ()   .;
 ⠪  ।  㭪権 min ()    max ().
      室,   ।  樨 
  ணࠬ:

            #include "stdio.h"
            main ()
            {  printf("%d", max('J','B'));  }



            #include "stdio.h"
            main ()
            {  printf("%d", strlen("JB"));  }
            #include ? stdio.h ?

     ᠭ ᮤন 䠩 stdio.h  stdio.lib ਢ 
ਫ .  ᮧ  ᮡ⢥ ⥪, ᮧ 
। ᫥⥫쭮 ᠭ  믮 ४⨢ । :
p1,9999,JB.LIB.





                 9. 믮 権 /뢮

       権 /뢮 ந室  ଠ樨
 ᨢ   㤮.  䠩  ᨢ 
㤮 ⢫   㭪樨 fopen(),  ४饭
⮩ 裡 - fclose(). 䨪 䠩 ந室  
䠩 㪠⥫, 砥  १ 㭪樨 fopen. ⨬
㪠⥫   ⨯ (FILE *), 饥  ॠ樨 
।  䠩 stdio.h.  ⥬ Hisoft ⨯ FILE । 
 ४⨢:
         typedef  int  FILE;  ..   ⫨砥  ⨯ (int)
     樠 ࠧ ࠪ  䠩: ⠭ 䠩 ,
⠭ 䠩 뢮  ⠭ 䠩 ᮮ饭  訡.
 ⥬ Hisoft ⠭ 䠩  易  ன,  䠩
뢮  ᮮ饭  訡 -  孥  ࠭. 
  ன, ࠭  ਭ஬, ᫥⥫쭮,  ॡ
।⥫쭮 믮 㭪樨 fopen. ᫨  ⨯ (STREAM) ।
:
         typedef  FILE *STREAM;
 ⠭ ᫥饥 ᮮ⢥⢨:

         㤮                       㪠⥫

                                 cast(STREAM) 0
     ࠭                    cast(STREAM) 0
     ࠭                     cast(STREAM) 1
     ࠭                    cast(STREAM) 2
           ਭ                         cast(STREAM) 3

      㭪権,  易  ⠭묨 䠩
(printf  .),   맢  ⠭ 䠩 㪠⥫.

                    㭪  fopen  (஥)
              FILE *fopen (name, mode)
                 char *name, *mode;

      맮 㭪樨 뢠 䠩, 易  ᨢ name, 
०, ⠭ 㬥⮬ mode:
                        mode = "r" - 䠩  ;
                        mode = "w" - 䠩  뢮.

     ⮬ 㭪樨  䠩 㪠⥫, 騩
 䠩. ᫨ 䠩  ,  १ - ⮩
㪠⥫ (NULL)

                    㭪  fclose (஥)
                       FILE *ptr;
 



    믮 㭪樨 fclose ਢ   䠩,
㥬 㪠⥫ ptr. ᫨ 䠩    뢮, 
 ⨥ 㤥 ᮯ஢  ' 䠩' - EOF, 
 Hisoft  (SS+I)  -1.

         typedef  int  FILE;
         main ()
         {
           FILE *out, *fopen();
           out = fopen("JANB","w");
           putc ('J', out);
           putc ('b', out);
           fclose (out)
         }

- 믮 㭪樨 fopen ਢ   䠩, 易 
ᨢ JANB,  뢮. ⮬ 㭪樨  䠩
㪠⥫, 騩 㯮 䠩.  㪠⥫ ᢮
䠩 ६ out,  ன  饭  㭪 putc 
fclose.  ࠧ, 믮  㭪権  饬 砥
⭮  ᨢ JANB. 믮 㭪樨 fclose ਢ 
 䠩,   EOF.

                    㭪  getc  (஥)

                   int getc (inp)
                    FILE *inp

     뢮 ।   䠩 inp. ⮬ 㭪樨 
  ⨯ (int) 稭, ࠢ   .

                    㭪  ungetc  (஥)

                     ungetc (,inp)
                       char ;
                       FILE *inp

       䠩 inp, ᨬ, ।⠢ . 砥
 ⮬,   ᫥饬 믮 㭪樨 getc ⢫
  饭 ᨬ.


                    㭪  putc  (஥)

                   int putc (,out)
                    char c;
                    FILE *out;

     뢮  䠩 out  . ⮬ 㭪樨  
⨯ (int) 稭, ࠢ   .




         typedef int FILE;
         typedef FILE *STREAM;
         # define EOF (-1)
         # define monitor cast(STREAM)0
         main ()
         {
           FILE *inp, *fopen ();
           int ch;
           if (inp=fopen("stdio.h","r")) {
              while ((ch=getc(inp))!=EOF)
                 putc (ch,monitor);
              putc ('\n', monitor);
              }
         }

- 뢮 䠩 stdio.h  .


                    㭪  getchar  (஥)

                   int getchar ()

       ᨬ  ⠭⭮ 䠩 . 
㭪樨 -  ⨯ (int), ࠢ   ᨬ  EOF.


                    㭪  putchar  (஥)

                   int putchar ()
                        int ;

     뢮  ⠭ 䠩 뢮     . 
㭪樨 -  ⨯ (int), ࠢ  뢮 .

         # define EOF (-1)
         char flag;
         main ()
         {
           int ch;
           if ((ch = getchar() ) != EOF)
                main ();
           if ( !flag ) {
                flag = 1;
                putchar ('\n');
                }
           putchar (ch);
         }

-    ᫥⥫쭮 , 稢饩 EOF, 
⥬ 뢮 ⮩ ᫥⥫쭮  ⭮ 浪.
 




                    㭪  printf (஥)

                   printf (fmt, p1, p2, ..., pn)
                     char *fmt;

     믮  㭪樨 ਢ  뢮  ⠭ 䠩
뢮  ࠢ ᯨ᪠ ଠ⮢ fmt , ।⠢ p1

... n. 㭪 printf   맢  ६ ᫮
㬥⮢;   , 祬 ଠ⮢ ᨨ, ᮤঠ 
᫥⥫쭮 fmt.  ଠ, ᫨  , ⮨ 
᫥⥫쭮 , 稭饩  ᨬ %  稢饩
  㪢: d, o, , u, , s.

     % - 砫 ଠ ८ࠧ. 砥,  뢮
᫥⥫쭮   ஢  室  ;

     d - 뢮 㬥⮢    ᥫ;
      - 뢮 㬥⮢   쬥 ᥫ;
      - 뢮 㬥⮢   ⭠ ᥫ;
     u - 뢮 㬥⮢   ᫠  ;
      - 뢮 㬥⮢    ;
     s - 뢮 ᫥⥫쭮 , 㪠 㬥⮬.
         printf("Any Text" );  --->   Any Text
         printf("(%-2d)",5); --->     (5)
         printf("(%4.3s)","JanB"); ---> (Jan)
         printf("%c",'B');  --->      B
         printf("%x", -1);  --->      FFFF


                    㭪樨  fprintf (஥)

                   fprintf (out,fmt, p1, p2, ..., pn)     ;
                     FILE *out;
                     char *fmt;

     뢮  䠩, ஢ out,  ଠ fmt ६ p1
- pn. 筠 printf;   맢  ६ ᫮
㬥⮢.

 



                   㭪  sprintf (஥)

                   sprintf (str,fmt, p1, p2, ..., pn)
                     char *str;
                     char *fmt;

      믮 ⮩ 㭪樨  p1 - pn ࠧ  
 str  ࠢ fmt. 㭪   맢 
६ ᫮ 㬥⮢.

         # include "stdio.h"
         FILE *Inp, *fopen ();
         char Number[7];
         int Ind, Ch, Count;
         main ()
         {
            if (Inp=fopen("Janek","r")) {
               while ((Ch = getc(Inp)) != EOF)
                  Count++;
               sprintf (Number, "%u%c", Count, '\0');
                 while (Number[Ind] == ' ')
                     Number[Ind++] = '*';
               printf ("Janek zawiera %s znakow", Number);
               }
         }

-    䠩 Janek  뢮  :
       Janek zawiera **** 13 znakow


                    㭪  scanf (஥)

                   int scanf (fmt, p1, p2, ..., pn)
                     char *fmt;

     믮  㭪樨 ਢ    ⠭⭮ 䠩
  ࠢ ଠ⮢ fmt ⠭ ᫠ ,
ࠪ⮢   ᫥⥫쭮 稭 ६  ᢮
 稭 㬥⠬ p1 ... pn. 㭪   맢 
६ ᫮ 㬥⮢, 騬  ᫠ ଠ⮢. 
ଠ, ᫨  , ⮨  ᫥⥫쭮 ,
稭饩  ᨬ %  饩   㪢: d, o, x, c, s.
᫥⥫쭮 , 㪠 fmt,  饬 砥 ⮨ 
஡, , ⫨  ஡,  ଠ⮢ ८ࠧ. ᫨
 ⠪ ᫥⥫쭮  ஡,  室 䠩 
 ᮮ⢥⢮ ᫥⥫쭮 㯮 (஡, 
⠡樨    ப). ᫨  ᬠਢ
᫥⥫쭮  , ⫨  ஡,  
室 䠩  ⢮ ⠪  . ᫨   
 㪠⥫ ८ࠧ,   । ࠧ  ᯮᮡ
樨 ᫥饣  室 䠩.  
࠭稢 訬 㯮,  ᫨  ଠ 㪠 稭




,      , 祬 㪠  ଠ. ᫨
᫥  % ⮨  *,  襥  室 䠩
.
     祭 , ⮡ ⨯ ६, 㪠뢠 㬥⠬
㭪樨 scanf, ᮮ⢥⢮ ଠ⠬.  ਬ, ᫨ 
ᯮ짮 ଠ %d,  ६, 㪠 㬥⮬,  
⨯ (int),     ⨯ (char).
     ⮬ 㭪樨 scanf   ⨯ (int), ࠢ
 ६,  뫨 ᢮   EOF.

                    㭪  fscanf (஥)

                   int fscanf (inp,fmt, p1, p2, ..., pn)
                     FILE *inp;
                     char *fmt;

       䠩, 㪠 inp,   ࠢ fmt ....
筮 scanf.

                    㭪  sscanf (஥)

                   int sscanf (str,fmt, p1, p2, ..., pn)
                     char *str;
                     char *fmt;

        , 㪠 str,  ࠢ fmt
⠭ ᫥⥫쭮   .. 筮 scanf.

         int myAge;
         char Sep;
         char myName[20];
         main ()
         {
           sscanf("Age=44 JanB=Janek",
                  "Age=%d%c%*5s%3s",
                  &myAge, &Sep, myName);
           printf ("%sis%dcnow", myName, myAge, Sep);
         }

-   Jan is 44 now.

                    㭪  raw (஥)
                        raw ()
         ᨬ  뢮   ࠭  
। .  㭪樨 - ६ ⨯ (int), ࠢ
  ᨬ.
 



                   㭪  keyhit (஥)
                      int keyhit ()

     ஢ઠ    ।  
ᨬ.  㭪樨 - ६ ⨯ (int),  稭
0, ᫨    1 (⨭), ᫨    
 ᨬ.

                       10. ७  ਬ

       ६ 易  .  묨 饭ﬨ
 ᪠,  ᫨  樨  㪠 ,  ६,
  㭪樨,   auto,  ६,
  㭪樨 -  extern.   
砥  ⮬,  ६  auto ᮧ  ।
 맮 㭪樨   ⢮ ᫥ 砭
믮 㭪樨,   ६,  ६  extern
  ६ 믮 ணࠬ. 㣮  ᮡ
६  extern  , , ᫨  ணࠬ 
᪮쪮  ன ६  ਡ⮬ extern  ⮫쪮
  ⮩ ६  ਡ extern, 室饥 
㭪樨,     ⭮  ⮩ ६.
     ६  static   ६ 믮
ணࠬ,  ᫨    㭪樨,   ⠭
㯭 ⮫쪮  믮 ⮩ 㭪樨.   
static     ६  extern,   
᫮ extern,  ᢠ 砫 祭.

             -1㭪樨  ६ ᫮ 㬥⮢-0

     㭪  ६ ᫮ 㬥⮢   ।
 맮 ⮩ 㭪樨,    ।,
।⢥ ᫥ ᪮, 몠饩 ᯨ᮪ ࠬ஢, 
 ᫮ auto. ᫨  ᫮ ᮡ,   맮 㭪樨
㤥   㬥⮬ ⨯ (int), 㪠뢠騬, ᪮쪮 
﫨  㬥 㭪樨,    㬥. 
⬥,  㬥   浪  㯫  맮
 뢠    浪 뢠 ᮢ.  ⭮,
१⮬ 㭪樨 max  ᨬ ।  㬥⮢
⨯ (int):

         int
         max (Count) auto
            int Count;
         {
           int argc, *argv, max;
           argc = (Count >> 1)-1;
           argv =  Count + argc;
           max = -32768;
           while (argc--)
                if (*argv-- > max)




                max = argv[1];
           return max;
         }

     -1UWAGA-0: ⮣    몥.

                        -1  inline-0

      ⥬ Hisoft    ⠢  ᢮ ணࠬ
  ࠣ  設     inline. 㬥⠬
⮩    ந ࠦ,  ⭮,
16- ࠫ 0dd. ਭ,   㬥  । 0-255
   ,   ᫥騩 -   .
 䠩 stdio.lib  inline ᯮ  । 鸞
᪨ 㭪権:

         cls ()
         {
           inline (0xCD, 0xD6B);
         }

     -1UWAGA-0: ⮣    몥.


                            -1ਬ-0

1.। 㭪樨  ᫥ ᮫⭮ 稭 㬥
⨯ (int).

         int
         abs (Par)
           int Par;
         {   return  Par < 0 ? -Par: Par  }

2.। 㭪樨  ᫥ ᨬ쭮  ᨢ 
⠬ ⨯ (int):

         int
         max (Arr, Len)
           int Len, Arr[];
         {
           int Val;
           Val = -32768;
           while (Len--)
                if (Arr[Len]>Val)
                Val = Arr[Len];
           return Val;
         }

3.। 㭪樨   ᫠    㬥
⨯ (int):
 



        int
         count (Bits)
            unsigned Bits;
         {
            int  Tally
            for (Tally = 0; Bits; Bits >>=1)
                Tally+ = Bits&1;
            return Tally;
         }

4.। 㭪樨 ,㬥⮬ ன   , 
१⮬ -  ⨯ (char), 室饥  ⮬ :

         har
         peek (Addr)
           unsigned Addr;
         {
           typedef char *ChrPtr;
           return *cast(ChrPtr)Addr;
         }

5.। 㭪樨 poke    ⨯ (char)  
Addr:

         poke (Addr, Data)
           unsigned Addr;
           char Data;
         {
           typedef char *ChrPtr;
           *cast(ChrPtr)Addr = Data;
         }

 6.। 㭪樨 ࠢ ᫥⥫쭮⥩ :

         int
         strcmp (Src, Trg)
           char *Src, *Trg;
         {
           while (*Src == *Trg++)
              if (!*Src++) return 0;
           return *Src > Trg[-1] ? 1: -1;
         }

7.। 㭪樨  ᮧ  ⨯ (int) 
᫥⥫쭮 :

         int
         atoi (Src)
           char *Src;
         {
            int Chr, Val;
            Val = 0;
            while ((Ch = *Src++) == ' ')
              Val = 10*Val+Chr - '0';
            return Val;
         }





8.ᯮ 㭪樨 ᪮ ࠢ  (calloc  free),
ᠭ  ਫ , ᮧ ப ।, 騩
ᮧ ⥪, ப ண 㬥 ᫠  .
ਭ,   ப ॡ  ᫠  ⥪ ப. ᫨
⥪ ப  (),  ப . ᫨
  ᫮  ⥪,    뢮  ப
⥪.   ப  稢  ENTER, 
⥪ -  EOF (SS + I).

         #include "stdio.h"
         typedef struct Str{
              struct Str *next;
              int lab;
              }LIST;
         typedef LIST *ListPtr;
         typedef char *CharPtr;
         LIST head = {NULL};

         main ()
         {
           extern LIST *find();
           int num, del;
           char line[81];
           LIST *pos;
           num = 0;
           do {
              if (!num)
                display();
              else {
                pos = find(num);
                if (pos->next&&pos->next->lab == num)
                  delete (pos);
                if (del! = '\n') {
                  getLine (line,81);
                  insert (pos, num, line);
                }
              }
              getNumber (&num, &del);
           }
         LIST*
         find (num)
           int num;
         {
           LIST *ref;
           ref = &head;
           while (ref->next&&ref->next->lab < num)
              ref = ref->next;
           return ref;
         {




         delete (pos)
           LIST *pos;
         {
           LIST *ptr;
           ptr = pos->next;
           pos->next = ptr->next;
           free(cast(CharPtr)ptr);
         }

         getLine (ptr, max)
           char *ptr;
           int max;
         {
           int i, c;
           for (i=0;
                i < max-1&&(c=getchar()) != '\n';
                i++) *ptr++ = c;
           if (c != '\n')
              while (getchar() != '\n');
                *ptr = '\0';
         }

         int
         length (line)
           char *line;
         {
           int len;
           len=0;
           while (*line++)
             len++;
           return len;
         }

         insert (pos, num, line)
           LIST *pos;
           int num;
           char line[];
         {
           LIST *ptr, *ref;
           int size;
           size=sizeof(ListPtr)+sizeof(int)+length(line)+1;
           if (ptr=cast(ListPtr)callof(1,size)) {
             ref=pos->next;
             pos->next=ptr;
             ptr->next=ref;
             ptr->lab=num;
             fill(cast(CharPtr)(ptr+1),line);
           } else
             printf ("Zignorowano:-brak pamieci");




         }

         display ()
         {
           LIST *ref;
           ref=head.next;
           while (ref) {
             printf ("%3d%s\n", ref->lab, cast(CharPtr)(ref+1));
             ref=ref->next;
           }
         }

         fill (ref, line)
           char *ref, *line;
         {
           while (*ref++=*line++);
             *ref='\0';
         }

         getNumber (num, del)
           int *num, *del;
         {
           int c, val;
           val=0;
           while ((c=getchar())>='0'&&c<='9')
             val=10*val+c-'0';
           *num=val;
           *del=c;
         }

         #include ? stdio.lib ?

9. ணࠬ  뢮  ࠭ ᮤন 䠩 TEXT.DOC:

         #define EOF (-1);
         typedef int FILE;
         main ()
         {
           int Chr;
           FILE *input, *fopen();
           if ((input=fopen("TEXT.DOC","r"))!=NULL)
             while ((Chr=getc(input)) != EOF)
             putchar (Chr);
         }




10.ணࠬ ஢ ப    ਭ:

         typedef int FILE;
         #define EOF (-1)
         main ()
         {
           FILE *STREAM;
           int Chr;
           while ((Chr=getchar() != EOF)
             putc (Chr, cast(STREAM)3);
         }




             ਫ .     Hisoft

     ४⨢ ।  :
         Dn1,n2,t1,t2;
- D-㪢 ४⨢, n1  n2 - 楫 ᫠ 1 ... 32767,
t1  t2 -    20 ᨬ .  ࠬ
  饭.  ⮬ 砥  ਭ 祭
ᮮ⢥ ࠬ஢ ।饩 ४⨢.
     ᫨ ⥬ Hisoft 室  ० 樨,   맮
। 室  EDIT (CS+1),  ⥬  ENTER. 
砭 ।஢  맮  ᯮ ४⨢
,   室  Basic - ४⨢ .

     -1४⨢ I (insert)  Im,n-0
     ४⨢ 㦨  樠樨 ⮬᪮ 㬥樨 ப
⥪. ।⢥ ᫥  믮  ࠭  ᫮
m. ᫥  ENTER  ப  ⨬ ஬ 稢,  
࠭   ப  ᫮ m+n, ᮮ⢥饥 
᫥饩 ப.  ४饭 ⢨ ४⨢ I  EDIT.

     -1४⨢ L (list)  Lm,n-0
     ४⨢ 㦨  뢮  ࠭ ப ⥪ n ... m.
 㬮砭 m=1,  n=32767. ᫨  ⥪  㬥頥  ࠭,
  뢮 ﬨ  10 ப.  樨 뢮  
 ४⨢ .  室  ४⨢ 室 
EDIT.

     -1४⨢ K (Chunk)  Lm-0
     ४⨢ ⠭  뢮  m ப  ४⨢ L.

     -1४⨢ W (Write)  Wm,n-0
     뢮  ਭ.  뢠  - BREAK.




     -1४⨢ S (Set)  S,,d-0
      ᥯ 㬥⮢ ४⨢.  㬮砭
᥯஬   ,   ⠭  㣮 .

     -1४⨢ V (View)  L-0
     뢮  ࠭ 㬥⮢ n1, n2, t1, t2, ᯮ짮 
᫥ 믮 ४⨢; 뢮 ᮢ 砫   
⥪.

     -1४⨢ D (Delete)  Dm,n-0
      ப  m  n. D10,10  D10 - 㤠 ⮫쪮 10-
ப.

     -1४⨢ N (Renumber)  Nm,n-0
     ७㬥: ࢠ ப   m, ᫥騥 n+m.

     -1४⨢  (Put)  Pm,n,t-0
        ,   䠩   t, ப ணࠬ
 m  n.

     -1४⨢ G (Get)  G,,t-0
       譥    䠩   t ⥪ ணࠬ.
 ⥪ ࠧ頥 ।⢥  㦥 ।஢,
  ப ⮬᪨ 㬥  ⭮ 10.

     -1४⨢  (Compiler)  C-0

     -1४⨢ B (Basic)  B-0
         - PRINT USR 25200.

     -1४⨢ F (Find)  Fm,n,f,s-0
       १ m...n ப  訬 ஬, ᮤঠ饩 f.
᫥ ⮣ 믮 ४⨢ .  ⥪   
 ⥪ s, ᫨ ᯮ짮 ४⨢ s.

     -1४⨢  (Edit)  Em-0
      믮 ⮩ ४⨢ ந室  樨
ணࠬ, ᮤঠ饩 訡 ப m.  ⮬ 砥  ࠭
뢮 ᮮ饭  訡,    EDIT  믮
४⨢ Em.  ⨨  㣮  뢠 .
஢ ப ⢫   
४⨢.

* ४⨢ => (CS+8)
     ᫨   ᯮ짮 ⮩ ४⨢  ⮣
ப 뫠 뢥  ࠭,   ப  
ᨬ,  ⨢ 砥  ᫥騩  ⮣ ப;

* ४⨢ <=  (CS+5)
     ࠭  ࠭ ᫥  ⮣ ப  ᤢ
 ࠢ;

* ४⨢ ENTER
     ७  ⮣ ப ⠢ ᨬ 室, 砭
।஢    ⥪ 室 ப  ⮣;




* ४⨢ Q (Quit)
     砭 ।஢   室 ப;

* ४⨢ R (Replace)
     ஢ ⮣ ப  ७ ।஢;

* ४⨢ L (List)
     ७  ⮣ ப ⠢ ᨬ 室  ⠭
  砫 ⮣ ப. - ⮣ ⠭
室,   ⮣ - ⮩;

* ४⨢  (Kill)
     ᫨  ࠭ 뢥  ⮣ ப,   믮
४⨢ 㤠 訩 ᨬ 室 ப,  ⨢
砥 㤠 ,   室   ⮣ ப;

* ४⨢ Z (Zeroize)
     ய  ᨬ ⮣ ப, 稭  ᨬ 
஬   ᫥ ᨬ -   ᬮ७ -
室;

* ४⨢ I (Insert)
         L  *  室  ०,  ஬
ᨬ,   ,  ।⢥  ⮣
ப.  ⮬ ० 訡 ࠭ DELETE. 室  ० 
 ENTER.

* ४⨢ X (External)
     ७  ⮣ ப ⠢ ᨬ 室, 뢮 
࠭ ᥩ ⮣ ப   믮 ४⨢ I;

* ४⨢ C (Chang)
         L  +  室  ०,  ஬
ᨬ,   , ।⢥   ⮣
ப. ᫨    ⠪ ᨬ  ࠭ 뢥 
⮣ ப,   ᨬ ࠧ   ப, 
᫥騩  室 ப ᪠.  ⨢ 砥 
ᨬ 頥 室騩  ஬ ᨬ 室 ப 
 믮  ४⨢ =>. 室  ⮣ ०  ENTER.

* ४⨢ F (Final)
     ४⨢ 믮 ᫥  믮 ४⨢ E,
맢 믮 ४⨢ F.  ⮬ ࣠ 
᫥饣 ⪠, ᮤঠ饣 ⥪ f,   㪠 
।⥫쭮 믮 ४⨢ F.  ,  
⥪ ⢫  ࠭, ।  ४⨢ F;

* ४⨢ S (Substitute)
       ⥪ f ⥪⮬ s   믮
४⨢ F.  ⥪   樨஢ 믮
४⨢   ४⨢ F.






            ਫ .    㭪樨

䬥⨪,  樨  ᨨ

㭪 max; (stdio.h)
        int max (count) auto
        int count;

㭪 min; (stdio.h)
        int min (count) auto
        int count;

㭪 abs; (stdio.lib)
        int abs(p)
        int p;

㭪 sign; (stdio.h)
        int sign (p)
        int p;

⮬ 㭪樨   稭  -1, 0  1 
ᨬ   㬥

㭪 peek; (stdio.lib)
        char peek (addr)
           unsigned addr;

頥  ⨯ (char), ࠭饥   addr.

㭪 poke; (stdio.lib)
        poke (addr, ch)
           unsigned addr;
           int ch;

㭪 tolower; (஥)
        char tolower (c)
           char c;

⮬ 㭪樨   ⨯ (char). ᫨ 
 㪢,  १ - ᮮ⢥ . 
⠫  - ᨬ, ࠢ .

㭪 toupper; (஥)
        char toupper (c)
           char c;




㭪 ⭠ tolower.

㭪 atoi; (stdio.lib)
        int atoi (str)
           char *str;

८ࠧ ᫥⥫쭮 ᨬ, 㪠 str  
⨯ (int). ᫨ ᫥⥫쭮 稭  楫 ᫠, 
१⮬   ᫮,  ⨢ 砥  - 0.

                         ஢

㭪 qsort; (stdio.lib)
        qsort (ptr, cnt, size, fun)
           char *ptr;
           int cnt, size;
           int (*fun)();

஢ ,  ᨢ  cnt ⮢,  
ண 㪠 str.  ⮢ । size,  ࠢ
㭪 - fun. 㭪, 易  ࠬ஬ fun,  
࠭ ⠪, ⮡   ⮢ elm1  elm2 १⮬ 맮:

                         (*fun)(&elm1,&elm2)

뫮  ⨯ (int) 稭 -1,0  1  ᮮ⢥⢨ :

                          -1 ᫨ elm1<elm2;
                           0 ᫨ elm1=elm2;
                           1 ᫨ elm1>elm2;

८ࠧ ᨬ ᫥⥫쭮⥩

㭪 strcat; (stdio.lib)
        char *strcat (first, second)
           char *first, *second;

 ᫥⥫쭮 ᨬ, 㪠 first,  
᫥⥫쭮 second (.. ᮥ second  first).
 㭪樨 -  ⨯ (*char), 㪠뢠饥   
᫥⥫쭮 first.

㭪 strcmp; (stdio.lib)
        int strcmp (src, trg)
           char *src, *trg;

ࠢ ᫥⥫쭮 , 㪠 src  trg,   
 ⨯ (int), ।饬 १ ࠢ.  
稭 0 -᫨ ᫥⥫쭮 ࠢ, ⥫ - ᫨ ࢠ
᫥⥫쭮  ன  ⥫, ᫨ ࢠ 
ன. ࠢ    ᫥⥫쭮   ࢮ
ࠢ.




㭪 strcpy; (stdio.lib)
        char *strcpy (dst, src)
           char *dst, *src;

஢ ᫥⥫쭮, 㪠 src,   ,
㪠 dst.

㭪 strlen; (stdio.lib)
        unsigned strlen (str)
           char *str;

   ⨯ (int) ࠢ   ᫥⥫쭮,
㪠 str.

                  ࠢ ⨢ 

㭪 calloc; (stdio.lib)
        char *calloc (n, size)
           unsigned n, size;

뤥  , ।祭  ࠧ饭 n ꥪ⮢
ࠧ஬ size     㪠⥫   . ᫨
뤥  ,  १ - NULL.

㭪 free; (stdio.lib)
        free (ptr)
           char *ptr;

᢮  , 뤥 㭪樥 calloc. 㬥
㭪樨 ।⠢ ᮡ 㪠⥫   .

㭪 swap; (஥)
        swap (pArea, qArea, len)
           char *pArea, *qArea;
           unsigned len;

 ⠬ ᮤন  ⥩   len ,
㪠 pArea  qArea.

㭪 move; (஥)
        move (dst, src, len)
           char *dst, *src;
           unsigned len;

஢    len, 㪠 src,  ,
㪠 dst.

                     樨 /뢮

㭪 gets; (stdio.lib)
        char gets (str)
           char *str;




饭   , 㪠 str, ᫥⥫쭮
ᨬ, 砥  ⠭⭮ 䠩 . 믮 㭪樨
稢  祭  '\n' (ENTER).    
뢠    0. ⮬ 㭪樨  㪠⥫ 
   .

㭪 puts; (stdio.lib)
        puts (str)
           char *str;

뢮  ⠭ 䠩 뢮 ᫥⥫쭮 ᨬ, 㪠
str. 室, ⮡ ᫥       0.

㭪 fgets; (stdio.lib)
        char *fgets (str, n, inp)
           char *str;
           int n;
           FILE *inp;

饭   , 㪠 str,   祬 n ,
砥  䠩, 㪠 inp. 믮 㭪樨 稢
 ࠧ饭 n-1    祭  '\n'. ᫥ ⮣ 
 ࠧ頥 ⥫    0. ⮬ 㭪樨
 㪠⥫       NULL, ᫨ 䠩
⮩.

㭪 fputs; (stdio.lib)
        fputs (str, out)
           char *str;
           FILE *out;

뢮  䠩, 㪠 out, ᫥⥫쭮 , 㪠 str,
稢饩 ᨬ   0.

                    砩 ᥫ

㭪 rand ; (stdio.lib)
        int rand()

㭪 srand (s); (stdio.lib)
        int s;

⠭  砩 ᥫ.

                      䨪  

㭪 plot; (stdio.lib)
        plot (on, x, y)
           int on,x, y;
 




  ࠭ ᥫ  न⠬ , y   梥⮬ paper, ᫨
on=0,  ink, ᫨ on=1.

㭪 line; (stdio.lib)
        line (on, dx, dy)
           int on, dx, dy;

稢 १ אַ  ⥪饩 樨, ⠭ 㭪樥
plot,  窨, 㤠  dx, dy. On । 梥.

㭪 paper; (stdio.lib)
        paper (color)
           int color;

㭪 ink; (stdio.lib)
        ink (color)
           int color;

㭪 cls; (stdio,lib)
        cls()

㭪 beep; (stdio.lib)
        beep (time, tone)
           int time, tone;

Tone -   Hz, time - ⥫쭮 1/10 s.







               ਫ D. 饭  訡

Error-0     missing 'x'
            ⢨  
Error-1     RESTRICTION: not implemented
             ⨯ 
Error-2     bad character constant
            訡  ᨬ쭮 ࠫ
Error-3     not a prerocessor command
            訡筠 ४⨢ ९
Error-4     LIMIT: macro buffer full
            । ⬥ ᠬ ᥡ
Error-5     can only define identifiers as macros
            訡筠 ४⨢ ९
Error-6     RESTRICTION: macros may not have parametrs
            訡筠 ४⨢ ९
Error-7     cannot open file
            ⢨ 䠩   
Error-8     RESTRICTION: cannot nest includes
            祭 䠩 ᮤন ४⨢ 祭 㣮 䠩
Error-9     missing while
            訡   do
Error-10    not in loop or switch
            ࠢ쭮 ᯮ짮  break
Error-11    not in loop
            ࠢ쭮 ᯮ짮  continue
Error-12    not in switch
             case  default ࠢ쭮 ᯮ짮
Error-13    LIMIT: too many case satements
            ᫨誮  case
Error-14    multiple default statments
             祬  default
Error-15    goto needs a label
            ⢨ ⪨   goto
Error-16    multiple use of identifier
            ᮢ ⪨  䨪
Error-17    direct execution not possible
            ४⭮ ᯮ짮 ४⨢ ९
Error-18    LIMIT: name table full
            ᫨誮  ⨯ 
Error-19    LIMIT: too many types
            ᫨誮  ⨯ 
Error-20    duplicate declaration - type
             
Error-21    duplicate declaration - storage class
             
Error-22    LIMIT: global symbol table full
Error-23    LIMIT: too much global data
            ᫨誮  ६   㭪樨
Error-24    duplicate declaration
             




Error-25    LIMIT: local symbol table full
            ᫨誮  ६  㭪樨
Error-26    this variable was not in parametr list
            ६  뫠 㯮  ᯨ᪥ ࠬ஢
Error-27    undefined variable
Error-28    bad function return type
            訡筮 ࠦ   return
Error-29    no arrys of functions
            ᯮ짮 ᨢ 㭪権
Error-30    LIMIT: expression too complicated
Error-31    LIMIT: expression too complicated
            ᫨誮 ᫮ ࠦ
Error-32    bad type combination
            ४ 㬥 樨
Error-33    bad operand type
            ४ 㬥 樨
Error-34    need an lvalue
            ᯮ짮  l-ࠦ
Error-35    not a defined members of a structure
               
Error-36    expected a primary here
            ᯮ짮  ࢨ筮 ࠦ
Error-37    undefined variable
            饭    ६
Error-38    need a type name
             ᯮ짮  ⨯
Error-39    need a constant expression
            ᯮ짮  ⠭⭮ ࠦ
Error-40    can only call functions
             맮  ᯮ짮  㭪樨
Error-41    does not follow ? properly
            ࠢ쭮 ᯮ짮 3-㬥⭮ 
Error-42    destination  must be an lvalue
            ᯮ짮  l-ࠦ
Error-43    need a:to follow ?
            ࠢ쭮 ᯮ짮 3-㬥⭮ 
Error-44    need a pointer
             ᯮ짮 㪠⥫
Error-45    illegal parametr type
            ४ ࠬ 㭪樨
Error-46    RESTRICTION: not implemented
             ⨯ 
Error-47    cannot use this operator
             ⨯ 
Error-48    bad declaration
            訡  
Error-49    storage class not valid
            訡  
Error-50




Error-51    duplicate declaration of structure tag
              ਧ
Error-52    use a predeclared structure for parameters
              ⨯ ᫥ 㭪樨
Error-53    structure cannot contain itself
               ᮤঠ ᠬ ᥡ
Error-54    bad declarator
            訡  
Error-55    missing ) in function declaration
            ⢨ ()   㭪樨
Error-56    bad formal parameter list
            訡   㭪樨
Error-57    type should be function
             ⨯ १ 㭪樨
Error-58
Error-59
Error-60    LIMIT: no more memory
Error-61    RESTRICTION: use assignment to initialize
            ४⭮ ᢮ 砫 
Error-62-63 cannot initialize this
            ४⭮ ᢮ 砫 
Error-64    too much initialization data
            ᫨誮  砫 








