2003/12/8, 2004/4, 5/22, 6/12, 8/19
ɣɡɽγ
(##24)2004/ 5-6
(##23)2004/ 4
(##22)2003/ 7
(##21)2003/ 6
(##14)2002/ 6
(##11)2002/ 1
(##10)2001/ 11~12
(##9) 2001/  10


ʣ˸ݲ
ɽ HIR (High level Intermediate Representation) ϡC
C++JavaFortranPascalʤɡԤμ³ˤƤ
ɽݲΤǤ롣³ˤƼγǰ¿ˤ錄
뤬ɽˤĤƸȡѼʸȿʸʤɡ̤복
ǰ롣ɽ֤ϸˤäưۤʤ뤬ʬ򤷤Ƥ椯ȵ
̿ˤʤꡢ¸Ϥʤʤ롣ޤʬ򤹤ΤǤʤ³
ŪǰΥ٥ޤǤαʤСץߥ󥰸γ
ǰȣУ˶ᤤбطꡢ¸ΤʤɽȤݲ
뤳ȤǤ롣ơĤκ٤㳰ȡΤ褦
ѴԤʤȤǤ(##10)
ϸ졡ͭνǰ
á¸¸

ඦɽŪǰ
á졦¸

ඦɽ׻ݲ
á¸ˤʬŪ¸

졡̿
¸¸
ץߥ󥰸ˤϡFortranΤ褦˳ؤʤ줫顢
֥ȻظʤɤγǰˤäƴĤγؤĸޤǡ͡
η֤ꡢΤ򸫤ȶ̲Ϥऺ褦˻פ롣
ƤɽȤ˹ʤäƸȡΤ褦ˡ̤Ūǰ
Ƥ롣
ץϡ̤ˡĤץ(subprogram)ʤꡢ
ΣĤץȤƺǽ˵ư졢ץब
ӽФ롣Ĥץबưȡμ¹ʸ
(executable statement)¹Ԥ롣¹ʸˤʸ(assign statement)
ʸ(if statement, selection statement)ȿʸ(loop statement)
ƤӽФʸ(call statement)ʸ(return statement)ʤɤꡢ
μ¹Բǡ黻ΤλѼ(arithmetic expression)ʤɤɾ
롣ʸȿʸǤϡȽԤʤӼ(comparison
expression)(logical expression)ɾ롣Ѽϲø
ʤɤα黻(operation)ɽӼ羮ӤӤʤɤɽ
(logical or, bitwise or)(logical and, bitwise
and)(negation)ʤɤɽ
黻оݤѿ(variable)(constant)ʤӤ˼(expression)ʤ
Ǥ롣ѿˤϡñΥǡɽѿ䡢ʣ礵줿ǡɽ
ΡaggregateˤȤƤ(array, vector)¤(structure)
ɤ롣ѿȤˡȤƤϡñѿ̾(simple variable name)
(array element)¤(structure element)(union
element)ݥ󥿻(pointed element, pointed location)ʤɤ롣
ΥǡǤɽϡǤη(type)ɽ롣
ɽϸ䵡˰¸뤬ѥβ򸫤ȡǽθ
ϤλȺǸΥǤϥǡǤζɽ˿¸
׵ᤵ뤬ʳǤϡ¿νϱ黻оݤζɽ˰¸
Ǽ¹ԲǽǤꡢäޤޤɽǽǽʤΤ¿

Τ褦ʹͤ˴ŤơඦɽζλͤƤ椯
ϣĤꤹ뤳Ȥ롣ζɽϥƥȤ
뤤ڹ¤(tree structure)ηȤ(##14)ڹ¤ȤƸ硢
HIRϡnonleafˤɽΡ(node)
ʱ黻ҡ°ڥɣڥɣġ
աleafˤɽΡ
<̡>
ʤӤ˶nullܹǤȤ롣ƥɽϡڹ¤ȣ
б嵭Τ褦ˡ
ʱ黻ҡ°ڥɣڥɣġ
դ
<̡>
ȵҤ(##14)ڤλޤι⤵ʿˤϳ̤ҤοǼ롣
ڹ¤б䤹뤿ᡢҤο򥤥ǥơο
Ȥ⤢롣ǡڥɣڥɣĤڤޤ
Ǥꡢդϵɽ줿ޤnullɽ黻ɽʤɤϡ
Τ褦ʬڤȤɽ롣°ϸǽҤ٤뷿ʤɤξɽ
ǡ¿ϵɽ(symbol table)˵ܤƤꡢHIRɽȤƤϡ
ɽεܹʥȥˤ򼨤ˤȤɤΤ¿äơܺ
ʵҤȤƤϵɽȹ碌ƸʤФʤʤ绨Ĥ˸ȡ¹
ʸˤ黻Ƥȥץ๽¤HIRȤɽʸ
ˤ뵭ι¤°(attribute)ϵɽɽΤǤ롣(##10)
ץɽᡡɽܡɽ
ơɽоݤ
¤ߴϢ°
ɽϡ
SymTable
 ʵ̡̾°°ġ
 ʵ̡̾°°ġ
ġ
ɽ졢°
°̾󣱡󣲡ġ
ɽ(##10)ǥХåϤǤϡԤ䵭Ұ֤˰̣
뤳Ȥˤꡢ̤°̾άάɽȤ(##14)
ɽκ仲Ȥϡ٤ HIR Ф륢᥽åɤ
𤷤ƹԤʤɽκ仲ȤϤ٤ƵɽΥ᥽åɤ
ƹԤʤ
ϥץHIRѴȤϸ˸ͭɽޤ
ɽͳƤ顢ϸ˰¸ʤHIRѴ뤳Ȥ롣
ȤC줫HIRѴȤϡCͭɽޤHIR-C
ȤɽͳƤ鶦̤HIRɽѴ롣HIRȸ
ϸͭɽޤޤʤ̤ɽΤȤɽΤȤ̤
ɬפȤϡHIR-baseȸHIR-Cʤɤȶ̤롣
ʤ굡ˤĤơ򼨤ꤷϡ
ʬ[[ ]] ǰϤǼ(##10)
ʣ˸ݲΥ٥롡(##10)
ݲˤϡʸΤߤꤷƤΰ̣ϸ줴Ȥ
䡢˶ᤤ٥ˤޤʬ򤷤ựդޤǤäԤ
Ԥʤɡˡ롣HIRǤϡ󲽤η̤ϸƱ
ǽϤʤɤλȤˤʤ褦ˡޤʬ򤷤ʤ٥
ˤȤɤ롣ޤեϤŬѴѴʤɤνǤ
¤䵡ˤʤǶ̲Ǥ褦ˤ뤳Ȥտޤ롣
ˡΤ褦ʲϤѴǽȤ뤿ΰ̣դ¹Խε
ळȤˤ롣٤ʥ٥ޤǲǽˤ
ȤLIR˾ꡢʤ¿ν̲ǤФ褷Ȥ롣HIRˤ
ݲϤΤ褦ʹͤ˴ŤƹԤʤäƤ롣
ʣ˷Ȥбդ
HIRγƥΡɤˤϡ줬(value)ĤΤǤФηյ
롣äơѿ黻ʤɤɽΡɤˤϡ٤Ƥη
յ롣ͤʤΡɤˤϷvoidյ(##9)ͤǼ
򥪥֥Ȥȸ֥Ȥɽ͡l-value
ȸηȤϤμɾ̤ηǤ롣ɽˤĤƤ̤
Ϥ򻲾Ȥ줿ʬڤηϤʬ(subtree)κ(root)°Ȥ
ɽ롣
[[
Cɽ
   int i;
   float x, y[10];
   ...
   x = y[i] + 1.0;
ˤơʸHIRϼΤ褦ɽ蘆롣ȤǽҤ٤褦ˡ
<VECT n lb xxx>xxxǤηȤ٥ˤ̣롣n
ǤοlbźβͤǤ롣(##14)
   (assign float
    <var float x>
    (conv float
     (add double
      (conv double
       (subs float
        <var <VECT 10 0 float> y>
        <var i int> ) ) (##14)
      <const double 1.0> ) ) )
]]
Ρɤˤannotation, infˤΥե饰°Ȥդ뤳
ȤǤ롣ե饰ΣĤˡμǤ뤫ݤɽ롣
ʣղþ(##14)
HIRγƥΡɤˤϡΤۤˡɬפ˱ղþĤ뤳Ȥ
롣ĤˡȤơ
     InfNode
դȡƤϼͳ뤳ȤǤΤǡǤդξ
뤳ȤǤgetInfNode(), attachInf()ˡΥΡɤˤĤ
ΤǤϤʤɬפʤΤФƤΤդ뤳ȤǤ롣Ŭ󲽤
ɤŪ˱ƤƤФ褤
ʸΥΡɡStmtˤˤϡϥץˤƤʸƬޤե
̾ȹֹϿ뤳ȤǤgetFileName(), getLineNumber()ˡ
⤦ĤˡȤơtrue, falseɽ魯ե饰򤤤ĤǤդΥΡ
ɤդ᥽åɤѰդƤgetFlag(), setFlag()ˡե饰μ
HIR󥿥ե롣
ʣ˱黻ȷ
黻ν(order)ϡ§Ȥơڹ¤򿼤ͥǺ鱦ء裱
ҡ裲ҡġˤȤ֤Ǥɤν˽ȤǸɽι
ǽҤ٤褦ˡĤ㳰롣HIRڹ¤ۤȤ
ʸˡǵꤵ줿ɾHIRιʸ§Ĥ碌ơɤΥ
ɤɤλޤˤĤ뤫롣ɾϸʸˡǷ
ʤʬФƤϡϰ¸Ǥꡢѥ鳫ȯԤȽǤˤ
ڹ¤ȤΩƤ롣νϷ褷ѹƤϤʤȤȤ
̣ΤǤϤʤƱ黻̤ݾڤǤ䡢ͤǵ
ϰǤϡѥѹƤ褤(##22)
黻η˴ؤƤϡ
a + (b - c)

(a + b) - c
ϿŪˤͭ¤ηǷ׻륳ԥ塼Ǥϰۤʤ̤
뤳Ȥ⤢롣Τ褦򤱤뤿ᡢץǻꤵ
줿̤ºŤơ̾ϳΤΤȳ̳ΤΤ礹뤳ȤϤ
ʤѥˤäƤϡ̤ˤȤ줺˷ѹŬ
ѴǽʤΤ⤢뤬Τ褦ʥѥǤ⡢̵̤뤹
ȷ̤礭ʱƶڤ־ϳ̤ºŤ뤳Ȥ׵ᤵ롣
ǽˤ뤿ᡢʬڤencloseȤ黻Ҥ򤫤֤ȡ
ʬڤ˴ؤƤϡѹȼŬѴϹԤʤʤȤ
롣(##23)
ŬԤʤȱ黻νѤäꡢα黻줿ꤹ롣
ʬФƤϤΤ褦ѴԤʤäƤۤʤ⤢롣HIR
ФѴ¤ݤˡȤơϰϤˤʬڤκФơ
     setFlag(HIR.FLAG_NO_CHANGE, true)
Ƥ֤ȡʬΤФƺŬѴ򤷤Ȥˤ
롣encloseϷѤʤŬѴΤФơ
FLAG_NO_CHANGEϤʬڤФ뤹٤ƤκŬѴػߤ뤳Ȥ
ɽ(##23)
ʣHIRΥ᥽åɡ(##11)
HIRˤɤʥ᥽åɤꡢɤΤ褦ʻͤˤʤäƤ뤫ϡܻͽ
ǤϵҤƤʤˤĤƤϥ󥿥եIR.javaHIR.java
򻲾Ȥ줿HIRΥ󥹥󥹤᥽åɤHIR󥿥ե
ѰդƤꡢnewǺɬפϤʤ˴ؤ᥽åɤˤĤƤϥ
󥿥եSym.java򻲾Ȥ줿Υ󥹥󥹤᥽å
Sym.javaѰդƤꡢnewǺɬפϤʤ
󥹥󥹤newǺ뤳ȤػߤƤ櫓ǤϤʤHIR䵭
Υ󥹥󥹤newľܤ˺ȤϡΤ«ʬ򤷤
ʤȡߴϢԶ礬뤪줬롣󥹥󥹤
newľܤ˻Ȥʤ⤦Ĥͳϡϸʤоݵˤѹ
뤤ϵǽĥˤȤʤäƥ֥饹ߤȡ֥饹Υ
󥹤뤳ȤɬפˤʤꡢnewľܻȤäƤȤѹս꤬
ʬ¿ˤʤäƤޤ嵭Τ褦ˤȡѹս
HIR.java, Sym.javaμ¸ˤȤɤޤꡢνǤिǤ
(##14)
HIR.javaSym.javaˤϡHIRSym°䲼Ǥ򻲾Ȥʤ
᥽åɤ⤢롣˽񤫤줿᥽åɤǤϤǤʤˤĤ
ϡHIRSymβ̤Υ󥿥ե򻲾Ȥ줿̤Υ󥿥ե
˸ȡ̤Υ󥿥եǤǤѰդƤʬ
ʼӤʤǡ˺äꤹ뤳Ȥˤʤ롣ʲ̥󥿥ե
ȤƤ

   HIR
     Stmt.javaʸ
       AssignStmt.javaʸ
       LoopStmt.java롼ʸ
     Exp.java
     SymNode.javaΡ
       VarNode.javaѿΡ
   Sym
     Type.java
     Subp.javaץ
     Var.javaѿ
     Const.java

ʤɤ롣᥽åɤμ¸ƤĴ٤ˤϲ̤Υ饹鸫Τ褤
ȤĴ٤ˤϾ̤Υ󥿥ե鸫褦ˤʤȡ
Ȥְ㤦줬¿ʬˤ롣
ʣHIRѴ(##24)
ѥǤϡŬ󲽤ʤɤΤHIRѴ롣
ˤ
     copyWithOperands, replaceThisNode, deleteThisStmt
ʤɤդ᥽åɤȤѴˤäƣĤΥΡɤʣοƤ
󥯤ڹ¤ǤʤʤΤǡΤ褦ʸäѴ򤵤뤿ˤϡ
ޤĤΤǤϤʤʬŪԡʤɤˤäƿʬڤꡢ
Ƥ³褦ˤΤ褤
ޤѴˤäơ롼פifʤɤ湽¤HIRΰ̣
ʤΤȤʤʤ褦ˤʤФʤʤ롼פФƤϤμ¹
ǥ˹äѴǤʤФʤʤifФƤifμ¹ԥǥ
äѴǤʤФʤʤȤС롼פμ¹ԥǥƤʤ
ǥ롼׳롼ӹꡢ롼ץƥåӽФ
ꤹ뤳ȡifμ¹ԥǥ˹ʤifthenelseӹ
ळȤʤɤ򤱤ʤФʤʤΤ褦ѴԤäϡʸ
þ褹礬롣
ʣHIRΡɤֹդ(##23)
ŬɽɽκݡΡɤγơֹ椬ĤƤ
Ȥ¿ΤᡢHIRȤˡĤΥѥñ̡
뤤ϣĤץФơΡʬڤγƥΡɤ˰Ϣֹ
Ϳ롣ŬʤɤΤHIRѴϡĤץ
ѴλǡץʬڤФưϢֹͿ
ʤֹդsetIndexNumberToAllNodeȤ᥽åɤʬڤ
ѤȤǤ롣

HIRΥ饹

JavaΤ褦ʥ֥Ȼظ򥳥ѥ鵭ҸȤ֤ȡ
򥯥饹ȤƤȤ館뤫פ߷׹ܤȤʤ롣ɽǤϡ
ץʸʤɤΥץߥ󥰸γǰб饹
ߤ뤳Ȥ򣱤ĤδˤȤƤ롣Ǹʸ估ϡɬ
θ¤ɽǤϤʤ˽Ҥ٤褦ˡŪ
Ūǰʬ򤷤ƹʤŪˤ복ǰɽΤǤ뤬
ϸθȤۤбդǤΤǤ롣ڹ¤δܹǤ
ϡҶΥΡɤȤƤnonleafΡɤȡҶʤդȤ
ƤleafΡɤꡢιʸBNFɽȡnonleafnonterminal
ˡleafterminalб롣
HIRζŪ饹ؤ򼡤˼ǤϤ̾
interfaceȤƤ̾Ǥꡢ¸륯饹̾Ϥ̾
ImplĤΤˤʤäƤ(##10)// Ϥλ͵Ҥˤ
λϤޤ򼨤
  IR
   |- IR_factory    // IR object creation factory.
   |- IrList        // List of indefinite number of objects.
   |   |- HirList   // IrList whose elements are HIR objects. //##12
   |
   |- LIR           // Low level Intermediate Representation
   |   |- ...
   |
   |- HIR // High level Intermediate Representation.
       |  // Usual operations on HIR are done by using HIR methods.
       |
       |- Program         // Program definition node.
       |- SubpDefinition  // Subprogram definition node.
       |- HirSeq          // Sequence of definite number of
       |                  // HIR objects.
       |- HirList         // IrList whose elements are HIR objects.
       |                  // (Multi-inheritance of interface) //##14
       |- Stmt            // Statement
       |   |- LabeledStmt // Labeled statement.
       |   |- AssignStmt  // Assignment statement.
       |   |- IfStmt      // If-statement.
       |   |- JumpStmt    // Jump (goto) statement.
       |   |              //  (Jump unconditionally)
       |   |- LoopStmt    // Loop statement.
       |   |   |- ForLoop     // For-loop.
       |   |   |- WhileLoop   // While-loop.
       |   |   |- RepeatLoop  // Repeat-while-true loop.
       |   |   |- IndexedLoop // Loop with index range
       |   |                  // (such as Fortran DO loop).
       |   |- ReturnStmt   // Return statement.
       |   |- SwitchStmt   // Switch (case) statement.
       |   |- BlockStmt    // Block representing a sequence
       |   |               //   of statements.
       |   |- ExpStmt      // Expression treated as a statement.
       |   |               // Call statement is treated as an
       |   |               // expression statement of function call.
       |   |               // Loop start condition expression has
       |   |               // label and treated as ExpStmt.
       |   |- InfStmt      // An information node
       |   |               // which can be treated as a statement.
       |   |               //  (pragma, comment line, etc.)
       |   |- SetDataStmt  // Statement to specify initial data which
       |                   // may be set before starting execution.
       |                   //    //##24
       |- LabelDef         // Label definition node.
   //  |- InfNode          // IR information node.  //##17 DELETED.
       |                   //  Use InfStmt.
   //  |                   //  (pragma, comment line, etc.)
       |- Exp  // Expression
           |- ConstNode // Constant node
           |- SymNode   // Symbol node
           |   |- VarNode   // Variable name node.
   //      |   |   |- ParamNode // formal parameter name node
   //      |   |   |            //##16 DELETED
           |   |   |- ElemNode  // struct/union element name node
           |   |                //##16 not DELETED
           |   |- SubpNode  // Subprogram name node.
           |   |- LabelNode // Label reference node.
           |   |- TypeNode  // Type name node.
           |
           |- SubscriptedExp // Subscripted variable.
           |- PointedExp     // Pointed object.
           |- QualifiedExp   // Qualified variable.
           |- FunctionExp    // Function call expression.
           |- PhiExp         // Phi function used in SSA
           |- ExpListExp // Expression representing a list of
           |             //  expressions. //##24
           |- NullNode   // Null (no-operation) node

ඦɽιʸ

ԤǤϡHIRιʸˤĤ롣HIRΰ̣ˤĤƤ
ɽηỌ̇̄
λͽ򻲾Ȥ줿(##14)
ʣHIRڹ¤ɽ
HIRǤϡĤΥѥñΤ򣱤Ĥڹ¤ɽϡ
ˡɽʬڤȡץɽĤʬڤʤ롣
ץɽʬڤϡˤɽʬڤȼ¹ʸ
估ɽʬڤʤ롣¹ʸȤƤϡʸʸȿʸ
ƤӽФʤɤꡢˤϻѼӼʤɤ롣
ʬڤϱ黻ҡʥڥ졼ˤɽդѿ̾ؿ̾ʤɡ
ɽ˵ܤ줿ɽǤ˽Ҥ٤褦ˡڹ¤ˤϤȣ
Убƥɽ(##14)
¹Բǽڹ¤μ¹ԡɾ˽ˤĤƤϡơι롣
ΤʤǤϡ§Ȥơڹ¤裱ʬڡʺʬڡˤˡ
ͥǤɤäνƱǤ(##10)ʬڤ򤿤ɤˤϡ̾
ѤΥƥ졼Ȥ(##9)
HIRեؤΥ󥯤ϡ٥Ρɤ𤷤Ƥʤ롣
ϥץˤ٥դʸϿܥ֥åƬʸȤ
ϥץǥ٥뤬ƤʤƤ⡢ܥ֥åƬ
ˤʤΡɤФƤϡѥ٥Ρɤ
롣Τ褦ˤơδܥ֥å˥٥Ρɤб
եؤΥ󥯤ĥ롣٥Ρɤʤɤ򸫤
ʤϡΤȤˤ򥹥åפ뵡ǽäƥ졼Υ᥽
åɤȤФ褤
ʣHIRΥƥɽ
ڹ¤ΥΡɤˤϡ줬ΥΡɤǤ뤫ɽɤĤƤꡢ
ɽ°ĤƤ롣¾°ĤȤ⤢롣Υɤ
˽Ҥ٤黻Ҥ򥳡ɲΤǤ롣HIRɽȤƤϡιʸ
ɽȡHIRɽ줿ŪʬڡHIRΥ󥹥󥹡ˤɽ
礬롣ʲιʸҤˤƤϡΡɤΥɤxxxCodeηɽ
󥹥󥹵ҤǤϡʷˤ뤿ᡢxxxCode黻ҤȤΡ
ñxxxɽTypeϤʬڤɽʸʤɤηɽ°Ǥ
ȤʸȤƤϵҤʤ󥹥󥹤ǤϵҤ롣HIRΥ
󥹤ΥƥɽΤȤ򤽤Υ󥹥󥹤ɽȸɽ
ɽȸ(##10)

nonleafΡ
             xxxNode
           /    |  ...  
     child-1  child-2 .. child-n
ιʸϡƥȤȤƤ
     (xxxCode  child-1  child-2 ... child-n)
ɽΥ󥹥󥹤ϡյ
(xxx  Type  child-1  child-2 ... child-n)
ɽleafΡ
             xxx  z
ιʸϡƥȤȤƤ
<xxxCode  z>
ɽΥ󥹥󥹤Ϸյ
<xxx  Type  z>
ɽleafnonleaf̤䤹뤿ᡢnonleafǤϴݳ ( )
ȤleafǤϻѳ < > Ȥ䤹ˤʤϡ
ѳ̤򤹤٤ƴݳ̤֤Ƥ⺹٤ʤ(##11)
Ȥ
             assign
              /   
             x    add
                  /  
                 y    1
ȤϡƥȤȤƤ
       (assign int
         <var int x>
         (add int
           <var int y>
           <const int 1> ) )
Τ褦ɽ
ʣ˵ˡ
ɽڹ¤γƥΡɤϡ裱ҤȤƲȤꡢ裲ҤȤƲ
Ȥ롢 ȤȤΤɽ뤿ˡɽιʸBNFǵ
롣BNFɽˤ뤤Ĥεˡ롣
ʸǻϤޤѿ󡧡ü
ʸǻϤޤѿ󡧡ü

 _ פǽʤü桧
ɽ饹̾ޤϥ󥿥ե̾
 _ פǽü桧
饹̾Ǥ⥤󥿥ե̾Ǥʤüǡ
BNFҤɤߤ䤹뤿Ƴ
IrList of xxx: xxxǤȤIrList(##10)
°ȤƤϡפʤΤΤߤ򼨤@ĤƤΤڹ¤
λޤȤʤΤǤꡢ@ΤĤƤʤΤϻޤȤƤǤϤʤ°Ȥ
ͿƤǤ롣@ϥǡ¤ʤɤȤƼΤ¸ߤʸˡ
ǤϤʤޤʤ뤿ñʤɽεǤ롣
(##11)
  Note:
    Following items are not represented as a subtree
    dangling to a node but are represented as information
    attached to the node. They are not traversed when HIR tree
    is traversed but can be get by applying corresponding HIR
    methods to the node.
        Operation code     (xxxCode)
        Symbol table entry (xxxSym)
        Constant symbol    (xxxConst)
        Symbol table       (SymTable, GlobalSymTable_, LocalSymTable_)
        attr               (attribute such as node type which is
                            a symbol representing the type
                            of the result of HIR subtree.)
    Items represented as a subtree is indicated by @ to clarify.
    (@ is not a syntactic component but a postfix marker
     to decrease misunderstanding.)
BNFɽˤ뽪üˤϡ黻ҤȤʳε椬롣黻
Ұʳνüڹ¤դȤʤΤǤꡢΤΤ롣ǡ
xxxSymϵɽ˵ܤ줿xxxεɽxxxConstϵɽ˵
ܤ줿xxxɽ
    xxxCode: operation code xxx

    xxxSym : symbol recorded in the symbol table
            progSym : program name symbol
            subpSym : subprogram name symbol
            varSym  : variable name symbol
                      (including array/struct/union name symbol)
            paramSym: formal parameter name symbol
            elemSym : struct/union element name symbol
    //      fieldSym: field name symbol of a class
    //      classSym: class name symbol
            labelSym: label name symbol
            typeSym : type name symbol
    xxxConst: constant recorded in the symbol table
            intConst   : integer constant
                         (int/short/long/unsigned int/ ...)
            floatConst : floating constant (float/double/ ...)
            charConst  : character constant (signed/unsigned)
            stringConst: character string constant
            boolConst  : boolean constant
                        (true is 1, false is 0 in integer)
    intConstValue:    integer constant
                      (not a symbol table entry but value itself).
    stringConstValue: string  constant
                      (not a symbol table entry but value itself).
    null       : empty (nothing, epsilon)
    NullNode   : a leaf node with operation code null.
                 (It is not null.)  // (##22)
    List_of_xxx: java.util.List with elements xxxx. (##10)
黻ҤˤĤƤϡûɽaddaddCodeȽ񤯤Ȥ褦ˡxxx
黻ҤϹʸ§ǤxxxCodeȤɽƤʤ⤢
ʤñʤɽζ̤Ǥˡ
ƥΡɤˤĤ뷿ϡHIR˸ͤ˽äƷꤹ롣
ʬڤǤϷvoidȤ롣
˽Ҥ٤ͽǤεҷȥ饹̾󥿥ե̾󥹥
ϻɽȤδϢ㼨롣εμºݤΥǥ
ˤĤƤϡSym.java򻲾Ȥ줿(##11)
󥿥ե̾ɡɽ饹̾(##11)
   Program         progCode      prog      ProgramImpl
   SubpDefinition  pubpDefCode   subpDef   SubpDefinitionImpl
   AssignStmt      assignCode    assign    AssignImpl
   IfStmt          ifCode        if        IfStmtImpl
   VarNode         symCode       var       VarNodeImpl
   LabelNode       symCode       label     LabelNodeImpl
   ConstNode       constCode     const     ConstNodeImpl
   Exp             addCode       add       ExpImpl
   Exp             multCode      mult      ExpImpl
    ...             ...          ...        ...
ʣHIRιʸ
ʲˡɽιʸBNFɽǤϡյƤ
// Ϥλ͵ҤˤλϤޤ򼨤ʸ§ HIR-C
only ȼʬϡHIR-CˤΤߴޤޤɽ򼨤
  Program   ->             // Program represents a compile unit.
     ( progCode attr       //
       GlobalSymTable_     // Global symbols of the program
       ProgSym_ @          // Program name (may be null).
       InitiationPart_ @   // Initial value specification.
       SubpList_ @ )       // Subprogram definition list.
  ProgSym_  ->
     ( symCode attr progSym )   // Program name symbol.
   | null
  GlobalSymTable_  ->   // Global symbol table of the program.
     SymTable           // As for SymTable, see Sym and SymTable.
   | null
  InitiationPart_ ->    // Initial value specification (##14)
     InitiationBlock_
   | NullNode
  InitiationBlock_ ->   // Block containing initiation statements.
     ( blockCode attr
       InitiationStmtSeq_ @ )
  InitiationStmtSeq_ -> // Sequence of initiation statements
     InitiationStmt_ @ InitiationStmtSeq_ @
   | null
  InitiationStmt_ ->    // Initiation statement
     ( setDataCode attr         // with Exp_l_: l-value
        Exp_l_ @ ValueSpec_ @ ) // ValueSpec_: constant Exp.
   | AssignStmt
  ValueSpec_ ->
      ConstNode         // Constant value
   | ( listCode attr    // List of ValueSpec_
       List_of_ValueSpec_ @ )
   | ( repeatCode attr           // Expression to represent repeating
       ValueSpec_ @ intConst @ ) //   ValueSpec_ intConst-times.
  SubpList_ ->
     ( listCode attr     // Subprogram definition list
       List_of_SubpDefinition @ )
  SubpDefinition ->      // Subprogram definition
     ( subpDefCode attr
       LocalSymTable_    // SymTable local in the subprogram.
       SubpNode @        // Subprogram name.
       InitiationPart_ @ // Subprogram initiation.
       SubpBody_ @ )     // HIR subprogram body
                         // (Control flow should be ended by return).
  //   LIR @ )      // LIR representation for the subprogram.  //##24
deleted
  SubpNode  ->      // Subprogram name node.
     ( symCode attr
       subpSym )
  LocalSymTable_ -> // Local symbol table (for subprogram, block, etc.)
     SymTable
   | null
  SubpBody_ ->      // HIR subprogram body is
     BlockStmt                 // block statement or
   | ( labeledStmtCode attr    // BlockStmt with Label.
        LabelDefinitionList_ @ // List of label definitions.
        BlockStmt @ )          // Statement body
  BlockStmt ->
     ( blockCode attr
       LocalSymTable_  // Define symbols local in the block.
       StmtSeq_ @ )    // Block makes a sequence of statements
                       // to be treated as one statement.
            // Statements in StmtSeq_ can be get
            // by getFirstStmt() and successive getNextStmt().
  StmtSeq_  ->
     Stmt @ StmtSeq_ @  // Statement sequence is a statement
   | null              // followed by statements or null.
  Stmt      ->          // Statement is
     LabeledStmt        // a statement with label definitions or
   | StmtBody_          // a statement without label definition.
  LabeledStmt ->        // Statement with label definition.
     ( labeledStmtCode attr
        LabelDefinitionList_ @ // List of label definitions.
        StmtBody_ @ )          // Statement body (statement that is
                               // peeled label off).
  LabelDefinitionList_ ->   // List of LabelDef nodes.
     ( listCode attr
       List_of_LabelDef @ )
  LabelDef   ->             // Label definition node.
     ( labelDefCode attr
       labelSym )
  StmtBody_  ->     // Statement body.
     AssignStmt     // Assignment statement.
   | IfStmt         // If statement.
   | JumpStmt       // Jump (goto) statement.
   | LoopStmt       // Loop statement.
   | CallStmt_      // Subprogram call statement.
   | ReturnStmt     // Return statement.
   | SwitchStmt     // Switch (case selection) statement.
   | BlockStmt      // Block statement.
   | ExpStmt        // Expression treated as a statement.
   | SetDataStmt    // Set initial data statement.

  AssignStmt ->     // Assign statement.
     ( assignCode attr
       Exp_l_ @     // l_value expression
       Exp @ )      // Expression whose value is to be assigned.
   | ( CompoundAssignOperator_ attr  // HIR-C only
       Exp_l_ @
       Exp @ )
   | ( IncrDecrOperator_ attr        // HIR-C only
       Exp_l_ @ )
  Exp_l_  ->              // l-value expression is
     Exp                  // an expression representing an object
                          // (memory area to contain data).
  IfStmt    ->            // If statement
    ( ifCode attr
       ConditionalExp_ @  // Conditional expression.
       ThenPart_ @        // Then-part
       ElsePart_ @        // Else-part.
       LabeledNull_ @ )   // End-of-if label.
  ThenPart  ->
     LabeledStmt   // Executed if ConditionalExp is true.
   | null
  ElsePart  ->
     LabeledStmt   // Executed if ConditionalExp is false.
   | null
  LabeledNull_    ->          // A labeled statement whose statement
     ( labeledStmtCode attr   // body is null at the first HIR
       LabelDefinitionList_ @ // generation but it may become
       StmtBody @ )           // non-null by code optimization, etc.
  JumpStmt  ->
     ( jumpCode attr  // Jump to the statement with
       LabelNode @ )  // specified label.
  LoopStmt ->  // Loop statement is either for-loop, while-loop,
               // repeat-loop, indexed loop, or other general loop.
               // All of them are implemented as a general loop
               // with some restriction depending on the loop type.
               // Compiler components (other than front part) should
               // treat general loop, that is, do not assume some child
               // is null without checking whether the child is null
               // or not.
               // There may be some cases where processing become
               // simple if the loop is either for-loop, repeat-loop,
               // etc.
    ( LoopCode_ attr     // Loop kind code.
      LoopInitPart_ @    // Loop initiation part to be executed
                         // before repetition. This may be null.
                         // LoopInitPart_ should not contain
                         // control statements. //##24
      ConditionalInitPart_ @ // Conditional initiation part.
                             // This is deleted. Give null. //##24
      StartConditionPart_ @  // Loop start conditional expression
                         // with loopBackLabel.
                         // If true, pass through to LoopBody_,
                         // otherwise transfer to LoopEndPart_.
                         // If loop start condition part is null  ,
                         //  pass through to LoopBody_.
      LoopBody_ @        // Loop body repetitively executed.
                         // Pass through to EndCondition_.
                         // It is a block statement (BlockStmt)
                         // with loop start label and the blcok
                         // statement contains a labeled statement
                         // with loopStepLabel as its last statement.
                         // This should not be null but the block may
                         // have no executable statement and contains
                         // only a labeled statement with loopStepLabel.
                         // "continue" jumps to the loopStepLabel.
                         // The loopStepLabel may be omitted if
                         // there is no "jump loopStepLabel".
     EndCondition_ @     // Loop end condition expression.
                         // If true, transfer to LoopEndPart_,
                         // otherwise pass through to
                         // LoopStepPart_.
     LoopStepPart_ @     // Loop step part executed
                         // before jumping to loopBackLabel.
                         // LoopStepPart_ should not contain
                         // control statements. //##24
     LoopEndPart_ @ )    // Loop end part
                         // with loopEndLabel.
                         // "exit" (break in C) jumps to here.
     IndexedLoop_ attr   // Attributes for IndexedLoop. //##21
                         // Not given for other loops.  //##21
  LoopCode_ attr ->
     whileCode attr      // while-loop
   | forCode attr        // for-loop
   | repeatCode attr     // repeat-loop
   | indexedLoopCode attr// indexed-loop //##21
   | loopCode attr       // general loop other than above loops. //##21
  LoopInitPart_   ->  // Loop initiation part.
     Stmt
   | null
  ConditionalInitPart_ ->  // Executed at first time only.
     null                  // This is deleted. Give null. //##24
  StartConditionPart_ ->      // Show start condition with
     ( labeledStmtCode attr   // loopBacklabel.
       LabelDefinitionList_ @
       ExpStmtOrNull_ @ )     // loopStartConditionExpression.
  LoopBody_  ->               // Block statement with loopBodyLabel.
     ( labeledStmtCode attr   // The last statement of the block
       LabelDefinitionList_ @ // is a LabeledNull_ statement with
       BlockStmt_ @ )         // loopStepLabel.
  EndCondition_ ->            // ExpStmt showing loop end condition.
     ExpStmtOrNull_
  LoopStepPart_  ->    // Statement to be executed before jumping
     Stmt              // to loopBackLabel.
   | null
  LoopEndPart_  ->     // LabeledNull_ statement with loopEndLabel.
     LabeledNull_
  NullOrStmt_ ->       // Usually null but it may be
     null              // a statement (created during
   | Stmt              // HIR transformation). //##20
  ExpStmtOrNull_ ->    // Expression statement or null  .
     ExpStmt
   | null             //
  IndexedLoop_ attr  -> // Attributes for IndexedLoop.
     loopIndex attr     // Loop index (induction variable).
                        // See getLoopIndex().
     startValue attr    // Start value of the loop index.
                        // See getStartValue().
     endValue attr      // End value of the loop index.
                        // See getEndValue().
     stepValue attr     // Step value for the loop index.
                        // See getStepValue().

  // Note. LoopInf may contain goto-loop that is difficult or
  //   impossible to be represent by above LoopStmt.
  //   (goto-loop is not implemented by LoopStmt.) //##21
  // LoopStmt is executed as follows:
  //   LoopInitPart_;
  //   if (loopStartConditionExpression != null) {
  //     if (loopStartConditionExpression == true) {
  //       jump to loopBodyLabel;
  //     }else
  //       jump to loopEndLabel;
  //   }else
  //     jump to loopBodyLabel;
  //   loopBackLabel:
  //     if ((loopStartConditionExpression != null)&&
  //         (loopStartConditionExpression == false))
  //       jump to loopEndLabel;
  //   loopBodyLabel:
  //     Start of BlockStmt of LoopBody_
  //       Stastement sequence of the BlockStmt;
  //       loopStepLabel:;
  //     End of BlockStmt of LoopBody_
  //     if ((loopEndConditionExpression != null)&&
  //         (loopEndConditionExpression == false))
  //       jump to loopEndLabel;
  //     LoopStepPart;
  //     jump to loopBackLabel;
  //   loopEndLabel:
  //     Loop end part;

  // BEGIN #21
  // ForStmt is created as a general loop where contents of
  //   ConditionalInitPart_, EndCondition_, LoopEndPart_
  //   are labeled null at first (but their statement body may
  //   become not null by some optimizing transformation).
  //   See isSimpleForLoop().
  // WhileStmt is created as a general loop where contents of
  //   LoopInitPart_, ConditionalInitPart_, EndCondition_,
  //   LoopStepPart_, LoopEndPart_
  //   are labeled null at first (but their statement body may
  //   become not null by some optimizing transformation).
  //   See isSimpleWhileLoop().
  // RepeatStmt is created as a general loop where contents of
  //   LoopInitPart, ConditionalInitPart_, StartCondition_,
  //   LoopStepPart_, LoopEndPart_
  //   are labeled null at first (but their statement body may
  //   become not null by some optimizing transformation).
  //   See isSimpleRepeatLoop().
  // IndexedLoopStmt is created as a general loop where contents of
  //   ConditionalInitPart_, EndCondition_, LoopEndPart_
  //   are labeled null at first (but their statement body may
  //   become not null by some optimizing transformation).
  //   See isSimpleIndexedLoop().
  // IndexedLoopStmt represents a Fortran type loop where
  //   value of loop index is incremented or decremented by loop
  //   step value starting from loop start value and stops
  //   to loop before crossing the barrier of loop end value.
  //   (See IndexedLoopStmt interface.)
  // Indexed loop attributes (IndexedLoopAttr_) are available
  // only for IndexedLoopStmt.
  // END #21

  CallStmt_   ->         // Subprogram call statement.
     ( expStmtCode attr  // Expression statement
       FunctionExp @ )   // with FunctionExp.
  FunctionExp ->         // Subprogram call expression.
     ( callCode attr
       Exp @             // Expression specifying
                         // subprogram to be called.
       HirList_ @ )      // Actual parameter list.  //##24
  ReturnStmt ->          // Return statement.
     ( returnCode attr
       ReturnValue_ @ )  // Return value.
  ReturnValue_ ->
     Exp
   | null
  SwitchStmt ->          // Switch statement.
     ( switchCode attr
       Exp @             // Case selection expression.
       JumpTable_ @      // List of constants and statement labels.
       Stmt @            // Collection of statements to be selected.
       LabeledNull_ @ )  // Indicate end of case statement.
  JumpTable_ ->          // Jump table.
     ( seqCode attr
       JumpList_ @       // List of constant-label pairs.
       LabelNode @ )     // Default label.
  JumpList_ ->                 // Jump list.
     ( listCode attr           // Correlate Exp value
       List_of_SwitchCase @ )  // and list of SwitchCase_ pairs.
  SwitchCase_ ->       // List of SwitchCase_ pairs.
     ( seqCode attr
       ConstNode @     // Correlate Exp value and
       LabelNode @ )   // switch statement label.
  ExpStmt   ->         // Expression statement.
     ( expStmtCode attr
       Exp @ )         // Expression treated as a Stmt.
  NullNode  ->
     ( nullCode attr ) // NullNode is a terminal
            ;           // that is not null.
  InfStmt   ->         //##24
     ( infCode attr    // Information node (terminal).
       InfKind_        // Information kind identifier.
       InfObject_  )   // Information.
                       // (InfKind_ and InfObject_ are not
                       // traversed by HIR traverse operations.)
  InfKind_  ->
     stringConst // String constant showing the kind of
            ;     // information such as pragma, comment, etc.
  InfObject_  -> // Information.
     Object      // Object such as Sym, Exp, etc. or
                 // a list of Objects. It may or may not be HIR.
  ConditionalExp_ ->     // boolean expression
     Exp
  Exp ->                //Expression.
     Factor_
   | UnaryExp_
   | BinaryExp_
   | ExpListExp    //##24
   | SelectExp           // HIR-C only
   | NullNode
//##24  | InfNode
  Factor_  ->
     ConstNode
   | SymNode
   | CompoundVar_
   | FunctionExp
   | PhiExp
//| AssignStmt          // HIR-C
   | ExpListExp          //##24
   | HirSeq              // Sequence of objects
  UnaryExp_ ->           // Unary expression.
     ( UnaryOperator_ attr
       Exp @ )

   | ( sizeofCode attr // size of the type of Exp
        Exp @ )  
   | ( sizeofCode attr  // size of the type
       TypeNode @ )     // represented by TypeNode.
  BinaryExp_ ->         // Binary expression.
     ( BinaryOperator_ attr
       Exp @

       Exp @ )

  CompoundVar_ ->    // Compound variable.
     SubscriptedExp  // Subscripted variable.
   | PointedExp      // Pointed variable.
   | QualifiedExp    // Qualified variable.
  SubscriptedExp ->  Subscripted variable. //##14
     ( subsCode attr // Array with subscript expression.
       Exp @       // Expression indicating the array.
       Exp @ )     // Subscript expression.
//##24  | ( subsCode attr
//##24      Exp @       // Expression indicating an array.
//##24      ExpList @ ) // List of Subscripts.
//##24          ;        // (1st subscript, 2nd subscript,
//##24                 //  etc. for rectangular array.)
  ElemSize_    ->    // Element size.
     Exp
  QualifiedExp ->    // Qualified expression.
     ( qualCode attr // Qualified variable
       Exp @         // Should represent a structure or union.
       ElemNode @ )  // struct/union element.
   // | ( qualCode attr // Class field
   //     Exp @         // Should represent a class.
   //     FieldNode @ ) // Field of the class.
  PointedExp ->       // Pointed expression.
     ( arrowCode attr // Pointed variable
       Exp @          // Expression representing a variable
       PointedElem_ @ ) // Pointed element.
  PointedElem_ ->
     ElemNode  // Pointed element (with displacement).
   | null      // Pointed location (0 displacement).
  ConstNode ->          ;            // Constant symbol.
     ( constCode attr intConst )    // integer   constant
   | ( constCode attr floatConst )  // float     constant
   | ( constCode attr charConst )   // character constant
   | ( constCode attr stringConst ) // string    constant
   | ( constCode attr boolConst )   // boolean   constant
  SymNode   ->        // Symbol node.
     (symCode Sym )   // Program name, etc.
   | VarNode
   | SubpNode
   | LabelNode
   | ElemNode  //##16 not DELETED
   | TypeNode
  VarNode   ->
     ( symCode attr varSym )   // Variable name node
  SubpNode  ->
     ( symCode attr subpSym )  // Subprogram name node
  LabelNode ->
     ( symCode attr labelSym ) // Label reference node
  ElemNode  ->
     ( symCode attr elemSym )  // structure/union element
            ;           ;             // name node.
// FieldNode -> ( symCode attr fieldSym ) // Field name node.
  TypeNode  ->
     ( symCode attr typeSym )  // Type name node
  FunctionExp ->     // Function expression.
     ( callCode attr
       Exp @         // Expression specifying function
                     // to be called (SubpNode, etc.).
       HirList_ @ )  // Actual parameter list.
                     //   It is HirList whose elements are Exp.
  IrList     ->
     ( listCode attr    // A List that can be treated as IR.
       List_of_Objects_ @ )
  HirList        ->
     ( listCode attr    // An IrList that can be treated as HIR.
       List_of_Objects_ @ )
  ExpListExp    ->         // Expression representing  //##24
     ( expListCode attr    // a list of
       List_of_Exp @ )     // expressions in HIR form.
  HirSeq  ->
     ( seqCode attr HIR @ )  // Sequence of some definite
   | ( seqCode HIR @  HIR @ ) // number of HIR nodes.
   | ( seqCode HIR @  HIR @  HIR @ )
   | ( seqCode HIR @  HIR @  HIR @  HIR @ )
  PhiExp         ->
     (phiCode attr FlowVarList_ @ )  // phi function
  FlowVarList_   ->
     ( listCode attr
       List_of_VarLabelPair @ )
                               // List of (Var Label) pairs.
  VarLabelPair   ->
     ( listCode attr VarNode @  Label @)  //##9
  UnaryOperator_ ->
     notCode      // bitwise not (~) one's complement
                 //logical not (boolean not) (!)
   | negCode      // negate (unary minus)
   | addrCode     // get address (&)
   | contentsCode // get contents of pointed memory
   | convCode     // type conversion for basic type
   | decayCode    // convert array to pointer
   | castCode     // type conversion by cast for pointer
   | sizeofCode   // sizeof operator
   | encloseCode  // honor parenthesis
   | IncrDecrOperator_  // Increment/decrement. HIR-C only.
  BinaryOperator_ ->
   | addCode      // add                 (+)
   | subCode      // subtract            (-)
   | offsetCode   // Offset between pointers (HIR-C only)
   | multCode     // multiply            (*)
   | divCode      // divide             (/)
   | modCode      // modulo             (%)
   | andCode      // bitwise and, boolean and  (&)
   | orCode       // bitwise or, boolean or    (|)
   | xorCode      // bitwise exclusive or, boolean exclusive or  (^)
   | shiftLLCode  // shift left  logical    (<<) //
   | shiftRCode   // shift right arithmetic (>>)
   | shiftRLCode  // shift right logical    (>>) //
   | undecayCode  // convert pointer to array //##10
   | expRepeatCode   // Repeat constant values (operand 1)
                     //   count (operand 2) times.
   | CompareOperator_
   | CompareZeroOperator_            // HIR-C only //##20
   | ShortCircuitOperator_           // HIR-C only
   | commaCode    // comma operator  // HIR-C only
  CompareOperator_ ->
     cmpEqCode    // equal
   | cmpNeCode    // not equal
   | cmpGtCode    // greater than
   | cmpGeCode    // greater or equal
   | cmpLtCode    // less than
   | cmpLeCode    // less or equal
  CompareZeroOperator_ ->               // HIR-C only //##20
     eqZeroCode   // equal zero          // HIR-C only //##20
  ShortCircuitOperator_ ->              // HIR-C only
     lgAndCode    // logical and (&&)    // HIR-C only
   | lgOrCode     // logical or  (||)    // HIR-C only
  IncrDeclOperator_ ->          ;           ;        // HIR-C only
     preIncrCode  // pre-increment  (++) // HIR-C only
   | preDecrCode  // pre-decrement  (--) // HIR-C only
   | postIncrCode // post-increment (++) // HIR-C only
   | postDecrCode // post-decrement (--) // HIR-C only
  CompoundAssignmentOperator_ ->         // HIR-C only
     multAssignCode   // *=    // HIR-C only
   | divAssignCode    // /=    // HIR-C only
   | modAssignCode    // %=    // HIR-C only
   | addAssignCode    // +=    // HIR-C only
   | subAssignCode    // -=    // HIR-C only
   | shiftLAssignCode // <<=   // HIR-C only
   | shiftRAssignCode // >>=   // HIR-C only
   | andAssignCode    // &=    // HIR-C only
   | xorAssignCode    // ^=    // HIR-C only
   | orAssignCode     // |=    // HIR-C only
  SelectExp ->        //  (Exp ? Exp : Exp) // HIR-C only
     ( selectCode attr
       ConditionalExp @   Exp @  Exp @ )
  attr ->             // Attribute attached to the HIR node //##20
     typeSym          // Shows the type of HIR subtree.
     OptionalAttrSeq_ // Sequence of optional attributes
                      // that are not inevitable at the first stage
                      // of HIR generation. The optional attributes
                      // may be attached to give information used
                      // in some specific compiler modules or
                      // to help compiling processes.
  OptionalAttrSeq_ ->
     OptionalAttr_ OptionalAttrSeq_
   | null
  OptionalAttr_ ->
     StmtAttr_      // Attributes for statements
   | IndexNumber_   // Index number to identify the HIR node.
   | Flag_          // true/false flag.
   | InfItem_       // Node-wise information.
   | ExpId          // Expression identifier used in flow analysis.
   | Work_          // Phase-wise information.
  StmtAttr_ ->      // Attributes attached to statement subtrees.
     FileName_      // Source program file containing the statement.
     LineNumber_    // Line number of the line in which the
                    // statement started.
  FileName_ ->
     stringConstValue
  LineNumber_
     intConstvalue
  IndexNumber_ ->
     intConstValue
  Flag_ ->
     FlagNumber_
     FlagValue_
  FlagNumber_ ->
     intConstValue  // Such as FLAG_NOCHANGE, FLAG_C_PTR,
                    // FLAG_CONST_EXP
  FlagValue_ ->
     true
   | false
  InfItem_ ->
     InfKind_ InfObject_

----------

롼פConditionalInitPart  ##24
   UntilLoop (replaced by RepeatLoop) //##47
źindexɽ##24
