















	 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
	    ᫨誮  砫 

