    2.1. .

      ணࠬ஢  ⢥ .
ந⢮ ணࠬ ਮ५ ᮢ ࠪ, ⢥
㢥稫  ꥬ  ᫮. ࠡ⪠ ணࠬ -
ᮢ  ॡ  ⥫  ᨫ   ⨢
ᯥ樠⮢. ணࠬ ⠫   ⮫쪮 ᫨⥫묨
 砫 믮 訥 㭪樨  ࠢ  ࠡ⪥
ଠ樨  ࠧ .
    ⨥  ਬ 孮 ஥஢ ᮢ
ணࠬ ਢ  室 ७  ࠢ  -
䥪⨢  ० ᥣ  ⥯ ﭨ  ⢮ ண-
ࠬ த.
    ᯥ祭  ᮪ ⢠ ᫮ ᮢ ணࠬ
易  ⥫묨 ⠬ 㤠 ࠧࠡ稪. -
  ᮧ ணࠬ    㢥稢  ⠭
ॡ, 祬   ᫮  ᮢ 쬠 ᫮ -
  ᮪ ⢠  㭪樮஢,  ᫥ ᯥ祭
饩 ࠡᯮᮡ    㤠  -
祭  室 ⥫  ⢠.  ⮬ 㦥 ᥣ
ॡ  ⮤  ।⢠,    ⭮ -
  ⢮ ணࠬ  ணࠬ  ⭮⥫쭮 ᮪
 㤠.

    2.2. ᭮ 롮 孮 ஢.

     ⭮,   ᮧ ⨯筮 ணࠬ ஥
 50%  饣 ६   50% 饩 ⮨ 室-
   ஢ (஢) ࠧࠡ뢠 ணࠬ 
⥬. ஬ ⮣,  ⮨ ஢  饩 ⮨-
 ணࠬ  ⥭   㢥祭 ᫮-
 ᮢ ணࠬ  襭 ॡ    -
.
    뢠 ,   ࠡ⪥ 孮 ஢ ண-
ࠬ ᫥ ⪮ 뤥  ।  (   
祭 讥)  ᫮ ࠢ  ⫠,  ᯥ稢 ᮪
⢮ ணࠬ த  ᭨    ᮧ-
.
    ஢  -   ᯮ ணࠬ    楫
㦥  訡.   ᯮᮡ  祭 ⠢
  ᫥ ⥣ ஢, 뢠-
  ⥣ ୮ 騪, ஢  ࠢ  
,   ஢  ࠢ  室-室.  
ᯮ짮  ⮩  ⥣  ணࠬ  ᬠਢ 
 騪. ⮢  ᯮ ⮫쪮   ᮮ⢥-
    ᯥ䨪樥  ணࠬ (..      
७ ).
     ⠪ 室 㦥   訡  ணࠬ -
 ਥ 뢠饣 室 ஢. ᫥-
   ⨣,  ᫨   ⢥  ⮢ ஢
ᯮ짮    室 . ⥫-
,  室   뢮,   뢠饣 ஢
ணࠬ ॡ ᪮筮 ᫮ ⮢,   -
 뢠饣 室  .  ⢥ত-
  㬥⠬: -,  ᮧ , ࠭-
騩 ⢨  訡; -, ࠧࠡ⪠ ⠪  -
⮢ ⨢ ᪨ ॡ. ᪮ -
饥 ஢ ᪫砥, 襩 楫   -
ᨬ १⨢  ⠫   -
஢ (ᨬ  ᫠ 訡, 㦨  -
⮬).   ⮣ 室 ᬠਢ ७ 
ணࠬ    ࠧ㬭, , 筮,  -
騥  ࠭⨥ ⮢୮ ।.
    ⥣  騪,  ⥣ ஢, ࠢ-
塞   ணࠬ,   ᫥  ७
 ணࠬ.  ⮬ 砥 騩 砥 -
  ⥬   ணࠬ.
    ࠢ ᯮᮡ  ஥  ⮢    ⥣ 
뢠騬 室  ஢ ⥣ ୮  騪.
୮ ।,    筮 ந  ⠪ 
⮢,   ஬     ᯮ    
ࠧ. 뢠饬 室 ஢   ⠢-
  ᮮ⢥⢨ 뢠饥 ஢ ⮢. -
㬥,  ணࠬ  ஢७ , ᫨  
⮢ 㤠  ⢨  믮 ⮩ ணࠬ  ᥬ
 ⠬  ⮪ () । ࠢ.
    ᫥ ⢥ত   ᫠  㭪: -,
᫮      㣠 ⮢ - ஭᪮;
-,  ᫨      ஢७, ᠬ
ணࠬ  ᮤঠ 訡 (ਬ,  
ய饭).
     १       砭  ⬥-
,   뢠饥 室 ஢  뢠-
饥 ஢ ⮢    묨 ⥣-
, ⮬     ॠ㥬.  ⮬ ॠ ⥬,
   ᮧ  ,  , 筮  ᮫
⥣,  ⠭  ஢ ணࠬ ᪮-
 ⮤.

    2.3. ࠡ⪠ 孮᪮  ஢.

    ᫨ ⪠  ஢  ⥩,   -
,  ਥ   믮   -
 ணࠬ  ࠩ   ࠧ.
      ⢥  ਬ  ஢  쬥   Param.
।祭   - ࠧ  ப  ࠬ-
ࠬ  ⤥ ࠬ.
    ꥪ⮬  ஢  ६  ࠢ  ParamStr ꥪ
Parameters.

    function Parameters.ParamStr(ParamNum : byte) : string;
    begin
      if ParamNum = 0 then
        if Delux then
          ParamStr:=''
        else
          if Lo(DosVersion) >= 3 then
             ParamStr:=system.ParamStr(0)
          else
             ParamStr:=''
      else
        ParamStr:=OptionStr(ParamNum);
    end;

    奬 ⬠ ⮩ 㭪樨:

                   Ŀ
                         砫       
                   
                             
                            / \
                          /     \ 
                        /ParamNum \ Ŀ
                        \   = 0   /                 
                          \     /         Ŀ
                            \ /             ParamStr =     
                                         OptionStr(ParamNum)
                            / \           
                        /     \                   
           </  Delux  \                 
                       \  = true /                 
 Ŀ      \     /                   
   ParamStr = ''          \ /                  
                                
                           / \                     
                         / Lo( \                
                       /DosVersion Ŀ Ŀ
                       \ ) >= 3  /                         
                         \     /                           
                           \ /                           
                 Ŀ Ŀ 
                   ParamStr = System.   ParamStr = ''   
                     ParamStr(0)       
                                     
           ><<
                   Ŀ
                                 
                   

                           2.1.

                                                      . 2.1.
ͻ
 N  室     १ⳏ祭 १
Ķ
 1  ParamNum = 1      ParamStr =         ParamStr =         
                     OptionStr(ParamNum)OptionStr(ParamNum) 
Ķ
 2  ParamNum = 0      ParamStr = ''      ParamStr = ''      
    Delux = true                                            
Ķ
 3  ParamNum = 0     ParamStr =         ParamStr =          
    Delux = false     System.ParamStr(0) System.ParamStr(0) 
    Lo(DosVersion)=3                                        
Ķ
 4  ParamNum = 0     ParamStr = ''      ParamStr = ''       
    Delux = false                                           
    Lo(DosVersion)=2                                        
ͼ

      ਩ ஢ 㦥,  祬   
. ਬ, ᫨ ᫮ Lo(DosVersion)  >= 3 㤥 -
筮 ᠭ Lo(DosVersion) > 3.   ஢  -
   訡  㤥 㦥.
     ᨫ ਩    ணࠬ ⥭
 ⨥ 襭,   ⨥ 室. ᭮ -
    ᠭ 筮 ᫮ ⮢, -
,    襭    ਬ 祭 ⨭
   ࠩ   ࠧ.
     ,   ⨥ 襭 筮 㤮⢮
   ஢. ᪮   
 ஬  ,  室饬    室,  
窨 室 ணࠬ,  믮  ࠢ  -
室        믮. ⥫쭮,
 ਢ  室   ⮣ .
       ᪫祭, ਬ,   case. 
⮬    㧭 襭.

    CASE ᫮ OF
      m1 : 1;
      m2 : 2;
      m3 : 3
    ELSE
      m4 : 4
    END

    ਥ  ⠪  砥   믮  
 १  襭  ࠩ   ࠧ.
    訬 ਥ  ࠢ  ।騬  -
⨥ ᫮.   ⮬ 砥 뢠 ᫮ ⮢, -
   ⮣, ⮡    १  ᫮
 襭 믮﫨  ࠩ   ࠧ.

    ᬮਬ ਬ  㭪樨 OptionStr.

    function Parameters.OptionStr(ParamNum : byte) : string;
    var
      I, Len : Byte;
    begin
      Len := 0;
      I := OptPosition(ParamNum);
      if I <> 0 then
        while (I <= SLen) and not (ParStr[I] in OptDelim) do
        begin
          Inc(Len);
          OptionStr[Len] := ParStr[I];
          Inc(I);
        end;
      OptionStr[0] := Char(Len);
    end;

     ⮩ 㭪樨:

                   Ŀ
                         砫       
                   
                   Ŀ
                    Len = 0;          
                    I = OptPosition(  
                      ParamNum)       
                   
                            / \
                          /     \  
                        /  I = 0  \ Ŀ
                        \         /                 
                          \     /                   
                            \ /                  
             Ĵ                      
                           / \                     
                         /     \                   
                       /I <= SLen\               
                     /          \ >
                     \ParStr(I)   /               
                       \OptDelim /                 
                         \     /                   
                           \ /                  
                  Ŀ            
                   Len = Len + 1;                
                   OptionStr(Len) =              
                    ParStr(I)                    
                              
                                   
                             
                   Ŀ
                                 
                   

                         2.2.

    㭪 ᮤন  ᫮:

         I=0, I<=SLen, not (ParStr[i] in OptDelim).

    ⥫쭮, ॡ 筮  ᫮ ⮢, ⠪,
⮡ ॠ 樨,   I=0, I<>0   ࢮ ᫮ 
I<=SLen,  I>SLen,  (ParStr[i] in OptDelim)=true, (ParStr[i] in
OptDelim)=false  ஬ ᫮.

    , 㤮⢮騥    ᫮ 
 ⠡ 2.2. (  ⮪  ࠬ஢   :  MAIN.GRM
/Q/P, SLen=13, ParamNum=1):

                                                     . 2.2.
ͻ
 N  室     १ⳏ祭 १
Ķ
 1  I = 0             OptionStr(0) = 0   OptionStr(0) = 0   
                                                            
Ķ
 2  I = 1             OptionStr(0) = 0   OptionStr(0) = 0   
    (ParStr[i] in                                           
     OptDelim) = true                                       
Ķ
 3  I = 1             OptionStr(0) = 8   OptionStr(0) = 8   
    (ParStr[i] in                                           
     OptDelim)=false                                        
Ķ
 4  I = 11            OptionStr(0) = 0   OptionStr(0) = 0   
    (ParStr[i] in                                           
     OptDelim) = true                                       
Ķ
 5  I = 11            OptionStr(0) = 0   OptionStr(0) = 0   
    (ParStr[i] in                                           
     OptDelim)=false                                        
ͼ

      ਬ      ᫮     
 㤮⢮    襭,   ᥣ
⠪. ᫨  襭

   if  A and B then ...

     ਨ  ᫮ ॡ    :
A = true,  B = false   A  = false, B = true.   ⮬ 砥
 믮﫮  then-।  if.
         ਩,   ⨥ -
/᫮.    ॡ  ⠪  筮  ⮢,
⮡    १   ᫮  襭 -
﫨  ࠩ   ࠧ,  १  -
襭 믮﫨  ࠩ   ࠧ   窥 -
 । ࠢ  ࠩ   ࠧ.
    ⪮   襭/᫮  -
   ਬ   믮    १⮢
 ᫮;    믮    ᫥-
 ⮣,  । ᫮   㣨  ᫮ﬨ.
ਬ, ᫨ ᫮ AND   ,    ᫥-
 ᫮   ࠦ   㤥 믮. 筮, ᫨
᫮ OR  ⨭,     ᫥  ᫮ 
㤥 믮. ⥫쭮,  ਨ    ᫮ 
 襭/᫮ 筮  ⢨⥫  訡
 ᪨ ࠦ.
    ਥ,   蠥     㣨 ஡-
,  ୮ ⨥ ᫮.  ॡ ᮧ-
 ⠪ ᫠ ⮢, ⮡    樨 १-
⮢  ᫮     襭   窨 室 믮-
  ࠩ   ࠧ.

    ᬮਬ ࠢ CheckTreeNil   㫥 TmObejct ꥪ
Main.

    procedure Main.CheckTreeNil;
    var
      tn : boolean;
    begin
      tn := (GetPtrOfClass(SCl)=nil) and
             (GetPtrOfClass(UCl)=nil) and
             (GetPtrOfClass(ACl)=nil);
      if tn then Error('    ନ');
    end;

     楤:

                   Ŀ
                          砫      
                   
                             
                             /\
                           /    \
                         /        \
                       / G(SCl)=nil \
                     /               \  
                   /     G(UCl)=nil     \Ŀ
                    \                /             
                      \  G(ACl)=nil /               
                        \         /                 
                          \     /                   
                            \ /                   
                                                   
         Ŀ   
          Error('    ନ')   
            
                             <
                   Ŀ
                                 
                   

                           2.3.

      ⮣,  ⮡  ஢  楤 室
ᥬ ⮢,   뢠 ᥣ  ﬨ.

                                                . 2.3.
ͻ
 N  室                 祭 
                               १   १  
Ķ
    GetPtrOfClass(SCl) =  nil                         
 1  GetPtrOfClass(UCl) =  nil  tn = true   tn = true  
    GetPtrOfClass(ACl) =  nil                         
Ķ
    GetPtrOfClass(SCl) <> nil                         
 2  GetPtrOfClass(UCl) =  nil  tn = false  tn = false 
    GetPtrOfClass(ACl) =  nil                         
Ķ
    GetPtrOfClass(SCl) =  nil                         
 3  GetPtrOfClass(UCl) <> nil  tn = false  tn = false 
    GetPtrOfClass(ACl) =  nil                         
Ķ
    GetPtrOfClass(SCl) <> nil                         
 4  GetPtrOfClass(UCl) <> nil  tn = false  tn = false 
    GetPtrOfClass(ACl) =  nil                         
Ķ
    GetPtrOfClass(SCl) =  nil                         
 5  GetPtrOfClass(UCl) =  nil  tn = false  tn = false 
    GetPtrOfClass(ACl) <> nil                         
Ķ
    GetPtrOfClass(SCl) <> nil                         
 6  GetPtrOfClass(UCl) =  nil  tn = false  tn = false 
    GetPtrOfClass(ACl) <> nil                         
Ķ
    GetPtrOfClass(SCl) =  nil                         
 7  GetPtrOfClass(UCl) <> nil  tn = false  tn = false 
    GetPtrOfClass(ACl) <> nil                         
Ķ
    GetPtrOfClass(SCl) <> nil                         
 8  GetPtrOfClass(UCl) <> nil  tn = false  tn = false 
    GetPtrOfClass(ACl) <> nil                         
ͼ

      砥 横  ᫮ ⮢  㤮⢮७ 
୮   ᫮  筮 , 祬 ᫮ -
⥩.
      ,   ⮢, 㤮⢮騩  
୮  ᫮, 㤮⢮ ⠪   -
  襭,  ᫮   襭/-
.
     ࠧ,   ணࠬ, ᮤঠ ⮫쪮  ᫮-
    襭,     ਩, 
⮢ ண:
    - 뢠 믮  १⮢   襭 
ࠩ   ࠧ;
    - । ࠢ  窥 室 (ਬ, -
 CASE).
      ணࠬ, ᮤঠ 襭,    
   ᫮,   ਩ ⮨  
⮢, 뢠   権 १⮢ ᫮-
   襭  । ࠢ  窥 -
 ணࠬ  ࠩ   ࠧ.
      ᢥ ᥣ  襨,  ࠧ 
롮 쭮 ,   ஬ 室 -
 ணࠬ (. . 2.4.).

                           Ŀ
                                  砫      
                           
   >
                          Ŀ
                              
                           ᫮ 室
                          
                                    /\
                                  /    \
                                /        \  
                              / \ Ŀ
                              \     IF     /          
                                \        /            
                                  \    /              
                                    \/              
                                                     
                                    /\                
                                  /    \              
                              /᫮ \         
                    /  ᮤন  \>
                             \ /          
                               \ -/            
                                 \    /              
                                   \/                
    Ŀ Ŀ
      ⮢, 뢠騩      ⮢, 뢠騩    
      樨 १-   믮  १⮢ 
     ᫮   襭       襭      
       ࠧ.               ࠧ.                
     
                    ><
                                    /\
                                  / \
                             /᫥.\
   /    \
                               \ ᫮  /
                                 \室/
                                   \    /
                                     \/
                            Ŀ
                                          
                            

                                   2.4.
