2003/6/22, 11/28, 2004/5, 6/14, 22, 8/15
ɽηỌ̇̄
	(##25): 2004/08 
	(##24): 2004/05-6 
(##23): 2003/11, (##22): 2003/7, (##21): 2003/6 
(##14): 2002/6, (##11): 2002/1 
(##10): 2001/12, (##9): 2001/10 

ܻͽǤϡɽHIRηȤɽƤˤĤƽҤ٤롣
HIRλͤϸоݵˤʤΤǤ뤬Υ᡼
ˤäơθεˤĤƸڤ褤Ȥ
롣졢굡ˤĤƽҤ٤Ȥϡʬ[[ ]]ǰϤǼ
졢굡ФƲɤΤ褦˰κˤĤƤϡ
SourceLanguage饹MachineParam饹ǵҤƤʬ⤢롣

ϸ줫HIRؤѴHIR-base

ϥץHIRѴȤʳϸͭɽ
ɽͳ뤳Ȥ롣Τ褦ɽޤޤʤHIR򤽤
ȶ̤ɬפȤϡϸ˰¸ʤHIRHIR-baseȸƤ֡
	(##10)
[[
CΥץHIRѴȤCͭδĤɽޤHIR-
CͳơɽǤHIR-baseѴ롣
CHIR-CHIR-base
HIR-CϡCHIRؤѴϤʣʬ䤹뤿ȡեȥ
ŪġΤ褦ˡCϥץ˶ᤤɽǽ
䤹뤿ߤɽǤ롣ñHIRȸHIR-base
ΤȤǤ롣HIR-baseǤʤHIR-CˤĤƽҤ٤ȤɬHIR-Cȸ
"-C"άɽ
HIR-CHIR-baseޤɽǤ롣HIR-baseˤʤHIR-C
ɽϡ
ûＰ&&, ||
黻ҡ?:	(##9)
ʸʼΰҤηȤʸ
ޱ黻
󥯥ȡǥȡ++, --ˡ(##9)
ʣ礵줿黻
+=, -+, *=, /*, %=, <<=, >>=, &=, ^=, |=ˡ(##9)
ݥ󥿤Фø黻
Ǥ롣HIR-CηˤϡHIR-baseѴȤ˺ʬΤ
롣ȤHIR-CintϡHIR-baseǤint, char, enum˺ʬ
롣ޤHIR-CHIR-baseδ֤ǡƱɽǰ̣ΰۤʤΤȤ
Ƥϥݥ󥿤θ(##9)줬ɤΰ̣ǻȤƤ뤫ϡ
黻ΡɤˤĤե饰ǼHIR.FLAG_C_PTRˡ(##11)
]]

HIR-baseη

ɽ

ʣ˥Ρɤȷб
HIRڹ¤ɽ졢бƥɽġHIRɽ魯
ڹ¤ΥΡɤˤϡҶʤաleafˤȡҶ
nonleafˤ롣ƥΡɤϷ°(attribute)ȤƻġleafΡ
ɤϡѿ̾ץ̾ʤɡϥץ˸룱Ĥε
ɽ s ɽleafΡɤηϡε s ηƱǤ
ʵɽλͳפǽҤ٤褦ˡˤϷͿƤˡ
nonleafΡɤϡĤʾλҶȡ黻ʥڥ
ɡˤȤ黻Ҥɽ롣leafΡɤˤnonleafΡɤˤ⡢줬
Ǥ뤫ɽ黻ҤɲͿƤ롣leafΡɤϥ
ڥɤʤ黻Ҥɽ(##10)nonleafΡɤϴݳ( )
ϤɽleafΡɤȷҤ줿ϳѳ< >ǰϤɽ
(##21)
黻 op ɽnonleafΡɤηϡΥڥɤ˱黻 op Ŭ
Ѥ̤μηɽηϡʬڥɤȱ黻ҤȤ߹
碌ˤäHIR˷뤬Ѵ黻convη̤ηϡ
ʸ鸫Ƥ˲ηͿ٤Ǥ뤫Ȥʸ̮ˤäƷᡢ
ηΡɤյ (##9)ηɬפȤʤΡɤη
voidȤ롣̤ˡnonleafϼʸץʤɤɽleaf
ñѿ٥ʤɤɽҤäơnonleaf
leaf⹭μȤߤʤȤ롣HIRΥΡɤηϡġιμ
ФơHIR˷ΤǤ(##9)

ʣ˥֥
ͤ뵭ΰʵˤ򥪥֥ȤȤ(##9)֥
Ȥ礭(size)ϥХȿɽ(##24)voidǤʤͤ
ͤ黻ҡassignˤ裱ҤˤäƼ륪֥Ȥ
ȡͤϼ˿ͤޤݻ졢ε
Ȥ뼰ͤϡ˺Ǹ줿ͤȤʤ롣ʤǽҤ٤
ˡvolatile(qualifier)ĤƤȤϤȤϸ¤ʤ
ͤεȤƤΥ֥Ȥɽ͡l-valueˤǤ롣
֥ȤηϡݻͤηǤ롣̤ˡѿͤ
Ǥ뵭Ȥɽ뤬constҤĤƤͤǤ
ʤѿɽȤˤȤǽҤ٤乽¤ΡΤ
Ǽ뵭⡢줾졢ѿ¤ѿѿȤ褦
ˡѿΰȤߤʤȡѿϥ֥Ȥɽ
ѿǤϤʤȤɽ륪֥Ȥ⤢롣󡢹¤ΡΤ
֥ȤǤꡢɽϺͤǤ(##9)
ˤϡconstҤĤΤʤɡʸκդˤǤʤΤ⤢롣
ɬ⥪֥ȤǤϤʤϥ֥ȤǤ
(##21)
֥ȤϥץбƺФǤʤ
μ¹˺뤳Ȥ⤢ꡢ륪֥Ȥΰ̤Υ
ȤȤƻȤȤ⤢롣ɤεɤΥ֥ȤȤƻȤ
HIRǤɽ˽äƷ롣

ʣ˴ܷ
HIRդδܷbasic typeˤȤƤ
short int               û
int                     
long int                Ĺ
long long int           Ĺ
float                   ư
double                  ư
long double             Ĺư
char                    ʸ
bool                    false, trueͤȤ˻˷
(##22)
unsigned short int      ʤû
unsigned int            ʤ
unsigned long int       ʤĹ
unsigned long long int  ʤĹ
unsigned char           ʤʸ
offset                  ¤ǤǤѰ̡ޤ
֥ȤΥɽʥХñ̡
void                    ͤʤʶ
롣short int, int, long int, long long intĤ
unsigned short int, unsigned int, unsigned long int, unsigned long
long intʤΤξԤ碌Τ롣
float, double, long doubleưΤ롣charunsigned
charʸΤ롣ȤǽҤ٤褦ˡcharѴǤ
ѴϽimplementation definedˤưǤ롣
δܷ礭ХȤɽ뤫оݵʤɤˤäưۤʤ뤬
ѥ᡼뤳ȤǤMachineParam饹ˡ(##12)

(implementation defined)ưޤͤȤϡܥѥ
饤ե饹ȥ饯Ѥ륳ѥ鳫ȯԤƤƤ褤
ưޤͤǤ뤬ɤΤ褦᤿ʸ񲽤ʤФʤʤ
Ǥ롣
ϷͤġͤɽϽǤ롣ͤˤϳɽ
ɽɽˤб롣HIRˤɽϸˤɽ
Ȱۤʤ뤳Ȥ⤢롣HIRͤɽɽɽʤɤ˻Ȥ롣
HIRɽѴΤϡSourceLanguage饹
makeIntConstString, makeFloatConstString, makeStringBodyʤɤΥ᥽
ɤˤäƹԤ(##21)
HIRǤϡintϿɽ(##25)long intϿ
θLĤɽ롣long long intϿθ
LLĤɽ롣unsigned intϿθUĤ
ɽunsigned long int, unsigned long long intϡ줾
졢θUL, ULLĤɽ(##25)Ȥ1Ȥ
ϤɤηǤ뤫ˤäơ1, 1L, 1LL, 1U, 1UL, 1ULLȤɽ
ġ(##21)
ưɽϡŪCƱǤ뤬̤뤿
ˡfloatǤFdoubleǤDlong doubleǤ
L򤽤줾Ĥ롣(##25)
ʸʸȤɽʸstringȸƤɽġ
ʸɽˤƤϡϸˤäƳϽλΰ䥨ʸ
ääꤹ뤬ɽʸΤΤ󤫤ʤ
ʸΤȸƤ֤ȤˤȡHIRǤʸɽʸΤ
˰"ˤĤȤ롣Ȥϡʸ
ˤϰǤʤʸޤޤ줿ꤹΤǡѥ鵭ҸǤ
Javaɽ˹碌ƥʸäư(##25)ʸ
""ɽϸˤɽHIRˤɽδ֤Ѵ
᥽åɤϡSourceLanguage饹Ѱդ(##22)(##14)
charͤˤintʸɡcharacter codeˤб롣
unsigned charͤˤunsigned intʸɡcharacter codeˤ
б롣boolͤtruefalseǤ롣boolͤˤϽorder
numberˤȸƤбtrueνϣfalseν0Ǥ롣
offsetϹ¤ǤǤѰ̡뤤ϥ֥Ȥ礭ɽ
int ޤ long int, long long intɽͤʸҤθη
ơб뤬줬int , long int, long long intΤǤ뤫
оݵˤäưۤʤ(##10)
٥ͤĥ֥ȤǤϤʤɽηvoid
Ȥ롣
¿θˤϡ嵭δܷΤĤб뷿Ƥ롣
줾θΤɤηHIRΤɤηб뤫ϡϸФ
륳ѥθˤäƷ롣(##11)
[[
Cint, short int, long int ϡ줾졢HIRint, short int,
long int ѴCsigned int, signed short int, signed long int
ϡ줾졢HIRint, short int, long int Ѵ롣Cchar
HIRcharѴ뤫unsigned charѴ뤫ϽǤ
SourceLanguage饹ȡˡ(##12)
HIR-basechar, bool, offsetϡȤǽҤ٤褦ˡHIR-CǤ
ȤưȤǤ롣
CǤʸ˽ΰ0Ĥ뤬ʸΤˤϴޤ
ʤ(##14)
]]

ʣ˷Ҥȸη
ܷ䤽¾η鿷뤿ηҤȤơ
pointer                 ݥ󥿡ʥ֥Ȥؤ
vector                  켡
struct                  ¤
union                   
enum                    enumeration
subprogram              ץ
typedef                 ̾
롣
ǤȤƤҡenumeratorˤˤϡorder
numberˤȸƤͤб롣boolϡĤʤɡ
̤¿Ȥ̤ηǤ(##22)ݥ󥿤ˤϡͤȤ
ε(address)б(##25)
ˤϷ const, volatile Ĥ뤳ȤǤ(##12) t ˷
ҤĤ t1  t Ȥϰۤʤ뷿Ȥ뤬黻˴ؤƤ t  t1
ƱȤŪѴɬפȤʤconstĤѿ
Ƥassign黻ҤˤˤԤȤϤǤʤ
volatileդѿФƤϡɺŬ仲Ȥά
뤳ȡʤӤˤνѹ뤳ȤϤǤʤ(##10)
(type constructor)ϡʷƳȤȤˡƳ줿
(introduced type)Ф뷿̾ԤΤ˻Ȥ(##22)Ҥˤ
äƿʷ t ƳȤtȤϲΤ˻Ȥָ
(origin-type)פȤηˤĤƤϡҤȤ롣Ƴ
줿Ф黻ϸηˤΤܤäƹԤƳ줿α黻
Ǥϸηα黻󤬲ä뤳ȤꡢˤĤƤϸ̤롣
ܷϡλ꤬ʤиηʤϸˤäƤϸ
ηͿ뤳ȤǤ롣offsetθηϡоݵΥѥ᡼ˤ
äơlong, long longʤɤȡ򤹤뤳ȤǤMachineParam饹
ȡˡ(##11)
[[
ϸ줬CΤȤϡcharboolθηintȻꤹ롣
(SourceLanguage饹)
]]
ۤʤ뷿 t1  t2 δ֤ǤϡηƱǤäƤ⡢ŬѤ
黻ҤڥɤȤƱΤΤ׵᤹ʤСѴε§˹
碌ư¾ηѴ(##10)ȤǽҤ٤褦ˡ
Ĥ㳰롣ηƱ硢ͤɽϰϡͰˤΰ㤤ʤɤϤ
뤬t1t2˶̤ɽϰϤˤͤФƤϡѴϸѤ
Ǥäơͤѹȼʤtypedefˤ뷿̾ǰۤʤ뷿̾
Ƴ줿ȤʤɡηƱǼ¼ŪѴɬפȤʤϤ
(##22)(##9)
Ƴ줿Ͱ褬ηͰƱ硢ʤӤ˷Ĥ
ξ硢Ƴ줿ϸηα黻Ѿ롣ξ硢HIRɽȤ
ƤϡƳ줿򸵤ηˤΤܤäɽƤ褤Ƴ
ȤɽƤ褤implementation definedǤ롣Ƴ
줿Ͱ褬ηͰȰۤʤ硢Ƴ줿ȸηδ֤ǡ
Ʊ黻ҤǤۤʤ̣ĤȤ롣(##11)
ηϢ򼡡ȤΤܤäƤ椯ȡܷ˹Ԥ夤ơ
夵Τܤʤʤ롣ˤθηfinal origin typeˤȤ
(##24)

ʣ˷ɽ
HIRƥɽȤƥȤɽɽˤΤ
ܷ򣱤Ĥû̻Ҥɽ褦ˤ뤿ᡢɽɽ
ˤƤ
ɽܷ
     int           int                (integer)
     short         short int          (short integer)
     long          long int           (long integer)
     long_long     long long int
     u_int         unsigned int
     u_short       unsigned short
     u_long        unsigned long int
     u_long_long   unsigned long long int
     char          char               (character)
     u_char        unsigned char
     float         float              (floating point number)
     double        double             (double floating point number)
     long_double   long double
     bool          bool               (boolean type, similar to enum)
     void          void               (has no value)
     offset        offset     (structure element offset, vector element
                               offset, object size, pointer difference)
(##25)

ҤФƤ⡢ûɽɽƤ
     ENUM         enum
     PTR          pointer
     VECT         vector
     STRUCT       struct
     UNION        union
     SUBP         subprogram
     TYPEDEF      typedef
ʣ礵줿ʸǷɽȤϡ̤ǰϤǺɤ
ưʸݥ󥿷󷿡booloffset
ϥ鷿Τvectorˤȹ¤ΡstructˡΡunionˤ
ΡaggregateˤΤ롣ζʬʲˤޤȤƼ(##10)
ˤθηƱˤʤ뷿ƱʬηǤ(##24)

ܷ

Ĥ
int, short int, long int, long long int
ʤ
unsigned int, unsigned short,
unsigned long int, unsigned long long int
ʸ
char, unsigned char
ư
float, double, long double
bool
void
offset

ENUM, PTR, VECT, STRUCT, UNION, SUBP, TYPEDEF

鷿
int, short int, long int, long long int,
unsigned int, unsigned short,
unsigned long int, unsigned long long int
char, unsigned char,
float, double, long double,
bool,
offset,
ENUM, PTR

VECT, STRUCT, UNION

ʣ˷Ƴ
Ƴ줿ζʬϡηƱǤ롣ʤη
Ƴ줿Ǥꡢη鷿ʤƳ줿⥹
鷿Ǥ롣ĤƳ줿Ʊݤϡˤäƹ¤Ʊ͡
̾Ʊͤʤɤΰ㤤ΤǡSourceLanguage饹Υ᥽åɤȽꤹ
Τ褤ȤǽҤ٤뤤ĤξˤĤƤϡƱʹط
Ƥ롣(##11)
ȤƤΥ֥ȤϡѿȤɽ뤳Ȥ¿
󥿼ȤƤɽ롣 T Υ֥Ȥؤݥ󥿤η
     <PTR T>
ɽPTR T 򷿤Ȥݥ󥿤λؤ֥Ȥη T Ǥ(##9)
     <PTR void>
򷿤Ȥݥ󥿤ϡǤդηΥݥ󥿤Ȥδ֤ߤѴǤ롣

(6-1) 
ϡƱǤνŤ줿Ǥ(##24)礭ϡ
Ǥ礭ǿ褸ɽ(##24) T  n Ĥ
ꡢźͤβ¤lbǤη  (##14)
     <VECT n lb T>
ɽ<VECT n lb T> 򷿤ȤǤη T Ǥ(##9)¿
ηϡ
     <VECT 10 0 <VECT 20 0 int>>
Τ褦ˡηȤɽǿȲ¤ϡФ
ʤμȤɽ뤳Ȥ⤢(##24)ѥǿ
źͤλꤵƤʤηԴincomplete typeˤǤ
ä
     <VECT null null int>,  <VECT null 0 char>
Τ褦ˡǿźͤʬnullȤɽ(##10)Դ
󷿤ϡǷƱǷȤηȤδ֤ǡ黻
ݤƷѴɬפȤʤ(##11)
[[
ĤǤϡ̾Ϣ³뵭֤뤬HIRλͤȤ
ƤϤʤäơźξ֤뤳Ȥ⶯
Ǥֻȥμ¸ˡϽǤ(##24)
]]

(6-2) TYPEDEF
TYPEDEFϡTǷɽ
     (typedef T name)
Ȥɽˤˤꡢ뷿Tname̾ȤƤĤ뤳Ȥɽ
Τǡɽˤˤ
     <TYPEDEF name>
Ȥ̾η뤤ϸ줴ȤɽηƳ黻ʤ
μ¹Ԥ˺ݤƤϤηΰTƱȤȤȤɽ롣
TƳ줿<TYPEDEF name>θηǤȤʸηͰ
ۤʤͰƳ줿ϤȤʺϤޤ
ˡˡname̾ϼ̻ҤǤ뤬ϸˤäƤϤǤʤɽ
㳰Ūǧ롣(##11)
Ƴ줿ļα黻ϡηε§˽äƹԤηޤ
Ƴ줿ǤСθη򤿤ɤäƹԤäơǸ˹Ԥ夤ʸ
ηͿʤʤȤޤǹԤ夤˸ηε§˽äƹԤ
Ƴ줿ȸηδ֤Ͱ˰㤤ϡ黻Ƥ
ۤʤ뤳Ȥ롣(##11)
[[
Cξ硢
typedef int cm;
typedef cm Length;
Length leng1;
Ȥȡ<TYPEDEF cm><TYPEDEF Length>ȤƳ졢leng1η
<TYPEDEF Length>Ȥʤꡢ<TYPEDEF Length>θη<TYPEDEF cm>
<TYPEDEF cm>θηintȤʤ롣ơleng1Ф黻intȤ
ƹԤ롣ʤƳ̾ΰȤ<TYPEDEF ̻>Ȥ
ʤȤǽҤ٤褦ˡ<STRUCT ̻>, <UNION ̻>, <ENUM 
> ȤƳ̾ȤƵˡ(##11)
Pascal
     type price = integer;
ϡHIRǤ
     (typedef int price)
ȤбˤpriceȤƳȤθ
int ǤȤ롣 (##11)
]]

TYPEDEF򷿹ҤȤʤǡHIRƳ줿򸵤η
֤ƤޤȤ¸ȤƵߤCparserϤ
褦ˤƤΤǡƳ򼨤CparserβɬפǤ
η֤ƤޤCparserβפǤ롣
ǤϡƳ줿̾ۤʤȰۤʤ뷿ȤưξŬ
ѤǤޤǥХåʤɤϥץˤɽ׵᤹
ˤ⤦ޤʤCξϷ̾Ƕ̤ʤΤǡǥХå̤ˤ
СCHIRȤƳ줿򸵤η֤Ƥޤ
ȤˤƤ褤ˡ(##11)

(6-3) 

     <ENUM <һꡡһꡡ...>>
ɽ졢һϼ̻ҤȤƤ(enumerator)Ȥν
ꥹ
<ҡ>
ɽ롣(ordinal number)Ǥ롣Ҥб
ϡҤ¤ӽ0, 1, 2, 3, ... Ȼꤵ뤳Ȥ¿
ɬϢ³ǤɬפϤʤơ
     <ENUM <LOW 3> <MEDIUM 5> <HIGH 8>>
Τ褦ʻ(##10)ҤηenumǤꡢθη
ǡͤбǤ롣ҤθηɤǤ뤫
MachineParam饹ǻꤹ롣(##11)
[[
Cˤ̾ɽ̻tȤƤĤƤС<ENUM t>
Ƴ줿Ȥơ󷿤 <ENUM t> ɽ̻ҤĤ
ʤHIRѴ˥̾t1<ENUM t1>ȤƳ
줿Ȥ<ENUM t1>ɽ褦Ѵ롣ʤƳ̾ΰ
Ȥ<ENUM ̻>Ȥ<ENUM t>θηΤ
饿̾ΤȤɽȤСCˤ
     enum signal {RED, YELLOW, GREEN} s1;
s1η<ENUM signal>ɽ<ENUM signal>θη
    <ENUM <<RED 0> <YELLOW 1> <GREEN 2>>>
ǤȤ롣ʤѿs1Ʊ
     (typedef <ENUM <<RED 0> <YELLOW 1> <GREEN 2>>> <ENUM signal>)
ǡ<ENUM signal><ENUM <<RED 0> <YELLOW 1> <GREEN 2>>ȤĤη
ƤΤȸʤޤCˤ
     enum {OFF, ON} flag;
flagηϡѥ줿̾t1Ȥ
     <ENUM t1>
Ȥ路θη
     <ENUM <<OFF 0> <ON 1>>>
ǤȤ롣
]](##11)

(6-4) ¤Τȶ
¤ΤϡǤνŤ줿Ǥ롣¤Τ礭
η׻ϽǤ롣ΤϡǤε
ŤʤäΤǤꡢ礭ϽǤ뤬Ǥ礭
Ǥ礭򲼲뤳ȤϤʤ¤ΤǤȶΤǤФ
μ¸ˡϽǤ롣(##24)
¤ΤȶΤϡ줾졢STRUCTޤUNIONλ³ơ
ǻܹˤ뷿ɽˤäƽ¤٤Ȥ
     <STRUCT <Type_1 Name_1> <Type_2 Name_2> ... <Type_n Name_n>>
ޤ
     <UNION  <Type_1 Name_1> <Type_2 Name_2> ... <Type_n Name_n>>
ηɽ롣ϡ줾졢Type_1, Type_2, ..., Type_n򷿤Ȥ
Name_1, Name_2, ..., Name_nǹ빽¤Τޤ϶Τη
ɽǤ롣

     <UNION  <Type_1 Name_1> <Type_2 Name_2> ... <Type_n Name_n>>
ϡγ Name_1, Name_2, ..., Name_n εƬ֤Ʊ
Ǥ뤳Ȥ̣롣(##23)
¤ΤȶΤФơޤ(typedef null Ƴ̾)Ƴ̾Դ
ȤȤ(typedef ¤ Ƴ̾)ޤ(typedef 
Ƴ̾)ǤʷȤ뤳ȤǤ롣Դϥݥ
ηʤɤȤƻꤹ뤳ȤǤ롣(##10)
[[
Cstruct
     struct point { int x; int y; } s1;
Τ褦˥ʾ嵭ǤpointˤĤƤСϹ¤s1
Ʊˡ <STRUCT ̾> ȤƳ̾ƳȤä
¤ s1ηΤȤߤʤ̾ĤƤʤHIRؤ
Ѵ˥ѥǥ̾ƱͤɽΤξƱͤ
<UNION ̾> Ȥ̾ƳΤȤߤʤʤƳ
̾ΰȤ<STRUCT ̻><UNION ̻>Ȥ
äơC
     struct point { int x; int y; } s1;
     union value { int iValue; float fValue; } u1;
     struct { char* name; int price; } b1;
Ǥϡb1줿̾t2Ȥȡ
     s1 η<STRUCT point>(##9)
     u1 η<UNION value>(##9)
     b1 η<STRUCT t2>
<STRUCT point> θη<STRUCT <int x> <int y>>
<UNION value> θη<UNION <int iValue> <float fValue>>
     <STRUCT t2> θη<STRUCT <<PTR char> name> <int price>>
Ȥʤ롣
㤨Cˤ
     typedef struct tnode *TreePtr;
     typedef struct tnode {
       char *name;
       TreePtr left;
       TreePtr right;
     } TreeNode;
     TreeNode root;
Ǥϡrootleftη
     rootη <TYPEDEF TreeNode>
     leftη <TYPEDEF TreePtr>
Ǥꡢ<TYPEDEF TreeNode> θη <STRUCT tnode><TYPEDEF
TreePtr> θη <PTR <STRUCT tnode>> Ǥ롣<STRUCT tnode>ϡ
ԴȤ졢ȤǴȤƺ롣
     typedef int Int;
     typedef Int *IntP;
     IntP p;
ФƤ
     <TYPEDEF Int>
     <TYPEDEF <PTR Int>>
     <TYPEDEF IntP>
ȤƳ졢pη<TYPEDEF IntP><TYPEDEF IntP>θη
<TYPEDEF <PTR <TYPEDEF Int>>><TYPEDEF Int>θηintȤʤ롣
]](##11)

(6-5) ץ
ץηϡ裲ǰηΥꥹȡ裳ǲѸĿ
̵ͭɽbool裴ֵͤηɽ
     <SUBP <1η  2η ...> bool ֵͤη>(##9)
ɽ롣ΤʤץǤ裲϶Υꥹ < > Ǥ롣
ѸĿ̵ͭɽbool裳ϡfalseʤ̵trueʤͭ
̣롣ֵͤʤץǤ裴voidȤ롣
[[
ȤC
     int (*comp)(void *, void *);
Фơcompη
     <PTR <SUBP <<PTR void> <PTR void>> false int> > >
Ǥ롣Cξ硢ץɽ&sizeofΥڥɰʳΤ
ǻȤȡץؤΥݥ󥿤ȲᤵΤǡcomp
ƤӽФ
     comp(i, j), (*comp)(i, j)
ץʬηϡ
     <PTR <SUBP <<PTR void> <PTR void>> false int> > >
Ǥ롣ʣȤ
     int *fpi();            /* Function returning pointer to int. */
     int  *(*pfpi)();       /* Pointer to function returning
                               pointer to int. */
     int  *(*fpfpi())()   /* Function returning pointer to function */
     {                    /* returning pointer to int. */
       return pfpi;
     }
        ...
       pfpi = fpi;
       pi1  = pfpi();
       i5   = (*fpfi())();
ȤʸФơ줾ץʤץ༰η
     int *fpi();          <SUBP <void> false <PTR int>>
     int  *(*pfpi)();     <PTR <SUBP < > false <PTR int>>>
     int  *(*fpfpi())()   <SUBP <void> false
                            <PTR <SUBP < > false <PTR int>>>>
     {  return pfpi;      <PTR <SUBP < > false <PTR int>>>
     }
        ...
       pfpi = fpi;        <PTR <SUBP < > false <PTR int>>>
       pi1  = pfpi();     <PTR <SUBP < > false <PTR int>>>
       i5   = (*fpfi())(); <PTR <SUBP < > false
                                 <PTR <SUBP < > false <PTR int>>>>>
Ȥʤ롣(##11)
]]

(6-6) 
 t ˷ҤĤ
<float const>
<int volatile>
Τ褦ˡt ˷ҤɵȤꡢθη t Ȥ롣黻
ϸηȤƹԤƱΥڥɤ׵᤹뼰ǡĤΥڥ
ɤηδ֤ǷҰʳʬƱǤϡѴ
ɬפϤʤ(##11)

黻η

黻ηϡڥɤηȱ黻ҤˤäƷΤ¿conv
Τ褦HIR-baseѴȤϸλͤ˽äƷΤ⤢
롣ơα黻ҤϤ˹äΥڥɤ׵᤹Τǡ˹礦
褦ˡϸβǤϡɬפ˱ƥڥɤŪѴ
Фʤʤ黻ηˤĤưʲǼȤ˸̤뤬
⻲Ȥ줿
HIR-baseʸˡʣ졢ʣ˶̤Ǥ뤬ζŪɽ
ʥ󥹥󥹡ˤˤϸ䵡˰¸ͤĹܤ롣ʤ
HIRΥ󥿥եʣ졢ʣ˶̤Ǥ뤬Υ󥹥
ˤϸ䵡˰¸ͤĥեɤ롣Ūѥ
ϸ졢оݵФΤʤΤǡΤ褦ʰ¸
äƤ⤵پϤʤHIRνץʣ졢ʣ˶
̤ηǺ뤳ȤǤ롣(##9)

ʣ
HIRǤϡȤƤint, long int, long long int, unsigned int,
unsigned long int, unsigned long long intꡢưȤ
Ƥfloat, double, long double(##25)ϸΤɤ
HIRΤɤб뤫ϡϸθǷ롣
(##21)
[[
CդʤưϡHIR-
baseǤ⤽бHIRηǤ(##22)sizeof黻Ҥ
̤offsetǤ롣ʤͤϡƱϥץ
ФƤ⡢оݵ郎ۤʤȰۤʤ礬(##10)
HIR-baseǤϡCȰäơʸintǤϤʤcharǤꡢ
enum̾դȤƤҤintǤϤʤenumǤ롣
ʸϡȤƤɽϤ뤬ȤƤʸȤΤǡʸ
򤽤ιǤǤʸʬ򤹤ȤϡcharȤư
(##14)
]]
offset enumϡ̤ˡʣʿɽ
ɽ(internal value)ĤͤJavaȤɽǤϰϤ
ۤƤϡisOutOfValueRange()᥽åɤtrueֵѤ졢
ɽͤʤ߹ߤʤɤɽѴϡɽ
JavaȤɽǤϰϤǤΤ߹Ԥư
ɽͤĤ줬JavaưȤɽǤϰϤ
ۤƤˤϡisOutOfValueRange()trueֵѤ졢ɽ
ͤʤʸɽͤϡбintɽ
ޤunsigned charintѴɽͤȤ롣(##9)
ʸϡбʸΤΤϤȽ"դ
ɽ롣(##14)
[[
ʸΤϡϸ줬Cξ硢ξüΰ " ֤
escape character ᤷü0x00 ʸǤ롣
(##14)
]]
TͤvɽHIRΥΡɤ
     <const T v>
ɽȤ123ɽHIRΡɤ
     <const int 123>
ɽ(##21) boolˤ
     <const bool true>,  <const bool false>
(##24)
[[
CʸɽΡɤϡˤĤ0x00ʸǤȿ

     <const <VECT 4 0 u_char> "abc">
Τ褦ɽ
]](##21)
nullϼηǡɽڹ¤ˤNullNodeϲκѤ⤷
ʤդɽΤǤꡢnullǤϤʤNullNodeηvoidǤ
롣)(##22)

ʣѿ
ϸηTHIRηбΤǤСϸT
HIRǤtѿȤʤ롣t鷿ǤФϥѿǤ
ꡢηǤнѿǤ롣
[[
Cshort int, int, long int, char, float, double, long double,
unsigned short int, unsigned int, unsigned long int, unsigned char 
ѿϡ줾졢HIR-baseǤ⤽бHIRηѿǤ롣C
ˤơTϷȤDҡdeclaratorˤȤȤ
     T  D[n]
DηϡTnĤǤʤ
     <VECT n 0 T>
Ǥ롣nʤȤ롣ޤ
     T D[ ]
DηϡTθĿǤʤ
     <VECT null 0 T>
Ǥ롣
     T *D
DηϡTΥ֥Ȥؤݥ
     <PTR T>
Ǥ롣enum, struct, union, ؿˤĤƤϡ˽Ҥ٤Ǥ
롣
     char *s;
Ǥϡsηʸؤݥ
     <PTR char>
Ȥ롣
]]
ѿvɽleafΡɤϡvηTȤ
     <var T v>
ɽ
ǤηTȤ a  i ǤϡaiФHIRɽ
줾a', i'Ȥȡ
     (subs T a' i')
ɽ롣a'ηϡǿnźͤlbȤȡ<VECT
n lb T>Ǥ롣aiѿɽleafΡɤǤС嵭
     (subs T
       <var <VECT n lb T> a>
       <var int i> )
ɽ롣ɽ a  i Ǥΰ֤򻻽Фˤϡź
ĿʤȤεϤѰ̤κʬɬפˤʤ뤬η׻˻Ȥ
ǤΥ춭оݵ˰¸롣a'ϡȤǽҤ٤褦ˡ
aؤݥ󥿼ޤaƬؤݥ󥿼ǤäƤ褤
(##14)¿ǤȤȤɽ롣(##21)
¤sxϡxηTȤs HIRɽs'Ȥȡ
     (qual T
       s'
       <elem T x> )
ɽȤаˤǤ
     (qual int
       <var <STRUCT <int x> <int y>> s>
       <elem int x> )
Τ褦ɽ(##21)Τξ⡢STRUCTUNIONѤǡ
ȤƱͤǤ롣xoffsetˤϡElem󥿥եΥ᥽
åevaluateDispȤä
     x.evaluateDisp()
Τ褦ˤ롣̾ͤǤϤ뤬ȤɽƤ
⤢ꡢͤȤƳꤹ뤫ݤisDispEvaluableǳǧǤ
(##9)
ݥpؤ¤Τ䶦ΤTxϡp, xHIRɽ
줾p', x' Ȥȡ
     (arrow T  p'  x')
ɽ(##21)p, xleafΡɤǤ
     (arrow T
       <var <PTR T> p>
       <elem T x> )
Ȥʤ롣ݥpλؤ֥ȼΡʥ鷿ˤͤϡ
     (contents T
       (p' <PTR T> )
ɽ롣
ݥpaƬɽƤơͤѹ뤳Ȥʤ
ɥ쥹Ƥʤơ
     (contents int
      (add      <PTR int>
       <var      <PTR int> p>
       (mult     offset
        <const    offset 4>
        (conv     offset
         <var      int i>))))
Τ褦ˡiܤǤؤȤǤΤpȤäƤꡢ
ǿźͤ狼äƤʤСaǤηTȤȡ
pޤ༰λؤiܤǤϡݥ󥿤undecaysubs
ˤǤƱɽˤƤ褤(##24)Ǥɽˤ
ݥɽꡢŬ󲽤Ԥ䤹礬¿(##24)嵭ξ
硢pƬǤؤΥݥ󥿤ȤȤäƤʤС
     (subs T
       (undecay <VECT n lb T>
         <var <PTR T> p>
         <const int n>         (##22)
         <const int lb> )      (##22)
       (i' int) )
ɽƤ褯pΤؤΥݥ󥿤ȤȤäƤʤС
     (subs T                              (##22)
       (contents <VECT n lb T>            (##22)
         <var <PTR <VECT n lb T>> p> )    (##22)
       (i' int) )                         (##22)
ɽƤ褤(##25)ǡ(i' int)ϡiФHIRɽǤꡢ
n, lbpλؤǿźͤǤ롣(##21)
[[
CδؿȤƤ벾嵭ξƤʤ
(##24)ǤsubsɽƤ褤ȤС
   void f(int a[10], int b[3][5]) { ... }
Ǥϡa[i]b[j][k]򡢤줾졢
     (subs int
       (undecay <VECT 10 0 int>
         <var <PTR int> a> )
       <var i int> )
     (subs int
       (subs <VECT 5 0 int>
         (undecay <VECT 3 0 <VECT 5 0 int>)
           <var <PTR <VECT 5 0 int>> b>
           <const int 3>
           <const int 0> )     (##22)
         <var j int> )
       <var k int> )
ɽƤ褤CθͤǤɽϤƬ
ؤݥ󥿤̣ΤǡǤint a[10]10 int b[3][5]
3ϡ;ǿ103Ǥ뤳ȤݾڤΤǤϤʤ
ȤϤ줿ľȤƤλȤƤ嵭
ξƤȽǤϡǤϺŬ󲽤ν
оݤʤΤǡݥ󥿤ȤƤɽǤʤǤȤƤɽˤƤ
(##25)Ȥ줿б°̤
ǿäƤ뤫ݤϰ̤ˤϸڤǤʤΤǡŬ󲽤
ѴˤäơбطƤΤȤѴΤϡѥ
ΥץǤλݻꤵƤ˸¤٤Ǥ롣ʤ
     int f(int (*p)[10], (*q)[4][5]) {
       int i, j, k, x;
       ....
       x = (*p)[i] + (*q)[j][k];
       ....
     }
Τ褦ʽ򤹤硢(*p)ǿ10(*q)ǿ[4][5]
룲ȳꤷƤΤǡ̵ȤưȤǤ
롣(##24)
]]  (##21)

ʣ˻Ѽ
ø;ɽѱ黻add, sub, mult, div, modϡ
ưΥڥɤ顢ΥڥɤƱη̤
롣Ĥʤshort, long, doubleζ̤ϡڥɤη
ˤäޤ(##9)λѱ黻ҤˤơĤΥڥɤϡ
̤ƱǤʤФʤʤΰۤʤ룲ĤΥ
ڥɤФƻѱ黻ҤѤ褦ȤϡɽǽϤι⤤
˹碌Ƴʾ夲褦ΥڥɤŪѴƤ黻
˹롣ҤĤηȤθηʷʤη
Ȥδ֤ǤѴ˱黻Ǥ(##10)ѴϡHIR-baseɽ
ϸλͤ˹碌ƹԤ
ȿžñޥʥ黻negϡĤoffsetޤ
ưΥڥɤФƤϡƱȿž̤
롣ʤʸʤɡ嵭ʳηΥڥɤФneg
褦ȤϡHIR-baseѴȤĤؤŪ
ѴԤäΤ򥪥ڥɤȤʤФʤʤ

ʣ˥ݥ󥿼(##9)
HIR-baseǤϡݥ󥿤Фơ裱ڥɤݥ󥿤Ȥ裲
ڥɤoffsetȤøȡ裱ڥɤoffsetȤ裲ڥ
ɤoffsetޤȤøʤӤ裱ڥɤ裲
ڥɤƱΥݥ󥿤Ȥ븺Τߤѱ黻ȤƵ롣裱
ξ硢ݥ󥿤offsetα黻̤η裱ڥɤΥݥ󥿤η
ƱǤ롣add黻ҤǤ裱ڥɤΥݥ󥿤ɽϤ
ڥɤoffsetͤäϤ̤Υݥ󥿤Υݥ
ϤȤ롣sub黻ҤǤϡ裱ڥɤɽϤ裲
ڥɤͤ򸺤Ϥ̤Υݥ赭ϤȤ롣裲ξ
η̤offsetǤ롣裳Υݥ󥿴֤θǤϡ裱ڥ
Υݥ赭Ϥ裲ڥɤΥݥ赭Ϥ򸺤ͤ
offsetη̤롣
HIR-baseǤϡoffsetoffsetβøoffsetη̤
offsetøޤϾ軻offsetη̤offset
offsetǽη̤롣offsetνϡsizeof
offsetͤʤɤѤơǿʤɤѤ
롣
[[
HIR-Cˤݥ󥿤βøǤϡadd, sub ϡ줾졢TΥ
֥Ȥؤݥpi򥪥ڥɤȤơpsizeof(T)*i
ä롢ޤϸ뤬HIR-baseǤϡaddsubΥڥɤϥݥ
offsetȤǤˤΤ褦sizeof(T)褸黻ʤ줿
̤offsetڥɤȤͿƤΤȤ롣ʤHIR
ѴȤΤ褦ʾ軻Ū롣ƱͤˡCǤϥݥ
κʬݥ襪֥ȤθĿȤƤκʬȤ뤬
HIR-baseǤϡsub黻Ҥˤ국ϤκʬȤäȤ֥
θĿȤƤκʬˤϡsizeof(T)ǳ黻Ūɽ
ФʤʤHIR-CǤΤ߻Ȥoffset黻ҤǤϡݥ󥿴֤κʬ
ǿɽHIR-CHIR-baseĥɽʤΤǡݥ󥿤κʬ
offset黻ҤǤʤsub黻ҤɽȤϡHIR-baseƱ
sizeof(T)ǳ黻Ūɽ롣HIR-CǤ⡢ݥ󥿤
ʤݥ󥿤offsetɽȤHIR-baseƱ̣ˤʤ롣
]]
HIR-baseˤݥ󥿴Ϣα黻ޤȤȡΤ褦ˤʤ롣

黻ҡ裱裲
ڥɡڥ
add     ݥ󥿡offsetݥ
sub     ݥ󥿡offsetݥ
sub     ݥ󥿡ݥ󥿡offset ǿǤϤʤ
add     offset  offsetoffset
add     offset  offset(##10)
sub     offset  offsetoffset
sub     offset  offset(##10)
mult    offset  offset
div     offset  offsetlong  (##22)
neg     offset            offset(##10)
offset  ݥ󥿡ݥ󥿡long ǿHIR-CǤΤ
                                                       (##24)

[[
HIR-Cˤݥ󥿴Ϣα黻Ǥϡ嵭˲äơݥ󥿤
ȥݥ󥿤ʤɡCǵɽ롣(##24)
]]
ɥ쥹黻addrϺͤޤץ෿򥪥ڥɤȤ
ڥɤηTȤȡTؤΥݥ <PTR T> ̤ηȤ롣
ܱ黻contentsϡݥ󥿷ΥڥpȤpΥݥ
Υ֥Ȥ̤ͤȤ롣pTؤΥݥ󥿤ǤȤ
contentsηTȤʤ롣
decay򥪥ڥɤȤ黻ҤǤꡢƬǤؤΥݥ
̤Ȥ̤ηϡǤηTȤȡTؤΥݥ
<PTR T> Ǥ롣decayʸФƺѤȡʸƬʸ
ؤݥ󥿡ʷ<PTR char>ˤ(##21)
undecay黻Ҥϡ裱ڥɤȤƥݥ󥿤Ȥꡢ裲ڥ
Ȥǿɽ裳ڥɤȤźͤɽ
Ȥ롣undecay裱ڥɤη <PTR T>裲ڥɤ n 
裳ڥɤlbȤȡundecayη̤ϡT ǤnĤ
Ǥꡢη
<VECT n lb T>
Ǥ롣undecay裲ڥɤ裳ڥɤnullǤȡ
γʬɽη
<VECT null null T>
Τ褦ˡʬnullȤʤ롣
addr, contents, decay, undecayΰ㤤򷿤ܤƸȼ̤
롣
addr: T  <PTR T>
decay: <VECT n lb T>  <PTR T>
 string  <PTR char> ޤ <PTR u_char>
ʤʸstringˤФŬѤ롣
ؿˤdecayŬѤʤ
contents: <PTR T>  T
undecay: <PTR T>  <VECT n lb T>
ʤǤؤΥݥ󥿤η󷿤Ѵ롣

ʣӼ
羮ӱ黻cmpGt, cmpGe, cmpLt, cmpLeϡޤư
󷿡booloffsetʤӤ˥ݥ󥿷ƱΣĤΥ
ɤͤФơ줾졢裱ڥɤ裲ڥɤ礭
礭ʤtrueǤʤfalse
boolη̤롣󷿤Ͻ羮ˤäӤ롣bool
Ǥϡfalse0true1ννˤä羮
Ԥ(##22)offsetϸηˤä羮ӤԤ(##10)
ӱ黻cmpEq, cmpNeϡ鷿򤷤ǤդƱΣĤ
ڥɤФơ줾졢ξԤͤʤˤä
truefalseboolη̤ͤȤ롣
ѼξƱͤˡΰۤʤ룲ĤΥڥɤФӱ黻Ҥ
Ѥ褦ȤϡɽǽϤι⤤˹碌Ƴʾ夲褦
ϸλͤ˽äơΥڥɤŪѴƤ黻
˹롣ݥ󥿤ӤǤϡvoidؤΥݥ󥿤null
ǤդηؤΥݥ󥿤ӤǤ롣ޤҤĤηȤθη
ʷʤηˤȤδ֤ǤѴӤǤ(##10)

ʣ
黻and, or, xorϡboolΣĤΥڥɤФơ줾
졢¡ѡ¾Ū¤α黻Ԥʤboolη̤
롣offsetФƤϡɽФ¡ѡ
¾Ū¤α黻ԤʤڥɤƱη̤롣
notboolΥڥɤ˺Ѥȡtruefalseˡfalse
trueȿž롣(##10)

ʣ˥ӥåȱ黻
黻notϡưʳΥ鷿ʸ󷿡
booloffsetݥ󥿷ˤΥڥɤФơɽ
룱ȿžӥåˤͤȤڥɤƱη̤
롣and, or, xor boolʳΥ鷿Υڥɤ˺Ѥȡ
ɽγơΥӥåȤФѡ¡¾Ū¤ͤȤ
ɽ̤ηϥڥɤηƱΤȤ롣and, or,
xor ΣĤΥڥɤηƱǤʤФʤʤ(##10)

ʣ˥եȼ
եȱ黻 shiftR, shftLL, shiftRLǤϡ裱ڥɤbool
ưݥ󥿷ʳΥ鷿ǤꡢɽФƺѤ
(##10)裲ڥɤǤꡢ̤裱ڥɤƱ
Ǥ롣ѱեshiftRǤϡӥåȤĥʤ鱦եȤ롣
եshiftLLǤϡӥåȤޤƺեȤüζӥ
Ȥˤ0롣եshiftRLǤϡӥåȤޤƱե
üζӥåȤˤ0롣
[[
CѴȤڥɤĤĤʸǤл
եȤȤʳʤեȤȤ
]]

ʣˤ¾α黻
Ѵ黻convϡΥڥɤconvη̤Ȥƻꤵ줿
convΡɤηˤѴ롣convη̤ηϡconvη̤򥪥ڥ
ɤȤƻȤ黻Ҥʸ̮ˤ׵᤹뷿˹碌ơHIR
롣voidؤΥݥ󥿤ФƤϡǤդηؤΥݥ󥿤Ȥδ֤
ѴǤ롣
encloseϡϥץˤƳ̤ǰϤޤƤбʬ
ڤƯ򤹤ΤǡηϥڥɤηƱǤ롣
źǤsubsϡ裱ڥɤȤɽ
裲ڥɤȤźȤ(##14)η̤ηϡǤ
Ǥ롣ʤ裱ڥɤη <VECT n lb T> Ǥз̤
TǤ롣źηȤ롣ǤƬ鸫Ʋ
ܤˤ뤫礭ź黻ФǤĹФƤϡ
subsˤäźͤǤΰ֤ưפ˵뤳ȤǤ롣
ʬ礭·ϡݥ󥿤ݥ󥿤ǤȤȤ
ɽ롣
SSAΦմؿphiǤϡ裱ڥɤȤƷ̤ɽѿ쥸
(v) ꤷ裲ڥɤȤơѿȥ٥ޤϥ쥸ȥ٥
 (v_i L_i) ǤȤꥹȤꤹ롣Υ٥ϡԤ
ܥ֥åͿ줿٥Ǥꡢή줬ɤδܥ֥åͳ
Ƥ뤫ɽΤǤ(##10)
     (phi  T
       (v T)
       (list (v_1 L_1 T) (v_2 L_2 T) ... ) )
ϡL_i٥ȤƻĴܥ֥å椬錄ä褿
бv_i̤ɽvȤ򤹤뤳Ȥɽi = 1,
2, ...ˡv_1, v_2, ... vηƱǤꡢηTphiη̤η
Ǥ롣

  黻ҤȥڥɡʤӤ˷̤ηδطɽˤޤȤƼϲ
ǽߤ̤ΰ̣Ǥ(##25)
羮桡ؤ
ӡӡȿžѴ
Ĥʬ
ʤߡʬ
ưѴ
char        ߡʸɤޤϸη
u_char      ߡʸɤޤϸη
bool        ߡfalse 0, true 1
offset      ηɽ
PTR         ߡ
ENUM        ߡηʽ

ʣץ
ץϡ˽Ҥ٤褦ˡ
     <SUBP <1η 2η ... > bool ֵͤη>(##9)
ȤǤηɽTץؤΥݥ󥿤ϡ̤Υݥ
Ʊ
     <PTR T>
ɽץη̤ηֵͤηǤ롣
ץƤӽФǤϡϤǤȤ롣ϤȤ
ϡΥ֥ȤεϤaddr黻Ҥǵ᤿Τ°Ȥ
Ϥܤץ໲Ȥ⻲Ȥ줿(##24)(##11)

ʣʸ
ʸǤϡ裱ڥɤϥ֥ȤɽͤǤꡢ裲
ɤͤͤΥ֥ȤͤȤ롣assignξڥ
ɤηƱǤꡢassignΥΡɤη⤽Υڥɤȡʷ
ΰ㤤ƤϡƱȤ롣裱ڥɤ裲ڥɤƱ
ι¤Τޤ϶ΤǤС裲ڥɤƤޤȤ裱
ڥɤͤȤꤵ(##14)constķʸκ
դȤ뤳ȤϤǤʤ裱ڥɤȰ㤦ͤ褦Ȥ
ϡHIR-baseȤ裲ڥɤ裱ڥɤη˹
褦ŪѴʤФʤʤnullNullNodeˤǤդ
Υݥ󥿤Ǥ(##10)
ʸΥڥɤηȤƤϡvoidʳΥ鷿ޤϽη
롣ʤʸưbooloffset
ݥ󥿷󷿡¤ΡΤɽͤ򡢤Ʊ
ɽͤ뤳ȤǤ롣(##24)
ȴؿͤȤ֤ȤˤĤƤϡߤϤޤ¸
ǤƤʤʬ롣(##24)

ʣʸ
ifʸjumpʸ롼ʸ֤ͤʤreturnʸswitchʸη̤η
voidǤ롣֤ͤreturnʸηϤͤηƱǤ롣ץ
ƽФηץֵͤηƱǤ롣(##24)

ʣˤ¾ʸ
ʸ(ExpStmt)ηϥڥɤǤ뼰ηƱǤ롣֥åʸ
voidǤ롣(##24)

ʣ˥٥
٥ɽϡ٥ȥ٥뻲ȤǻȤΤߤǤꡢ黻
оݤȤϤʤʤ٥ȥ٥뻲ȤηvoidǤ(##9)

ʣˤ¾ɽ
ʤȤɽnull (NullNode)voidȤ롣
     <null void>
ǿ׵ᤵnull񤫤ƤȤ褦ˡnull
¤äƤϡvoidǤäƤ⡢HIRλͤǻꤵƤС뷿T
ᤵ륪ڥɤȤƽ񤯤ȤǤ(##9)
¾嵭ƤʤHIRɽηvoidǤ롣

Ѵ(##21)

ѼˤƤϡڥɤη̤η˹碌ʤФʤʤ
ΤηѴconv黻ҤȤɤΤ褦ʾˤɤΤ褦˷
Ѵ뤫ϡϸλͤˤäƷޤ뤬ѴHIR-base
ݤ˹ԤHIR-baseǤϰۤηѴϹԤʤ(##21)
ηδ֤ˤϡshort int < int < long int < long long int Ȥ
դrankˤꡢʤ㤤⤤Ѵʾ夲
integer promotionˤΤȤϾη»ʤưη
֤ˤ⡢float < double < long double Ȥդꡢʤ㤤
⤤Ѵʾ夲ΤȤϾη»ʤ
boolѴȤϡfalse0true1Ȥʤ롣char
ʸɤɽѴǤ롣enumҤ⤽б
ɽѴǤ롣ҤʸѴȤϡν
ʸɤȤʸѴ롣ưδ֤ǤŪ
ѴˤäѴǤ롣
offsetͤsigned intޤsigned long intȸʤȤǤ롣
ξ硢ָʤȤǤפȤȤϡʣʿˤɽ
convˤѴƱǤ뤳Ȥ̣(##9)
ݥ󥿤ͤϵ(addressˤɽsigned int, signed
long int, unsigned int, ޤunsigned long intȸʤȤǤ
(##25)դʤоݵ˰¸뤬꤬ʤ
ʤȤߤʤ
̤ˡѱ黻ǥڥɤη碌Ȥϡʤξη
碌褦Ѵ뤬ϸʸˡˤѴ§ͥ褹롣ʤ
CHIR-baseѴȤϡCθͤ˽äơڥɤ
碌ʤɤѴŪ˹ԤʤʤФʤФʤʤ
convϴܷδ֤Ǥμ¼ŪѴԤʤФǤʤT1ؤݥ
pT2ؤݥ󥿤ȤߤʤȤ褦ʡѤ뤿
ˤ
     (conv  (PTR T2)
       (p (PTR T1)) )
Τ褦˻Ȥ(##24)
conv 黻Ҥˤꡢ Ts Υڥ x  Tr ѴƷ r 
ȤνˤĤơˤޤȤƵbool ˤĤƤ enum Ʊ
§ŬѤ(##24)ѴζƤϽǤ롣ɽǤϡ
intɽɽȤδ֤ѴˤĤƤϾάƤ
(##25)

Operand x   Result r   Conversion operation
   -------   --------   --------------------
   int       char       The character code of r is the value of x.
             enum       The order number of r is the value of x.
             offset     The value of r is the value of x.
             pointer    The value of r is the value of x. (##25)
   char      int        The value of r is the character code of x.
             enum       The order number of r is the character code
                        of x.
             offset     Same as (conv offset (conv int (x char))).
   enum      int        The value of r is the order number of x.
             enum       The order number of r is the order number of x.
             offset     Same as (conv offset (conv int (x Ts))).
   offset    int         The value of r is the value of x..
             enum        The order number of r is the value of x.
             pointer     If the value of pointer is signed  (##25)
                         then the value of r is the value of x.
            ;             If the value of pointer is unsigend (##25)
                         then the value of r is signed-to-unsigned
            ;             converted value of x.
   pointer   int        The value of r is the address represented
            ;            by x. (##25)
             enum       The order number of r is the value of x.(##25)
             offset     If address is signed
                        then the value of r is the value of x.
            ;            If address is unsigend
                        then the value of r is unsigned-to-signed
                        converted value of x.
             pointer    Address represented by r is the same to
                        the address represented by x.
                        Whether the internal representation of the
                        objects pointed by x can be treated as an
            ;            object pointed by r or not is programmer's
                        responsibility.

[[
(1) ۤηѴ
Ǥ˽Ҥ٤褦ˡϥץˤۤηѴϡHIR-base
Ǥϡ٤ŪʷѴȤɽ롣HIR-CμˤϰۤηѴ
Ƥ뤳Ȥ뤬HIR-baseǤϡCθͤHIR-base
ε˽äơ٤ŪѴɽ롣㤨Сchar
boolHIR-CǤintƱǤ뤬HIR-baseǤϤintȤ
ۤʤ뷿ȤƤΤǡڥɤη碌뤿ˡɬפ˱
ŪʷѴ򤷤ɽ
C
     int a, plus;
     plus = a > 0;
HIR-C
     (assign int
       <var int plus>
       (compGt int
         <var int a>
         <const int 0> ) )
HIR-base
     (assign int
       <var int plus>
       (conv int
         (compGt bool
           <var int a>
           <const int 0> ) ) )
(2) HIR-baseHIR-Cɽΰ㤤
HIR-baseǤϡchar, bool, enumintȤϰۤʤ뷿Ȥư
HIR-CǤϡCƱΰȤưޤHIR-C
ϡCƱݥ󥿤Фβøȥݥ󥿤θ
HIR-baseǤϡβøϥݥ󥿤ѴȤƲø
Ȥݥ󥿤θoffsetѴȤƸԤʤȤ
(##25)
(3) Ѽ
Cchar, unsigned char, bool, enumƤѿؿͤη
ϡHIR-CǤΰȤơѱ黻ΥڥɤȤƻȤ뤬
HIR-baseǤϡ򻻽ѱ黻intؤʤɡ׵ᤵ
ʸ̮ǻȤȤϡint, unsigned intؤŪʷѴԤդˡ
int, unsigned intcharbool, enumѿؤʤɡHIR-base
char, unsigned char, bool, enum׵ᤵʸ̮ǻȤȤϡ
HIR-base˹礦褦ŪʷѴԤʤ

C
     char a, b;
     a = 'a';
     b = a + 1;
HIR-C
     (assign char
       <var char a>
       (conv char
         <const int 97> ) )
     (assign char
       <var char b>
       (conv char
         (add int
           (conv int
             <var char a> )
         <const int 1> ) )
HIR-base
     (assign char
       <var char a>
       <const char 'a'> )
     (assign char
       <var char b>
       (conv char
         (add int
           (conv int
             <var char a> )
           <const int 1> ) ) )
(4) ݥ󥿼
HIR-CǤϡCƱݥ󥿤Ф黻롣p, qT
ؤݥ󥿤Ȥi, j, kȤȤHIR-CHIR-baseδ֤Ǥ
Τ褦ɽѴ򤹤롣ʰʲμǡp, qñѿǤʤŪʥ
󥿼ǤС<var <PTR T> p><var <PTR T> q>μɽɽ
֤롣
C
     p + i
HIR-C
     (add <PTR T>
       <var <PTR T> p>
       <var int i> )
HIR-base
     (add  <PTR T>
       <var  <PTR T> p>
       (mult  offset
         <const  offset s>      ssizeof T
         <var  int i>))
p-i Фɽϡaddsub֤ΤǤ롣
ǡsizeof T ϰ̤ˤoffsetȤɽ(##9)
C
     p - q
HIR-C
     (offset  offset
      <var  <PTR T> p2>
      <var  <PTR T> p1>)
HIR-base
     (div   int
      (sub   offset
       <var   <PTR T> p2>
       <var   <PTR T> p1>)
      <const   offset s>))      ssizeof T
  ]]

ͻ (##14)

ѿνͤꤹʸ
(setData ͼͻ)
ϡͼǼ뵭ͻǻꤵͤꤹ뤳Ȥɽ
魯κͼϺͤɽ魯Ǥꡢͻͻ
ꥹȡ뤤ͻη֤ɽ魯ΤǤ롣
ͻ -> (expList  ͻꡡͻꡡ )
(expRepeat ͻꡡȿ)
ͼ顼ѿͻ꤬ηŬ礹뷿ǤС
򤽤Υ顼ѿͤȤꤹ롣
(##24)
(expList ͻꡡͻꡡ )
ͻǤոĿ¤٤ꥹȤǤꡢ
(expRepeat ͻꡡȿ)
ͻȿˤǼ֤¤٤ꥹ
ɽ魯ǡͼnĤǤĥ٥ȥaǡͻ꤬n
ǤĥꥹȤɽʤС嵭aia[i]ͻ
iv_iФ
( setData a[i] v_i )
Ȥ뤳Ȥ򤹤٤ƤǤФƷ֤Ȥɽ魯ͼ n
ǤĹ¤sǡͻ꤬nĤǤĥꥹȤɽʤС
嵭sis_iͻiv_iФ
( setData s_i v_i )
Ȥ뤳Ȥ¤ΤΤ٤ƤǤФƷ֤Ȥɽ魯
ʸ(setData ... )ϡץμ¹ԳϤΩäꤹ
ͤꤹΤǤꡢץΤץˤ
ãȤꤹͤꤹΤϡʸʤ롼ʸȤɽ
롣(##24)

ץ໲ (##14)

ץ໲Ȥ
( call  ץ༰ꥹ )
ȤȤ뤬ץ༰ץؤΥݥ󥿤Ǥꡢ
ꥹȤϼΥꥹȤޤ϶ʥꥹȤǤ롣Ȥdoubleΰx
ʿdoubleǵؿsqrtθƤӽФ
     (call  double
      (addr <PTR <SUBP <double> false double>>
       <subp <SUBP <double> false double> sqrt> )
      (list
       <var double x>) )
ɽ蘆롣ʤΰꥹȤ϶ʥꥹȤǤ롣
ȤƱͤĥ鼰ꤹȡͤץ
롣ݥ󥿤ꤹȥݥ󥿤ͤϤ롣
ϤȤƤϡ
ƬǤؤΥݥ󥿤Ϥ
ؤΥݥ󥿤Ϥ
󤽤ΤΤϤϤ¦ޤϼ¦ǥԡƼϤ
Σब뤬HIRȤϸλͤ˽äHIRˤ
Ϥ롣ƬǤؤΥݥ󥿤ȤϤ줿Τ
Υݥ󥿤ȤƼ뤳Ȥ䡢դؤΥݥ󥿤ȤϤ줿
ƬǤؤΥݥ󥿤ȤƼΰ̣դϡ
Ȥ롣ΰϸˤäŪ뤳Ȥ˾ޤ
¤Τ䶦ΤϤȤƤ
¤Τ䶦ΤؤΥݥ󥿤Ϥ
¤Τ䶦ΤΤΤϤϤ¦ޤϼ¦ǥԡ
Ϥ
ȤˡꡢHIRȤϸλͤ˽äHIRˤ
Ϥ롣ݥ󥿤Ϥcall-by-referenceǤꡢ¤
䶦ΤΤΤϤΤcall-by-valueǤ롣
ץֵͤη¤Τ䶦ΤǤСreturnΥڥ
ɤȤƹ¤Τ䶦Τɽ魯ꤹ롣ξ硢ֵͤȤƤϡ
ꤵ줿¤Τ䶦Τ֤ͤ롣Τ֤Ȥ
ؤΥݥ󥿤ץϤץϤ줿
ͤ񤭹֤Ȥ뤬ȼHIRŪɽ
ʤФʤʤ(##24)
ؤΥݥ󥿤ǤϤʤΤȤϤȡ
ֵͤȤƼ뤳ȤˤĤƤϡޤ¸Ƥʤʬ
롣(##24)
[[
CˤؿƤӽФ
   int func( int a[3], int i ){
     return a[i];
   }
    ....
   r = func(aa, 2);
    ....
ФHIRϡǽҤ٤θξ(##24)Τ褦ɽ
Ƥ褤Ǥ˽Ҥ٤褦ˡǤϸ;aint
Υݥ󥿤ɽΤǤäơȤƤǿǤ뤳Ȥݾڤ
ʤȤαդɬפ(##25)
   (subpDef  void
    <subp  <SUBP <<PTR int> int > false int> func>
   <null  void>    // Initailization part.
    (labeldSt  void
     (list
      <labelDef _lab1>)    // Label generated by subpDefinition of HIR.
     (block  void
      (return  int
       (subs  int
        (undecay  <VECT 3 0 int>
         <var  <PTR int> a>
         <const  int 3>
         <const  int 0>)
        <var  int i> ))))     // (##22)
       ....
      (assign  int
       <var  int r>
       (call  int
        (addr  <PTR <SUBP <<PTR int> int > false int>>
         <subp  <SUBP <<PTR int> int > false int> func>)
        (list
         (decay  <PTR int>
          <var  <VECT 3 0 int> aa>)
         <const  int 2>)))
]]
[[  (##21)
FortranǤϡ°ϤƤФ¦Ϥ򤽤Τޤcall-by-
referenceȤƻȤˡȡ񤭼̤ƽ᤹ˡȤ롣ѿ
ϤϤϤؤΥݥ󥿤ϤǤϲ
ɽѿʣ̤ƻȤäƤ褤ͤѹϡreturn
˸ƤӽФ¦Υݥ˽᤹ɬפ롣ͤǤϡƱ³
ΣĤμ°˽Ťʤ꤬硢νŤʤäʬ˸ƤФ줿³
ǽ񤭹ǤϤʤȤƤΤǡξԤƱ̤⤿餹ϤǤ
롣Ťʤ̵ͭ򥳥ѥ˸ФȤСϥեǹ
ΤȤ롣ؤΥݥ󥿤ȤƼäϡundecay
ơsubsˤꤽǤإ롣ȤС
   PROGRAM SIMPLE
   INTEGER AA(10), BB(3, 5), CC, DD
     ....
   DD = F(AA, BB, CC)
     ....
   END
   FUNCTION F( A, B, C )
   INTEGER A(10), B(3, 5)
   INTEGER I, X
     ....
   X = C + A(I)
   B(2, 3) = X
   C = C + 1
   RETURN X
   END
ФƤϡ
  (prog           // PROGRAM SIMPLE
   <sym SIMPLE>  // program name
   <nullNode >    // initialization part
   (subpDef void
    <subp <SUBP <> false int> SIMPLE_MAIN>
            ;       // generated subprogram name
    <null void>    // initialization part
    (labeldSt  void
     (list
      <labelDef _lab1>)    // Label generated by subpDefinition of HIR.
     (block    // subprogram body
     ....
      (assign int    // DD = F(AA, BB, CC)
       <var int DD>
       (call int
        (addr <SUBP <<PTR <VECT 10 1 int>>
                     <PTR <VECT 5 1 <VECT 3 1 int>>>
                     <PTR int>> false int>
         <subp <SUBP <<PTR <VECT 10 1 int>>
                      <PTR <VECT 5 1 <VECT 3 1 int>>>
                      <PTR int>> false int> F>)
        (list     // argument list
         (addr <PTR <VECT 10 1 int>>  // Change to array pointer.
          <var <VECT 10 1 int> AA>)
         (addr <PTR <VECT 5 1 <VECT 3 1 int>>>
          <var <VECT 5 1 <VECT 3 1 int>> BB>)
         (addr <PTR int>  // Change to scalar pointer.
          <var int CC>))))
     ....
     (return void )
    )))
   (subpDef void
    <subp <SUBP <<PTR <VECT 10 1 int>>
                 <PTR <VECT 5 1 <VECT 3 1 int>>>
                 <PTR int>> false int> F>
     <null void>  // Initialization part
     (labeldSt  void
      (list
       <labelDef _lab1>)    // Label generated by subpDefinition of HIR.
      (block void
       (assign int   // Copy the contents of the pointed argument
            ;         //  to _var1.
        <var int _var1>
        (contents int
         <var <PTR int> C>))
       (assign int
        <var int X>        // (##25)
        (add int
         <var int _var1>
         (subs int
          (contents <VECT 10 1 int>      // (##22)
           <var <PTR <VECT 10 1 int>> A>)
          <var int I>)))
      (assign int
       (subs int
        (subs <VECT 3 1 int>
         (contents <VECT 5 1 <VECT 3 1 int>>       // (##22)
          <var <PTR <VECT 5 1 <VECT 3 1 int>>> B>)
         <const int 3>)
        <const int 2>)
       <var int X>)
      (assign int
       <var int _var1>
       (add int
        <var int _var1>
        <const int 1>))
      (assign int    // Copy back _var1 to the pointed argument.
       (contents int
        <var <PTR int> C>)
       <var int _var1>)
      (return int
       <var int X>)
    )))
  )
Τ褦HIRФ褤CǤcall裱ץؤ
ݥ󥿤Ȥ뤬FortranǤϤץ൭Ȥ뤫ץ
ؤΥݥ󥿤Ȥ뤫ϡǤ(##25)
ȤϤȤϡϤϤ⡢ͤȤ
ѿơϤϤ褤Сͤ
ȤץΰƶɻߤǤ롣
嵭ϣĤμ¸Ǥäơͤ˹äӤǤ
СΤۤˡǤ˺٤ʤ
]]  (##21)

----------
ܤʤѸ
void  (##25)
address (¸ʬ)  (##25)
ʸʸΤ֤  (##25)
źindexɽ(##21)
cast黻  (##10)
