2012-06-04 14:58:17 +00:00
MZ� ´ ¸
$
ÁÐȘÁµ � w ´ ´ ‹ � ~ � � QhLuE � QhPuE � QhTuE ‹ ‹ ‹ � Rh`uE � R‹EüPè£ ‹ ‹ ‹ � QèÇ � QhxuE
� S ‹
hXvE ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
¸ � ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � M ‹ � L ‹ � S ‹ ‹ ‹ ‹ ‹
¸ ‹ ‹ ‹ ‹ ‹ ‹ ¸ � A ‹ ‹ � > ‹ ¸ � ÷ÿÿƒÄ ¸ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � þÿÿƒÄ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � ‹ ‹ � @ � < ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ˜ ‹ ‹ ‹ ‹ ‹ � 2 ‹ ‹ ‹ ‹
0 ‹ ‹ ‹ � T
! ‹ ‹ ‹ ‹ ¸ ‹
‹ ‹
� ~E � ‹
� � HF ‹ � —F � �
´ ‹ ‹ ‹ � } ‹ ‹ ‹ � ú@ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � } � }ìîØÿÿtV� }ìïØÿÿt� }ìðØÿÿt � L � } ‹ ‹ � } ‹ ‹ ‹ ‹ ‹ ‹ � } ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � }ühgD
‹E
üÿÿƒÄ � EðP‹MìQè±°
‹ ‹
‹E � Uð‰Uè‹E � UðR‹ ‹
§ ‹ ‹
‹U � Uð‰Uè‹E � UðR‹ ‹
¦ � ìÿÿƒÄ � ˜ ‹ ‹ ‹ ‹ ‹ ‹ � UôRhÀs@ ‹ ‹ ‹ ‹ ‹ � UôRh0t@ ‹ ‹ ‹ � UìR‹ � UìR‹E ‹
‰Müé£ �
‰Mô‹Uø‹Eô;BDw‹
‹MøÇA@ ‹ ‹ ‹ � åÿÿƒÄ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � EøP‹M ‹ � D
‹ ‹ ‹ � ‹ � UôR‹E � E� Pj ‹ ‹ ‹ � U� Rh€IG ‹ � ^ ‹ ˜ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � E� P‹M ‹ � E� PhäIG ‹ � E´ ‹ � E
ëÿÿƒÄ � çÿÿƒÄ ‹
ÚÿÿƒÄ � } � T
� ‹M � ì � � èýÿÿQ‹U � � èýÿÿQèè � …èýÿÿPè5 � äýÿÿ‰M � …èýÿÿPè � � èýÿÿQè5
áÿÿƒÄ ‹ ‹
‹E
} � Â
‹E � UüRjÿ‹EôPèÒÛÿÿƒÄ
jþ‹EôPè � } � T � } � T � ì � ôýÿÿQè•Ú
t
u
€JG � èýÿÿ � äýÿÿQhŒJG
”JG � èýÿÿt � •ðýÿÿRh0� @ � ôýÿÿQèµÖ � äýÿÿQ‹U � EøPh`Ž@
‹UüÇB � @ � @ � ž � Ý
j� ðÿÿƒÄ
uIj � UôR‹EðPè¨å ‹ � E� P‹MüQ‹U � M� Qh¬KG � EøPj � ÿÿÿƒÄ � åÿÿƒÄ � ¾ÿÿƒÄ � ËÿÿƒÄ � ¾ÿÿƒÄ
¸ ‹ � I � @ � @ � @ � @ � @ � U� Rj ¸ � þÿÿƒÄ ‹ � ¹ÿÿƒÄ � cD ‹ ‹ ‹ � T� ü‰Uü‹Eü‹ � âÿ ‹ ‹ � L‹ ‹ ‹ � L
ÿÁá� á � T � UøR‹E ‹ � ‹å]ÃÌÌÌÌÌU‹ìƒì � � âÿ? � áÿÿ � éÿÿ
‹Uü‹E � D � � } � âÿ � á?Àÿÿ‹U� âÀ? � âÿ � áÿ � � á€
‹Eüƒè
‹M ‹ � }üú ‹ ‹ � Eð‰Eì‹Mì‹U � MðQ� UðR‹E
‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � Eð‰Eì‹MìÝE � EðP� MðQ‹U
u=‹M � á
‹U � � âÿÿ � âÀ?
u+‹M � Áé� áÿ
‹ ‹ � ‹ ‹ ‹ ‹ ‹ ‹ � I ‹
u
u ÇEìÿÿÿÿë ‹ � � ‰Mü‹Uü‹� áÀ? ‹ ‹ ‹ ‹ � I � ³@ � ³@ � ³@ � ³@ � ³@ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � x(ÿ � €
� z
‹ ‹
� Eð‰Eì‹Mì‹U � MðQ� UðR‹E � Eà‰EÜ‹MÜ‹U � UðR� EàP‹M ‹ ‹
‹ ‹
� üÿÿƒÄ � ¸@ � á?Àÿÿ‹Uü‹
‹å]ÃÌÌÌÌU‹ìQ‹E ‹ ‹ ‹ ‹
‹ ‹ � UèR‹E ‹ ‹ ‹ ‹ � EèP‹M � ‹ ‹ ‹ ‹ � »@
é¹ � ÷ÿÿƒÄ‹ � â½@ � I � çÿÿƒÄ � ,Ã@
‰ ‹ ‹ � � âÿÿ � á � ‹U ‹ ‹ ‹ ‹ ‹
‹M � ‹ ‹ ‹ ‹ ‹ ‹ ‹ � èÁ@
ñÿÿƒÄ
� ü]ÃÌÌÌÌÌÌU‹ì‹E ‹ ¸ ‹ ‹ ‹ ‹ � }øÿ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � ·ÿÿƒÄ � EŒP‹M � E� P‹MŒƒÁ ‹ � � M� Q‹UˆR‹E„Pè ‹ ‹ � M´ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ˜ ¸ ‹ ‹ � � ÿÿƒÄ � ÿÿƒÄ � ÿÿƒÄ � EŒP‹M� U� R‹EŒƒÀ � M� Q‹U„RèÊ � EŒP‹M� U� R‹EŒƒÀ
� ÿÿƒÄ � M� Q‹UˆRèB � ÿÿƒÄ � EøP‹M � ÿÿƒÄ � ÿÿƒÄ
ÿÿƒÄ � ÿÿƒÄ � ÔcD � ÿÿƒÄ � ›ÿÿƒÄ � EðP‹M � }èpÏ@
h,QG � MôQ‹UìRèF � � ì � …øþÿÿP葨 � � øþÿÿQèx… � � •øþÿÿRèI� � …øþÿÿP‹M � ÿÿƒÄ � ì€ � EŒP‹M� ÿÿƒÄ ‹ � M� Q‹U€R‹E„Pèb � U� R‹
P‹M„Qè. � M� Q‹UüƒÂ
R‹E„Pèõ � E� PhŒQG ‹ � U´Rh� QG ‹ � M´QhÀQG ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � ÿÿƒÄ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � R‹EôP‹M ‹ ‹ ‹
‹ � RG ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � áÿ � Û � áÿ ‹ � áÿ � áÿÿ � T ‹ ‹
‹EØÁè � ဠ‹ ‹ ˆ ‹ � T ‹ � D
� } ‹ � D
ÿ‹M ‹ � L� � D
ÿ‹M ‹
ƒ}È � } � D
ÿ‹M � â@
ÌÌÌÌÌÌÌÌÌÌÌÌU‹ì‹E� ùú ‹ ‹ ‹ ‹ ‹ ‹
‹ ‹ ‹ ‹ ‹ � áÿþÿÿ‹U ‹ ‹ � ‰Uü‹Eüƒà?ƒø � áÿ
¸¼RG
¸ÄRG � áÿ � áÿ � âÿ � áÿ � áÿþÿÿÁá � áÿþÿÿÁá � ðjD � EøP‹M ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � EðP‹M
& ‹ � ðjD � ðjD ‹ ‹ ‹ ‹ ‹ � E � E¸Pèê‹ � E¸Ph� SG � ‹ � � î@ � î@ ‹ ‹ ‹ � ‹ ˆ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � x0 N ‹ ‹ ‹ � ú N � E¸‰Bp� M¼j � ‹ � úªªª
w)‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � D ‹ ‹ ‹ ‹ � ù@ � Á@ ‹ � UˆR‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
‹E � Á@ � x0 N ‹ � z0 N ‹ ‹ ‹ ‹ ‹ ‹ � È
‹ ‹ ‹ ‹ ‹ � ùÈ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
‹M ‹ ‹ ‹ ‹ ˆ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � MìQhÐ ‹ � � MìQè � UìRj ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � UÿRè ‹ ‹ ‹ ‹ ‹ ‹ � M � UüRèFÿÿÿƒÄ � EøPè&ÿÿÿƒÄ � … ‹ ‹ ‹ � M ‹ ‹ ‹ � EðPè÷ � UðRèEüÿÿƒÄ � X � � � Y
‹MüQ‹U ‹ ‹
‹Uð ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � L
‹Uôƒz0
‰
‹Eô‹H0‹Uü‹
‰ � ‹ ‹ ‹ ‹
‰Eüƒ}ü � xL �  � ê �
� ‹ ‹ ¸
¸ � � I � � � áû � D � ‹ ‹ � D
xëa‹Uü‰Uì‹E � D‚L‹Mì‹Q(Áâ� � ‹Mì‹Q8kÒ � � ë� f ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
¸ ‹ ‹
‹M � áü ‹ ˆ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � I ‹ ‹ ‹ ‹ ‚ � âü � ˆQ ‹ ‹ ‹ ˆ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � áü
� ‹ ‹ � y0 N ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � ˜ � âø
‹MôÇA � áü ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � áø � áû
‹Uü‹E ‹ ‹ � áø
CÿÿƒÄ ‹ ‹ ‹ ‹
hTUG ‹ ‹ ¸ ‹
‹ ‹ ‹ ‹ ‹ � ¤dD ‹ ‹ ‹ � EøPh UG ‹ � ì � …èýÿÿP‹M� VÿÿƒÄ� •èýÿÿRèÎSÿÿƒÄ � äýÿÿQèáH � •èýÿÿRèmUÿÿƒÄ
t� èýÿÿ� T� …èýÿÿPèéTÿÿƒÄ � ì$ � …èýÿÿP‹M� UÿÿƒÄ � •èýÿÿRè´RÿÿƒÄ� äýÿÿ‹U � àýÿÿQèÈ6 � äýÿÿt“� •èýÿÿRè
Ç…Üýÿÿ ‹ ‹ � MðQ‹U ‹ � ÌdD � ÷ÿÿƒÄ � 9A ‹ ‹ � .ÿÿƒÄ � ˜eD
† � } ‹ ‹
‹M � ”aD � U¨RèÛ= ‹ ‹ ‹ � E¨PhôWG ‹ ‹ ‹ ‹ ‹ ‹ ‹ � }ü � }ü ‹ ‹ ‹ ‹ ‹ � z ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � x � ‹ ‹ ‹ ‹
¸- ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
tq‹
ti‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
‹
úÿÿƒÄ
ƒé‹ ‹
…Àv&‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ¸ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ¸ ‹ ‹ ‹ ‹ ‹ ‹
ƒé‹ ‹
…Àv&‹ ‹ ‹
ƒé‹ ‹
…Àv&‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
‹ ‹ ‹ ‹ ‹
¸ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
ÌÌÌÌU‹ìƒì ‹ ‹ ‹ ‹
t‹
ui‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � x ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
‹Uø‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � ö ‹ ‹ ‹ ‹ ‹
t‹
u � ,RA ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
‹U
‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � D‹ ‹ ‹ ‹ ‹ � D
� ëÿÿƒÄ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � àWA
�
‹U ‹ ‹ ‹ ‹ ‹
‹M� D
ƒé‹ ‹
…Àv&‹ ‹ ‹ � }üÿ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � I � SA ‹
ÿÿƒÄ
ÿÿƒÄ
ÿÿƒÄ ‹
ÿÿƒÄ ‹
ÿÿƒÄ ‹
ÿÿƒÄ � EðPj
ÿÿƒÄ
ÿÿƒÄ
ÿÿƒÄ
ÿÿƒÄ
ÿÿƒÄ
‹
ÿÿƒÄ � EüPj
ÿÿƒÄ ‹ ‹
"ÿÿƒÄ � sG �
ÿÿƒÄ
ÿÿƒÄ ‹ ‹ ‹ ‹ ‹ ‹ � ‹ÿÿƒÄ ‹ ‹ ‹ � ìˆ � …xÿÿÿPj ‹ � •xÿÿÿR‹E � ZG ‹ ‹ ‹ ‹ �
õþÿƒÄ � ýþÿƒÄ
� îþÿƒÄ � E� Pj � U� Rhh\G � ðþÿƒÄ
ÿÿƒÄ ‹ ‹ ‹ ‹ ¸ ‹ � ì � � ðþÿÿQj � …ðþÿÿPè‹1 � …ðþÿÿPhlZG � � } ‹ ‹
3Ò; � ÃtA � EüP‹M ‹ � UüR‹E ‹ ‹ � UìR‹E
‹ � EÈPèF0 � MÈQ‹ � EÄP‹M � I ‹ � E ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � EìPè:
� UìR‹E �
ëþÿƒÄ � ìü � � � MðQèF � EðPèL ‹ � _G ‹ ‹ ‹ ‹ ‹ � Âl ‹ � � ØýÿÿQ‹U � Mä9� Øýÿÿr� •ØýÿÿRèª� UìRhÈ � … � � •� …ØýÿÿPè| � � ØýÿÿQèø ‹ ‹ ‹
� MÔQèL � ì� � •pýÿÿR‹E� � ¸ýÿÿQ� •pýÿÿRèÌ � � pýÿÿQèCºÿÿƒÄ� •pýÿÿRè„ � …pýÿÿPè0 � � pýÿÿQèñ � `G ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
‹UôÇB ‹ ‹ ‹ � x ‹ � y ‹ ‹ ‹ ‹
‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � ùÈ � é � ‹A � é � A � A
� '
²ÿÿƒÄ � úŒA � A ‹ � UôR‹
‹ ‹ ˆ ‹ ‹ ‹ ‹ ‹ ‹
…Òu � UðR‹EèPèHþÿÿƒÄ � EèP‹M � UèR‹E‹
'ÿÿƒÄ ‹ ‹ ‹ ‹ ‹ � UØR‹E � MØQ‹U � }ø£ � €“A ˆ ‹ ‹ � � I ’ ‹
‹MÌQèV/ÿÿƒÄ � MØQè8ÿÿÿƒÄ ‹ � MØQ‹UÌRèy ‹ � }È � MØQ‹U � EØP‹ � UØR‹E � MØQ‹U � MØQ‹UÌRè � æÿÿ � æÿ?€ÿ‹MôQè\ÝÿÿƒÄ ‹ ‹ � z ‹ � x � UèR‹E � MèQ‹U ‹ � MèQ‹UÈRèk � EÐP‹M� UÐR‹EÈPèH ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
t‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � z ýÿÿ � ìH � …¸ýÿÿP‹M � …¸ýÿÿP‹M ‹ � T� úÈ ‹ ‹
‹ ‹ ‹ � 'ÿÿƒÄ ‹ ‹ ‹ � }ð � }ð
üÿÿƒÄ ‹ � }Äö � MàQ‹U� EàP‹M � žÿÿƒÄ� MÈQ‹U� ÷ÿÿƒÄ� EÈP‹M � I � UèR‹E� MèQ‹U � }Ô ‹ � UèR‹ � MèQ‹UÜRè„
ÿÿƒÄ � UèR‹E� EèP‹M
2011-10-03 18:41:19 +00:00
t � EèP‹MÜQè� � ÿÿƒÄ
‹U � }ø ¸ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ˆ ‹
‹Mü‹ � }ü � }üö
2012-06-04 14:58:17 +00:00
� EèP‹MäQè“ãÿÿƒÄ � UôR‹EäPè� ãÿÿƒÄ � âÿÿƒÄ � UðR‹EìPè’âÿÿƒÄ � }è ‹ ‹ ‹ ‹
hÈbG � EàP‹M� EàP‹M � UìR‹EøPèüßÿÿƒÄ � ßÿÿƒÄ ‹
hðbG ‹ � EØP� MØQ‹U � úþÿƒÄ
t � x � UôR‹EøPèåøþÿƒÄ � y � EôP‹MøQè›øþÿƒÄ � MôQ‹UøRè]øþÿƒÄ
� EèPèTáÿÿƒÄ � UÐR‹E� MÐQ� UèR‹EÌPèë
×ÿÿƒÄ� MàQ‹U � EàP‹MøQ‹UüR‹E� MèQ‹U � UÐR‹E� MÐQ� UèR‹E � UèR‹E
u*‹MÜ‹ � âÿ?€ÿ� Ê � UàR‹E ‹ ‹ � UÐR‹E� MÐQ‹U ‹ ‹ ‹ ‹ � EÈP‹M � EèP‹M� EèP‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � UèR‹E� UèR‹E � EèPèmÝÿÿƒÄ � MèQ‹U ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � MØQ‹U
t� EØP‹MøQè9õþÿƒÄ
u(ƒ}ô � UØR‹EøPèRûþÿƒÄ� MØQ‹UøRèm÷þÿƒÄ ˆ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � L � L
‰H ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � ˆ ‹ ‹ ‹ ‹ � ˜ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � � ‰
‹� ‰Uðë ‹
� y � EüPj� »þÿƒÄ � EðPj � � D
ÿP‹M
‹ � T � ì � …äýÿÿPj � •èýÿÿR‹E� äýÿÿ‹•äýÿÿƒê� Eô9…èýÿÿr� � èýÿÿQèÂÀþÿƒÄ
ˆ� …èýÿÿPè_ÂþÿƒÄ � ì$ � …ÜýÿÿPj � •àýÿÿR‹E � Eì9…àýÿÿr� � àýÿÿQèþ¿þÿƒÄ � àýÿÿˆ� …àýÿÿPè”ÁþÿƒÄ � ì$ � …ÜýÿÿPj � •àýÿÿR‹E � Eì9…àýÿÿr� � àýÿÿQè.¿þÿƒÄ � àýÿÿˆ� …àýÿÿPèÄÀþÿƒÄ � ì$ � …ÜýÿÿPj � …àýÿÿP‹M � ÜýÿÿQ‹UøR� …àýÿÿPèš¿þÿƒÄ � � àýÿÿQè � EèPj � ì$ � � àýÿÿQ‹U � Üýÿÿ;� Üýÿÿt � Mì9� àýÿÿr� •àýÿÿRè� ¼þÿƒÄ� Üýÿÿˆ� …àýÿÿPè/¾þÿƒÄ � ì � •èýÿÿR‹E� � èýÿÿQh� ÊA � � èýÿÿQ蓽þÿƒÄ � ì< � EøPj � UìRj
Ç…Äþÿÿ � Ìþÿÿ‹U� ÔþÿÿÇ…Üþÿÿ � � ÐþÿÿQèÀ � Èþÿÿ+MðQ‹U � …ÐþÿÿPè � ÈþÿÿQ‹•ÌþÿÿR� …ÐþÿÿPèõ � Ìþÿÿ‹•Ôþÿÿ‹…ÌþÿÿƒÀ
ƒ}ä ‹
‹E ‹ � ˜ÐA ‹ ‹ ‹ ‹ ‹ ‹ � � � �
‹ � � I
ÌÌÌÌÌÌU‹ìQ‹E ¸ ‹
‹Müƒé ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹
‹E
‹ ‹
‹E � ‹ ‹ ‹ ‹
‹Eüƒè ‹ ‹ ‹ ‹ ‹ ‹ � � þÿƒÄ � þÿƒÄ � þÿƒÄ � þÿƒÄ � ì( � …äþÿÿPhíØÿÿ‹M � èþÿÿ‹Uø� àþÿÿƒÁ� àþÿÿ‹•àþÿÿ;•ìþÿÿ � àþÿÿQ� •èþÿÿRè×ñÿÿƒÄ � Üþÿÿ;� àþÿÿu� àþÿÿQ� •èþÿÿRè � ìL � …ÄüÿÿPj � ÄüÿÿƒÁ
Ç…´üÿÿ � •ÈüÿÿR‹E� èþÿÿ‹•¼üÿÿ‰•àþÿÿ‹…¼üÿÿ� Àüÿÿ� ï � � àþÿÿQèÏïÿÿƒÄ � ¼üÿÿQ� •ÈüÿÿR� …àþÿÿPèó � ¸üÿÿ;� ¼üÿÿv� � Ôþÿÿ9� Èüÿÿr� •ÈüÿÿRèc¨þÿƒÄ� ¼üÿÿŠ� ¼üÿÿƒÁ� ¼üÿÿë
ƒ}ô � � ÈüÿÿQèA©þÿƒÄ � •ÈüÿÿRè©þÿƒÄ � Øþÿÿ3ÍèR� � þÿƒÄ � °ßA ‹ � þÿƒÄ � þÿƒÄ � ÞA � EøPj � Á ‹
r ‹
¦þÿƒÄ
‹U � � Â
ëT‹Eô � ì\ � EøP‹MüQ‹U � � àýÿÿQ‹U� §þÿƒÄ � Øýÿÿ� Eì9…àýÿÿr� � àýÿÿQ裤þÿƒÄ
‹•àýÿÿƒÂ � ØýÿÿƒÁ� Øýÿÿ‹•Øýÿÿ� Mì9� àýÿÿr� •àýÿÿRè9¤þÿƒÄ� ØýÿÿŠ� ØýÿÿƒÁ� Øýÿÿéj � …ÄûÿÿP‹� ØýÿÿQ‹U � ¸ûÿÿ‹•ØýÿÿƒÂ� ´ûÿÿƒéE‰� ´ûÿÿƒ½´ûÿÿ3 � þÿƒÄ � …ÄûÿÿP� � ØûÿÿQèZÅ � � •ÄûÿÿRès � þÿƒÄ � •ÄûÿÿR� …ØûÿÿPè � � ÄûÿÿQè3
� ¤ûÿÿQ� •ÄûÿÿR� …ØûÿÿPè¯Ä � …ÄûÿÿP� � ØûÿÿQè„Ä � …àýÿÿP‹M � •¼ûÿÿR‹EüP‹M � •ÄûÿÿRè‚} � •àýÿÿRè � � ÄûÿÿQ� •ØûÿÿRèåà � …ØûÿÿPèÓ{ � � ØûÿÿQ� •àýÿÿRèÜ¢þÿƒÄ � …àýÿÿPèX£þÿƒÄ � EøP‹M � æA �  � Á
2011-10-03 18:41:19 +00:00
r
2012-06-04 14:58:17 +00:00
‹U ‹ � Á
r
‹U � ‰ � D
� T � ˆ � D ‹ ‹ ‹ ‹ � h$fG � kìA � M � UøRèFl � ø‰Uøëâ‹E � x ‹ ‹ ‹ � È
� ùÿÿÿ � }ð€jD � ùÿÿÿ
pÿÿƒÄ � x ‹ ‹ ‹ ‹ ‹ ¸ � €ÿÿƒÄ � }ühgD ‹ ‹ ‹ ‹ ‹ ‹
� }ü€jD ‹ � ì„
‹MüÇD� ˆ � UˆR‹E � |ÿÿÿ� U€R� EˆP‹M � UˆR‹E � |ÿÿÿƒÁ� |ÿÿÿ� U€R� EˆPè4 � |ÿÿÿ+M„Q‹U€R‹E � ‹ � ‰Mü‹Eì™+ÂÑø9Eü~ � }ü � D‚ � ‚ � � ‹Mü � }ühgD � Uè‰UäÛE � UèR‹E � }ühgD � Uè‰Uä‹Eä‹M � EèP‹M � x � } � þÿƒÄ � þÿƒÄ � ~þÿƒÄ
ëk‹Eü‰Eøëvj � þÿƒÄ � ì( � EôPhW‡G � Øýÿÿ‰Mü� •àýÿÿR‹E� � àýÿÿQ‹U � ÜýÿÿQ� •àýÿÿR褆þÿƒÄ � •àýÿÿR‹E � � àýÿÿQè � ‹
� XþÿƒÄ ‹ ‹ ‹ ‹ ¸ � kD � ˜
‹ � EðPèž � UðRè ‹ ‹ � ùÈ ‹ � ‹ ‹ � EÿP‹M
� EüP‹M � EüP‹M � ùÿÿÿ?w � ùÿÿÿ � Ì � � úÿÿÿ?w � º
B
B � EøP‹M � ùÿÿÿ?w
� ùÿÿÿ?w � EðPèW � MäQ‹U � EäP� MðQè5¿ ‹ � UøR‹E � UÔRèå• ‹ � MÔQèðM � UÔR‹E � ‹ ‹ � V ‹ ‹ ‹
‹ ‹ ‹ � F
‹Uè;Uðu
3Ò;
¸
¸
3Ò; ‹ ‹ ‹ � D ‹ � Úýÿÿ‹å]ÃU‹ìQ‹E � ìð ‹ ‹ ‹ ‹ ‹ ‹ � ýÿÿƒ½ ýÿÿ% � áÿ
‹EÔÇ@ � áÿ � áÿ � � âÿÿ � E°‰E¨‹M¨‹Uð‹B � E°P‹M � áÿ � áÿþÿÿÁá� œýÿÿë� âÿ � œýÿÿQ‹UìÁê� âÿ � E˜‰E”‹M”‹Uð‹B � âÿÿ � E˜P‹M � áÿ � ‹Mè‰Mˆ‹U� ‹B‹ ‹ � � Q‹U � âÿ � â � áÿ � ˜ýÿÿ‹UìÁê� âÿ � â � áÿ � ”ýÿÿ‹•˜ýÿÿR‹…”ýÿÿP‹MèQ‹U � âÿ � |ÿÿÿ‹U€RèòOÿÿƒÄ ‹ ‹ ‹ ‹ ‹ ‹
îþÿƒÄ � âÿ � tÿÿÿ‹•pÿÿÿ‹� pÿÿÿ‹Q� âÿ � â � ýÿÿë� áÿ � � ýÿÿ‹UèR‹…� ýÿÿP‹� xÿÿÿQ‹U � âÿ � â � áÿ � Œýÿÿ‹•Œýÿÿ‰•hÿÿÿ‹EìÁè � áÿ � áÿþÿÿÁá� ˆýÿÿë� âÿ � hÿÿÿƒy � Xÿÿÿ‹� lÿÿÿÝ� `ÿÿÿ‹U艕TÿÿÿÝ…XÿÿÿÜ…`ÿÿÿ‹…TÿÿÿÝ� TÿÿÿÇA � lÿÿÿQ‹•hÿÿÿR‹EèP‹M � áÿ � á � âÿ � âÿþÿÿÁâ � „ýÿÿ‰� Lÿÿÿ‹UìÁê� âÿ � â � áÿ � €ýÿÿ‹•€ýÿÿ‰•Pÿÿÿ‹…Lÿÿÿƒx� Pÿÿÿƒy� 8ÿÿÿ‹…PÿÿÿÝ � @ÿÿÿ‹Mè‰� 4ÿÿÿÝ…8ÿÿÿÜ¥@ÿÿÿ‹•4ÿÿÿÝ � LÿÿÿQ‹UèR‹E � áÿ � áÿþÿÿÁá� |ýÿÿë� âÿ � áÿ � á � âÿ � âÿþÿÿÁâ � xýÿÿ‰� 0ÿÿÿ‹•,ÿÿÿƒz� ,ÿÿÿÝ� � ÿÿÿ‹E艅� ÿÿÿ‹� � âÿ � â � áÿ � týÿÿ‹•týÿÿ‰• � áÿ � áÿþÿÿÁá� pýÿÿë� âÿ � � øþÿÿ‹� � � ôþÿÿÇA � � áÿ � á � âÿ � âÿþÿÿÁâ � lýÿÿ‰� ìþÿÿ‹UìÁê� âÿ � â � áÿ � hýÿÿ‹•hýÿÿ‰•ðþÿÿ‹…ìþÿÿƒx� ðþÿÿƒy� Øþÿÿ‹…ðþÿÿÝ � àþÿÿ‹Mè‰� ÔþÿÿÝ…Øþÿÿܵàþÿÿƒì � àþÿÿÜØþÿÿ‹•ÔþÿÿÝ � ìþÿÿQ‹UèR‹E � áÿ � áÿþÿÿÁá� dýÿÿë� âÿ � áÿ � á � âÿ � âÿþÿÿÁâ � `ýÿÿ‰� Ðþÿÿ‹•Ìþÿÿƒz� ÌþÿÿÝ� ¸þÿÿ‹•ÐþÿÿÝ� Àþÿÿ‹E艅´þÿÿƒì � ´þÿÿÝ
‹•ÐþÿÿR‹…ÌþÿÿP‹MèQ‹U � âÿ � °þÿÿÝ� ¨þÿÿ‹U艕¤þÿÿÝ…¨þÿÿÙà‹…¤þÿÿÝ� ¤þÿÿÇA � °þÿÿQ‹•°þÿÿR‹EèP‹M � áÿ
� âÿ
Ç…\ýÿÿ � \ýÿÿ‰� þÿÿ‹U艕œþÿÿ‹…œþÿÿ‹� þÿÿ‰ � ˜þÿÿ‹Q� � ˜þÿÿ‹� ”þÿÿÇA � � þÿÿ‹…˜þÿÿ‹ � þÿÿÝ� � þÿÿÇA � ˜þÿÿQ‹U � âÿ � ˆþÿÿ+� ŒþÿÿƒÁ � €þÿÿ‹� „þÿÿ‰� âÿÿ � Œ� � âÿ � â � áÿ � Hýÿÿ‹•Hýÿÿ‰•xþÿÿ‹EìÁè � áÿ � áÿþÿÿÁá� Dýÿÿë� âÿ � |þÿÿ‹P� xþÿÿQ‹U
Ç…@ýÿÿ � âÿÿ � Œ� � áÿ � á � âÿ � âÿþÿÿÁâ � áÿ � á � âÿ � âÿþÿÿÁâ � <ýÿÿQ‹•8ýÿÿR‹E � áÿ � ”� � âÿ � â � áÿ � 4ýÿÿ‹UìÁê� âÿ � â � áÿ � 0ýÿÿ‹•4ýÿÿR‹…0ýÿÿP‹M � âÿ � áÿÿ � „Š
Ç…,ýÿÿ � áÿ � ,ýÿÿt � ”� � áÿ � tþÿÿ‹•tþÿÿƒz � tþÿÿƒ9
Ç…(ýÿÿ � âÿ � pþÿÿ‹•lþÿÿ‹� lþÿÿ‹Q� áÿÿ � „Š � âÿ � hþÿÿÁá
� `þÿÿÁá � Tþÿÿ‹•\þÿÿ‹B � \þÿÿ� \þÿÿ‹ � PþÿÿÁá� Xþÿÿ‹U� PþÿÿÁá� Tþÿÿ‰� Lþÿÿ‹•Hþÿÿ‹� Hþÿÿ‹Q � \þÿÿ‰A � áÿ � Dþÿÿt� L � 0þÿÿ‹MèÝ� 8þÿÿ‹UèÝB� (þÿÿÝ…0þÿÿÜ � 8þÿÿßàöÄ
Ç… � (þÿÿßàöÄ
Ç… � � � âÿÿ � Œ� � $þÿÿÇA � þÿÿÇA � � � � � � ”� � � � üýÿÿ‹• � � ôýÿÿ‹• � øýÿÿ‹•ôýÿÿ‹B� � âÿ � âÿ � L� � � ðýÿÿ‹•ìýÿÿ‹� ìýÿÿ‹Q� áÿÿ � „Š � âÿ � Üýÿÿƒé� àýÿÿ‰� äýÿÿ‹•èýÿÿ‹…äýÿÿ;B � äýÿÿQ‹•èýÿÿR‹E � àýÿÿƒé� àýÿÿƒ½àýÿÿ � äýÿÿ‰� � Ôýÿÿ‹•Ðýÿÿ‹B� Øýÿÿƒy� èýÿÿQ‹U � áÿÿ � Ìýÿÿ � Äýÿÿ‹•Ìýÿÿ‰Q � Àýÿÿ‹•Äýÿÿ‹uð‹D†� âÿ � Àýÿÿ‹•Äýÿÿ‰DŠ� ¼ýÿÿ‹•Äýÿÿ‰ ‹ ‹ � âÿ � ´ýÿÿ‹•´ýÿÿ‹…´ýÿÿ‹
+H� ¸ýÿÿƒ½°ýÿÿÿuq‹E � áÿ � ‡ � ¬ýÿÿ;� ¸ýÿÿ}`‹•¸ýÿÿÁâ� ¤ýÿÿ‹…¬ýÿÿÁà� ¤ýÿÿ‹� ¨ýÿÿ‰ � I ‚ ’ ‹ ‹ ‹ ‹ � ‹ �
‹E � EðP‹M � UØR‹E ‹ � UøR‹E ‹ ‹ ‹ ‹ ‹ ‹
� � ‰Uè‹Eèƒà?‰EÔ‹MèÁé� áÿ � âÿ � áÿÿ � âÿÿ � êÿÿ ‹
hllG ‹ � áÿþÿÿƒÊÿ+щUÈë � á � âÿþÿÿƒÈÿ+‰EÄë � lG � á � âÿþÿÿR‹E � á � â � áÿþÿÿQ‹U
hÄlG � áÿþÿÿQ‹U
hÌlG � T � QhälG ‹ ‹ � èLB ‹ ‹ � � I � LNB � � � � � � � ˆ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ › ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � €’G � E � ùÀpG � ù°nG ‹ ¸ � þ pG � N
ƒÆ Vÿ � H � ` � ` � Çè � ÿ`ê
ÿu � � þÿÿƒÄ ‹
Àt&:a
ät
Àt
äuÒ‹ÿ3ÀÃ�
ÀtÜ÷Â
ÀtÆ:a
ät½ƒÁ � vG ˜ ˜ � ù ’ � ‹Çº � ôZB � ÿ$� xZB � ˆ � I � #ÑŠ � I ¸ ˜ � ä‹DŽè‰D� è‹DŽì‰D� ì‹DŽð‰D� ð‹DŽô‰D� ô‹DŽø‰D� ø‹DŽü‰D� ü� � ‹ � Šˆ � Š� I ˆ � � t1ü� |9ü÷Ç
ýó¥üÿ$•€\B � 0\B � I � €\B � ”[B � I � ŠF � I ‹ � ‹ � � � � � � � � � \B ˜ ‹ � ŠFˆ ‹ � I ˆ ˆ ‹ � ŠFˆ ˆ ˆ ‹ ‹ ’
‹ ’
j
� tè‹Gü„Àt!„ät
ƒï � tÜ„Òt΄öt*÷ ˆ ‹
àpG � ú
ˆ � ¤$ � ¤$ � tè‹Aü„Àt2„ät$© � Aÿ‹L$� Aþ‹L$� Aý‹L$� Aü‹L$
Š
„Àuó^[_3ÀÊ� ~ÿŠa � Gÿ^[_ËÇ^[_ÃÌÌÌÌÌÌÌÌÌÌ� Bÿ[Ã� ¤$ � d$
ƒÂ
¿ÿþþ~‹Á‹÷3Ë� á � u � tÓ% � æ � Bÿ[Ã� Bþ^_[Ã� Bý^_[Ã� Bü^_[ËÿU‹ìSV‹ � › � Ì
PèGûÿÿY‰~ ›
› � €’G ‹ ‹
@‰
� Eüÿu � €’G
‹
è � EðPhàpG
ƒÈÿ3Ò÷u � ÷ÿÿƒÄ � ýÿÿƒÄ � ÿÿÿPWVè
SSSSSè«‘ � Híƒù
X]Ë
òÿÿYé· ‹ � � � � €’G � ~ � � ‹ ‹
� ~G ‹
¨}G ‹ ‹ ‹
¨}G ‹
‹ � Mðèfÿÿÿ‹Eðƒ¸¬ � EðPh
€~G � Mðèàþÿÿ‹Eðƒ¸¬ � EðPj
€~G � Mðèaþÿÿ‹Eðƒ¸¬ � EðPj
€~G � Mðèâýÿÿ‹Eðƒ¸¬ � EðPj
€~G � Mðècýÿÿ‹Eðƒ¸¬ � EðPh€
€~G � MðèÝüÿÿ‹Eðƒ¸¬ � EðPj
€~G � Mðè^üÿÿ‹Eðƒ¸¬ � EðPj
€~G � Mðèßûÿÿ‹Eðƒ¸¬ � EðPh
€~G � MðèYûÿÿ‹Eðƒ¸¬ � EðPhW
€~G � MðèÓúÿÿ‹Eðƒ¸¬ � EðPj ÿu
€~G � MìèRúÿÿ‹E � ~ � EìP � 9
<Xt ÇE
ƒø ‹ ‹ � }ü ‹ � ñ � Áÿÿÿ � Áÿÿÿ ‹ ‹ � d$ � ƒ=<’ ‹ ‹ � d$
� T$ � <$ � á � T$� ù � �
hrG �
hrG � T$ � T$ � âÿÿ
`rG ‹ ‹ � d$ ‹ � À;ÃtÕ3À‹u � €’G � ‹
‹
;} ˆ
uɈ � � E°‹+‹ � C Pè…á ‹ ‹
‹C � à ‹
‹ ‹ ‹ � t$ � z(ƒù
°‡G � 4Ñë� B
¬‡G � � ΀ � E´Pè×ã � |½´‹� UÀRP‹ÑÁú
Pÿ � ¯ � EàP‹EÌÿt…´èšá � EÔPèC&
SSSSSèà|
‹ � …LÿÿÿPè»ßÿÿƒÄ � < � |8
SSSSSè%|
SSSSSè
SSSSSèç{ � E� P� …LÿÿÿPSSSj
êÿÿ‹Mĉ � E
SSSSSè:{ � D0ÿ‰EØŠ
SSSSSè¦z
SSSSSèiz � E� P� …LÿÿÿPSSSj � ‰H
ÿt
ÿt
è¼çÿÿÇ � E
è…çÿÿƒ8
Hu
SSSSSè\x � F
SSSSSè
SSSSSèðw � MôQPèÉá
SSSSSèpw � Eô+þ
SSSSSèLw ˆ
SSSSSè8v � w � EüPhÿ
SSSSSè@u ‹
SSSSSèèt � EàPè²ç
èØâÿÿ‹MЉ � G
€ � Eüj@PèËýÿÿ‹EüYYÉÃj
s � 4…€’G � €’G � E ‹ � á
u � � €’G
u ‹ ‹ ‹
ƒÿ � Gþ=ýÿÿ � f � F‹ � N � É ‹ ‹ � ƒ � ‹
ÿÿÿYë'ÿu
� ~G ‹
¨}G ‹ ‹ � d$ � ƒ=<’ ‹ ‹ � d$
� T$ � <$ �
°rG �
°rG ‹ ‹ � d$ � ƒ=<’ ‹ ‹ � d$
� T$
Á � <$ �
ÀrG �
ÀrG ‹ ‹ � d$ � ƒ=<’ ‹ ‹ � d$
� T$ � <$
À �
ÐrG �
ÐrG ‹ ‹ � d$ � ƒ=<’ ‹ ‹ � d$
� T$ � <$ �
àrG ‹ � á
�
àrG ‹ ‹ � d$ � ƒ=<’ ‹ ‹ � d$
� T$ � <$
�
ðrG ‹ � á
�
ðrG ‹ ‹ � d$ � ƒ=<’ ‹ ‹ � d$
� T$
¼ � <$ �
�
‹ ‹ � d$ � lD ‹ ‹ � d$ � ú
� T$ ‹ � <$ ¸ �
`sG ¸ �
`sG ‹ ‹ � d$ � ƒ=<’ ‹ ‹ � d$
� T$ ‹ � <$ �
psG �
psG ‹ ‹ � d$ � ƒ=<’ ‹ ‹ � d$
� T$
¶ ‹ � <$ �
€sG �
€sG ’ ‹ ‹ � d$� ! � ƒ=<’ ‹ ‹ � d$ ‹ � ñ � EüPQQÝ
º
pbD � a � a � ÁÞ& ‹ ‹ � D8
VVVVVèüU � Mè‹óèÈÇÿÿ‹} � EèP � EèPj � EÐVPè%!
ÙîÝ]ø…ÿtB‰ � t� sG � E � EàPÇEäÿÿÿ � EàPSè ‹ � I
Àt ƒÂ� I
Àt ƒÆ� ¤$ � tè‹Aü„Àt#„ät � yÿë
� yþë� yýë� yü‹L$ � tá„Òt4„öt'÷ � tÜ„Òt,„öt � âÿÿ � âÿ � EüWP‰}ü3öèÓúÿÿƒÄ
WWWWWèrQ ‹ ‹ � EìPÿuìWè¯
èž¿ÿÿƒ8
u 蔿ÿÿ‰� Mì¸DlD � EøPÿ ‹ × � EøPÿ ‹ � 8ÝÝ ‹
™[÷û€Â0ˆˆ � V
™[÷û‹ � ½ � Ë � l � Q � / � ü � ¢ � Hÿë � „ � l � 9 � þm � ² � F � pÿÿÿ‹Æÿu ‹ ‹ ‹ � F
ÿÿÿ‹F� 7ÿÿÿÿu �
\`D ‹
X`D ‹ ‹ ‹ ‹ ‹ � EàPSÿ¶¬ � EàPj � eÔ_^[‹Mü3Íèç¬ÿÿÉÊ � ‚ � G
Hu¬°Bé< � G � � G � G � Mà‰]ø‰Eðèظÿÿ‹E ‹ � G � Mà � F‹ ˆ
ÿE‹ � EüP� EàPŠ� M� 9]üv‹ ˆ � ù@Wÿÿs
� ùÏ&A“wåSWh€3á � � + � � yÿjd‰}ø‰M� D� Aº‹Ú™RPèw ‹ � Ç€3á � á
jd™Y÷ù…Òu � � á
jd™Y÷ù…Òu �
‹ØA9 ‹ � ùÿo@“v � EøPèv
SSSSSèÿA � EôPè”
SSSSSèäA � EüPè²
SSSSSèÉA ‹ ‹ � ÿ€ô � EìP � EìP � D � Ám � � EøPÿ � Ñ!NbþQPèk
®ÿÿSSSSSÇ � @ � ù � ù � ‹
ƒþ � ëßc � EøPè
VVVVVèk= � EüPè9
VVVVVèP= ‹ � EìP� E¸Pè€úÿÿYY…ÀuJ‹ ‹ � EìP� E¸PèUúÿÿë
� EìP� E¸PèÜ÷ÿÿYY…Àu� u¸ó¥ë ‹ � ÿÿÿ¶¼ � ÿÿÿ¶¼ � ÿÿÿ¶¼ � ÿÿYY‹†À � ¾Ô � ~PÇE � ‹ � œÿÿY9_üt‹ � _PÇE � {ø°}G ‹
‹C ‹ � _PÇE � {ø°}G ‹
‹C � þ¸}G ‹ � Fl‹=� ~G � ~G ‹
(� G ‹
,� G
”~G
XtG
¤rG
ðƒG � u
SSSSSè¦8 � � F� ‡€
SSSSSèB8 �
äÿÿ;Ãé � <0Š ‹ � w
SSSSSèI7 � F@8 � †€ � x � ^� CHÿ0‰EôhDoD � š ‹ � � CHÿ0‰Eô‹EühDoD � }ü¬nD ‹ ‹ � ì´ � H(‰� Tÿÿÿ� H,� X � Xÿÿÿ‰…hÿÿÿ…ö
VVVVVèØ4
3Àf‰ � ÿÿYY…À � ÿÿYY…À � …lÿÿÿVPè¼ûÿÿYY…À � …lÿÿÿPSPèÔ' � Tÿÿÿ‰� …lÿÿÿPWÿµhÿÿÿè£üÿÿƒÄ
‹…Pÿÿÿ;Çr � ÿÿƒÄ � ÿÿƒÄ
VVVVVès3 � ìÄ � …hþÿÿP� …PþÿÿPhƒ � …xÿÿÿPS� ÇÐ � � � …xÿÿÿPè|ŽÿÿYY…À � …xÿÿÿPèV–ÿÿƒÀ � DŽ � � …<þÿÿPè � ÿÿ‹F� � xÿÿÿQ‹� tþÿÿ‰…Lþÿÿ‹…pþÿÿƒÁüƒÀ � lþÿÿƒÀ� …PþÿÿPÿµdþÿÿ豎ÿÿƒÄ � dþÿÿ‰•Dþÿÿ‹P� DþÿÿƒÀ� � dþÿÿ‰H� …xþÿÿÿv ¸ � …xþÿÿPè^ � xnD � lþÿÿ‰� ½\þÿÿ°}G � <0ÿ7ÿ � ì˜ � tÿÿÿ;Ë
' � þ¬nD � � …xÿÿÿhƒ
VVVVVè � � xÿÿÿÆ„=xÿÿÿ
G€? � …xÿÿÿPQè"ùÿÿƒÄ� ~H…Ût3ÿ7� …xÿÿÿPè"ŠÿÿYY…Àt� � xÿÿÿè%ûÿÿY…Àu
Ç � ^l‹ÃèyóÿÿWè´òÿÿYöFp ‹ ¸ � ~G � ~G � G ‹ ‹ ‹ � \ � \ � \ � \ � \ � \ � \ � \ � \ � \
+ót� \ � \ � \
+ót� \ � \ � \ � \ � \ � \ � \ � \ � \ � \ � \ � \ � \ � \ � \ � \ � \ � \ � \ � T� T� T� T� T� T� T � T� T� T� T� T� T� T� T� T� T� T � T� T� T� T� T� T� T� T� T � L ÿ‹Áë
‹ � T� T� T� T� T� T� T� T� T� T� T� úÿÿ� T� T� T� T� T� T� T� T � T� T� T� T� T� T� T� øÿÿ� T� T � L ÿ‹Áéîûÿÿ‹Pâ;Qât}� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T� T � T� T� T� T� T� T
Àt ƒÂ
2011-10-03 18:41:19 +00:00
Àt � FÿƒÄ ^ÉËD$
2012-06-04 14:58:17 +00:00
ƒÂ
ƒÂ
3Ë¿ÿþþ~� á � tà‹Jü2Ët#2ët � Bÿ[Ã� Bþ_[Ã� Bý_[Ã� Bü_[ËÿU‹ìƒì� MðèÏ„ÿÿ3Û9]� ÿÿSSSSSÇ � Eðjÿÿu
èä€ÿÿÇ � E ¸ � ¸ ˆ
� <… ˆ � � F
‹ � N ‹ � f � ìx � � ¤ýÿÿ‰µ´ýÿÿ‰½Üýÿÿ‰…¸ýÿÿ‰…ðýÿÿ‰…Ìýÿÿ‰…èýÿÿ‰…Ðýÿÿ‰…Àýÿÿ‰…ÈýÿÿèÚ
‹…¬ýÿÿƒ`pýƒÈÿéÈ
� €’G � Øýÿÿ‰� àýÿÿ‰� ¼ýÿÿˆ•ïýÿÿ„Ò
� Äýÿÿ
� èýÿÿÿ‰µ� ýÿÿ‰µÀýÿÿ‰µÌýÿÿ‰µÐýÿÿ‰µðýÿÿ‰µÈýÿÿév � ðýÿÿ � ðýÿÿ � ðýÿÿ � � ðýÿÿ€ � ðýÿÿ � ù � ðýÿÿ� Ìýÿÿéç
� D � ¢ � èýÿÿÿé–
� D � � ðýÿÿ � � ðýÿÿ � Äýÿÿé9 � ðýÿÿ � ðýÿÿ é! � � ðýÿÿ � Äýÿÿéþ � ¥ðýÿÿÿ � ÄýÿÿéÝ � …¤ýÿÿP � ´ýÿÿ� µØýÿÿè¤ûÿÿŠ� Äýÿÿ„À� ´ýÿÿ� µØýÿÿè‚ûÿÿéM � è � ò � ýÿÿ � ðýÿÿ@9µèýÿÿ� � ôýÿÿ¸ � äýÿÿ‰… ýÿÿ� H � � ðýÿÿ
� � ðýÿÿ � èýÿÿƒùÿu � …ôýÿÿP� …àýÿÿPè � …ôýÿÿ‰…äýÿÿé5 � äýÿÿt � û � � ðýÿÿ � ðýÿÿ@Ç…àýÿÿ
� ðýÿÿ÷Á � ½èýÿÿ£ � Æ]
Ç…èýÿÿ£ � …¤ýÿÿPÿµ� ýÿÿ� …ˆýÿÿSPÿ5¨vG � ç€ � …¤ýÿÿPSÿ5´vG
� …¤ýÿÿPSÿ5°vG
� � ðýÿÿ � äýÿÿSé � ¸ýÿÿë$ƒès � � ðýÿÿ � � uó‹…èýÿÿÿ� èýÿÿ…À
� ýÿÿ‹ø‹Ú~� ¸ýÿÿˆ� Eó+ÆF÷…ðýÿÿ � äýÿÿ‹� äýÿÿÆ � Ìýÿÿ+� àýÿÿ+� Ðýÿÿö…ðýÿÿ � …ØýÿÿSj èpõÿÿƒÄ � …Øýÿÿ� � Ôýÿÿèvõÿÿö…ðýÿÿ� …Øýÿÿè.õÿÿƒÄ � ýÿÿPj� EôP� …˜ýÿÿFPFè¶ � …Øýÿÿ� Môèñôÿÿƒ½ ýÿÿ � Øýÿÿÿë� äýÿÿP� …ØýÿÿèÊôÿÿYƒ½Øýÿÿ � …Øýÿÿè‚ôÿÿƒÄ � ÄýÿÿŠ� ”ýÿÿ‹½ÜýÿÿŠÐéáõÿÿ€½°ýÿÿ
‹…¬ýÿÿƒ`pý‹…Øýÿÿ‹Mü_^3Í[è¡eÿÿÉÃ� "òB � EœPÿ � ˆ
‰x
Æ@&
‰x8Æ@4 ‹
€’G � Á
� X� ‹ � � €’G � �
ƒ`
Æ@&
ƒ`8 ‹ � ë � F � …Ûu
‹ÃH÷Ø � F
€N � ì( � …Üüÿÿj � …Øüÿÿ‰…(ýÿÿ� …0ýÿÿƒÄ � Üýÿÿ‰•Øýÿÿ‰� Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒ� ìýÿÿfŒ� ÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ¼ýÿÿœ� …ðýÿÿ‹E� M � ôýÿÿ‹Iü‰� äýÿÿÇ…Øüÿÿ � …(ýÿÿPÿ ‹ � l$ � Eðd£
� {
‹N � Uè‰Sü‹[ � I � � D†
‹N ‹ � 9csmàu)ƒ=`’ ’
‹ ‹
‹N ˆ � †è ˆ � †è ˆ � †è ˆ � †è � üÿÿÃj � ‹ ‹
WÿÓWè¢[ÿÿƒ& � þÐuG � þÐuG ‹ � 4õ°tG
èY
è(ÿÿÿYËÿU‹ì‹E� 4Å°tG � `D � `D � `D
ÐuG
ÔuG ‹ ˆ
èéýÿÿYƒeü � ~G
è°üÿÿYÃj ‹ ‹ ‹ ‹ ‹
WÿÿY‹
è[üÿÿYƒeü � ÿˆxG ‹ � ~G � ÿ¸}G
èñúÿÿYËu ‹ ‹ ˜
ƒ=x‰G � `D
ûÿÿYÿÐ…Àt
ƒ=`tG � ûü
VVVVVè � ŠG ¸
VVVVVèmòÿÿƒÄ
VVVVVèHòÿÿƒÄ � EøP� 4ýÜuG � UÿÿYPÿ6Sÿ � C � C � G� 4˜èñ÷ÿÿY£Œ“G � ·� vG � 8PE � D‹ ‹ ‹
BƒÀ(;Örè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìjþh� TE � Eðd£
‹X
¸ ‹ × ‹ ¸ � � ‘ � ‚ �
ÄvG
¾¤ŒG
ƒû ‹
¸
¼vG ¸
ƒû � ì” � ½|ÿÿÿ‹ÏQÿu� xÿÿÿÿu � lÿÿÿ‰� xÿÿÿt� NÿQWVPè²+
SSSSSèÖéÿÿƒÄ� xÿÿÿt
öé� ÿ¸ŒG � }à � êÿÿËÿU‹ì‹E � MðèÀZÿÿ‹u � MðèMZÿÿ‹E
@Bˆ � EøPèD÷ � E � Mð‹Øè
Yÿÿ3ö;Þu+èŒUÿÿj ‹ ‹ � s � F
SSSSSè� N‹ ‹
™jd_÷ÿ
|
™j
_÷ÿ ’ � A ‹ � MäQ� MÔQÿp � MÔQ� N � EÔSPÿu � MÜÇEìÿ ‹ � åÿÿƒÄ � � ^ � á � áÿÿ
ÇEìþ � áÿÿ � âÿÿ � âÿÿ � FÿŠ ‹
Æ
r
RPèé÷ � MðNè2Sÿÿ…ÿu-è¶Oÿÿj � w‹
‹ÆèXùÿÿÆ ‹ ‹ � MäQ� MÔQÿp � MÔQ‹MØ � EÔSVÿu ‹ � MäQ� MÐQÿp � <0ƒùÿu � EÐPÿu ‹
Š � EÐj � EÐj
VVVVVè¿ÝÿÿƒÄ � › � ¶€ � ¿€
= � œZ+Ñt � 3À
D’ ‹ � ú � Œ � ‹ � L � JàÓë� L ‹ ‹ � � KàÓî÷Ö!´¸Ä ‹ ‹ ‹ ‹ � ‹ ‹ ˆ � D¸D � Jà» � Jຠ� „¸Ä
X’ ‹ ´
X’G
X’G ‹
D’G ‹ ’ � L� H
D’ ’ ’ ’ ‹ ’ ’ ’ ‹ ’ ’ ’ ¸ � „0D � � — � G � � ü � � üïÿÿÇ@üð � O � J � Œ � |9ü‹ � ; � L� Dþ u&‹ � L� Ä ‹ ‹ � L1üƒÿ?v� ‹ ‹ ‹ ‹ ˆ � D� D‹Ïë €} � Oà» � „� Ä � Oຠ� D2ü‰‹ � F � / ‹ � N� \3ü‹u ‹ � t� Dþ � NàÓë� L� Ä ‹ ‹ ‹ ‹ ‹ ‹ � ‹ ‹ ˆ � D� D‹Îë €} � Nà¿ � „� Ä � Nàº
ƒÁàƒÊÿ3öÓê‰Uø‹
P’G
ƒÃ ‹ ‹ ×
ƒÃ
ƒÃ‹ ’
ƒÃ � Ä � D#Mø#þ ‹ � Ä � HD‹9#Uø#þ � Œ � D3ÿ#Îu� Ä
+Mð‹ñÁþ ‹ � |8 � OàÓë‹Mü� ŒˆÄ � |8 � � ‹ ˆ
� Nà¿ � ¼ˆÄ � Nà¾
‰L‹ � N
‰L2ü‹uô‹� y ‹
X’G � B � ì( � G
Ô� G � G � G � G � G � G
ä� G � G � G ¸ � G � G � � G � G � G � E� G � G � G � G ˆ � G � ¤$ � f � ¿€
ÿ � <ÿÿYƒÈÿë ’ � � €’G � ÎÿÿÃÿu � f
ƒI � A � G � Q � ¢
t"ƒè � eüÿ¿ÿÿÇEô � M � M ´ � M � M � M � Eðÿu ‹ � <…€’G ‚ ‚ � N � ~ ‹ � Ï � � Fýƒø� F
˜“G � g ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � 4v� \³‹ ‹ � ¸ ‹ ‹ ‹ ‹ ‹ ’ � <…€’G � úÿÿÿ �
tl9]ˆ ‹
8]þtN‹
tC9]ˆ ‹
u$‹
tˆ ‹
S� MèQÿu � D
‹
u
t ˆ � ‹ � A
u
AA‰M
ëu‰E � EèPj� EÿP‹
ÿ ‹
t¹Æ
‹
t j
t
C‹Eð9E� D
èõ0ÿÿÇ ‹ ˆ ‹ ˆ ‹ ˆ � á
u
t ‹ � H
u
ƒÀ
éŽ � EèPj� EøP‹
ÿ ‹
t²j
Xf‰‹ ‹
ë*;]ôu
t…j
t
Xf‰� t � � €’G ‹ ‹ ‹
ˆ
ˆ ˆ ‹
t � F � ~ � F � † � ì � …èúÿÿPÿv � � ïúÿÿ� ”
üþÿÿj Rè{ � …üúÿÿÿv� …üþÿÿPj � …üýÿÿWPW� …üþÿÿPWÿv � …üüÿÿWPW� …üþÿÿPh � † � „ � Z ƒû � UE
è¥ÁÿÿYƒeü � þˆxG ‹
èjÀÿÿYËÿU‹ìƒì� Mðè¶,ÿÿ‰ � G � G ‹ � G � G � � ÿèý � ÿéý � EèPWÿ � C � uïŠ � C � ±È|G ‹ � C� ‰¼|G � C � {� G ‹ ˆ ‹
è&¾ÿÿYƒeü � G ‹ � G � G � G
ŠL ˆ
蟼ÿÿYÃë%ƒøÿu � ûˆxG � “G � “G � Mèè� (ÿÿ‹]� C � EèP‹E
3Ɉ]øÆEù ‹ � EüPQ� EøP� Eèj ‹ ’ � ù
ø²D × ’ ’ � âð � ú
€ªD � Á€ÿ � ²D � ²D ˜ � ªD � ù � � Âï � âÿ � úð
À²D � á × � âÿÿÿ � â
#Áº
°²D
#Áƒø � áÿ � ùÿ � á �
À²D � � âÿÿÿ
� ú � ú � ñ � âÿÿÿ
� Á � ê€ � Á€ � €þ � ²D � î€ÿ � ²D ˜ � ªD � ê€ÿ � ú � É€ÿ � âð � êð? � ¤$ � ¤$ � Æ…pÿÿÿþ
íuKÙÉÙñë
Æ…pÿÿÿþ2íÙêÞÉè;
ít
ÉuSÃÙìë
Éu®ÙñÃéN
Éu
ít
ítéÙàëåÝØé
ít
Éu¯ÝØÛ- ~G
Ò~G
¸ � \ÿÿÿ€Ï� ^ÿÿÿÙ^ÿÿÿ» � aÿÿÿÐáÐùÐÁŠÁ$� á � \ÿÿÿ€Ï� ^ÿÿÿÙ^ÿÿÿ» � aÿÿÿÙå›Ý½`ÿÿÿÙÉŠaÿÿÿÐåÐýÐÅŠÅ$
Ä� á
2011-10-03 18:41:19 +00:00
ÉÃ
Ét � E� MàPQRè� Ç � } � â
‹ ‹
© � <$ ‹ ‹
Œ³D
„³D � uHÝE
˜³D � � G � t � ø � MØÝ]àQÝ � MØÝ]àQÝ � Á � N\C � MØÝ]ðQÇEØ ‹ ¸ ‹ ‹ ‹ ‹ ‹ ‹ ¸ ‹ � D$ ‹ ‹ ‹ � 4v‹
‹
� y ‹ ‹ ¸ ‹ � Ÿÿÿƒeü � Mì‰]üèí ‹ � Aÿ‰Eüë
9]üë ‹ ‹ ˆ ˆ
FŠ � ÿÿƒÄ
ÿÿYèÑ
ÿÿ‹
ÿÿÇ
ÿÿÇ
‹
ÿÿj
BF:Ëtˆ
ÿÿj"Y‰
ÿÿÇ
èæ ÿÿÇ
èÍ ÿÿÇ � G � ãÿ¿ÿÿë ;×u� Ë � Ë€ � EÄP� EÐP� EÔPÿ � � T� D � � T� D � EÜPèÉ»
2012-06-04 14:58:17 +00:00
SSSSSèv˜ÿÿƒÄ¸ � D � D � D � D � E
� N
‹
…À}
2011-10-03 18:41:19 +00:00
ë � ‹
Pè¤úþÿYÿEä‰}üè
2012-06-04 14:58:17 +00:00
SSSSS訔ÿÿƒÄ
ÇEØ � EàPè� ·
SSSSSèJ”ÿÿƒÄ
p‡G � Mô � Mø � Mô � Mô � EÐPÿuðÿuøÿu � eøÿÿÿ � EÐÿuìPÿuðÿuøÿu � D0 � D0
2011-10-03 18:41:19 +00:00
� D � 8ƒ � EüPÿ6ˆ]üè ‹ ‹ ‹ � EèPÿ6è£ÉÿÿƒÄ � }è � D=èPÿ6è" � €’G � D � €’G � D
ʈ � €’G � D � EÐj� çÿÿÿ � €’G � D � €’G � EäP‹ÇèjøÿÿƒÄ � €’G � D � ÿÿYY‰ � ÿÿƒÄ
ÃRèfÂÿÿYËÿU‹ìƒ}� ìü � � � |þÿÿ‰…dþÿÿ‰� TþÿÿÇ…$þÿÿ^ � €’G � €’G � � � tþÿÿVV� µtþÿÿè…þÿÿYPèkþÿÿYYG
� D � ƒ � G � G
ƒûwt� G � kþÿÿþ� sþÿÿ€½Sþÿÿ � sþÿÿu � µtþÿÿè}üÿÿYë � Lþÿÿ…Ét
ƒ½lþÿÿ � r
�
� lþÿÿ‹•dþÿÿÿ…tþÿÿè^ûÿÿ‰…xþÿÿƒ½Lþÿÿ � lþÿÿÿ� lþÿÿ…ÀtfŠ…xþÿÿ‹� Tþÿÿÿ…Xþÿÿˆ � …0þÿÿP� …|þÿÿPCS� ½Tþÿÿ� µ$þÿÿè‚úÿÿƒÄ
� lþÿÿ…À � Tþÿÿ‰…xþÿÿŠ…aþÿÿˆ � …0þÿÿP� …|þÿÿPCS� ½Tþÿÿ� µ$þÿÿèÕùÿÿƒÄ � lþÿÿ…Àtf‹…TþÿÿŠ� xþÿÿÿ…Xþÿÿˆ � …0þÿÿP� …|þÿÿPCS� ½Tþÿÿ� µ$þÿÿè{ùÿÿƒÄ
ƒ½xþÿÿE � lþÿÿ…À � …0þÿÿP� …|þÿÿPCS� ½Tþÿÿ� µ$þÿÿèéøÿÿƒÄ � …0þÿÿP� …|þÿÿPCSè£øÿÿƒÄ � lþÿÿ…Àu� lþÿÿ…Àtf‹…TþÿÿŠ� xþÿÿÿ…Xþÿÿˆ � …0þÿÿP� …|þÿÿPCS� ½Tþÿÿ� µ$þÿÿè � tþÿÿÿµxþÿÿèUøÿÿƒ½Xþÿÿ � � � tþÿÿWÿµxþÿÿ‰µ@þÿÿèº÷ÿÿYYƒ½Lþÿÿ � lþÿÿ…À
� aþÿÿ3ҋȃá
Ü3Ë…Ñ � … � … þÿÿP� … � cþÿÿ€½jþÿÿ
� w� EÜj � D� D � lþÿÿu
ÿ� lþÿÿu � tþÿÿPèÞôÿÿYY‰µxþÿÿé � tþÿÿWPèjôÿÿYY9µ@þÿÿ � Dþÿÿ3Àf‰ � lþÿÿu
ôþÿY…À � ´
ÿµ8þÿÿÿµ4þÿÿè…Q � lþÿÿt5‹•dþÿÿÿ…tþÿÿèºòÿÿ‰…xþÿÿé� tþÿÿÿµxþÿÿè®òÿÿYY€½`þÿÿ � 8þÿÿ÷ØƒÑ � 8þÿÿéÚ
ë' � |� lþÿÿt5‹•dþÿÿÿ…tþÿÿè´ñÿÿ‰…xþÿÿéXÿÿÿÿµdþÿÿÿ� tþÿÿÿµxþÿÿè¨ñÿÿYY€½`þÿÿ
� G� xþÿÿ‰½Hþÿÿ;Ãul � tþÿÿƒ½xþÿÿÿu� ðÿÿYYë �
‹…
ènêþÿÇ
ÿu � ‹ � H‹ ‹ � E � 4…€’G � 'åÿÿ€û� èþÿVVVVVÇ
€ � � � … � åÿÿÿ � åÿÿt � 4åÿÿ‰…
� EôPëK � 4åÿÿ+Ë � …@åÿÿSPè � …@åÿÿPèäž � � MôQj� � @åÿÿQPÿµ � …<åÿÿPV� EôP‹…(åÿÿ‹ � 0åÿÿ � …<åÿÿPj� EôP‹…(åÿÿ‹
ÿ4
� åÿÿ<�
XP‰…@åÿÿèº� � @åÿÿ„Û � <åÿÿƒ¥Dåÿÿ � 4åÿÿ� …Håÿÿ;M
u
@ÿ…Dåÿÿˆ� ½Dåÿÿÿ � …Håÿÿ+Øj � …,åÿÿPS� …HåÿÿP‹ � Dåÿÿƒ¥<åÿÿ � 4åÿÿ� …Håÿÿ;M
u
[f‰� ½<åÿÿþ � …Håÿÿ+Øj � …,åÿÿPS� …HåÿÿP‹ � Dåÿÿƒ¥<åÿÿ � 4åÿÿj� …Hùÿÿ^;M
u
[f‰� ½<åÿÿ¨
� � ðëÿÿQ� � Hùÿÿ+Á™+ÂÑøP‹ÁPVhéý � …,åÿÿP‹Ã+ÆP� „5ðëÿÿP‹…(åÿÿ‹
ÿÿÿë?j � � ,åÿÿQÿu � � � €’G � D0 � � � €’G � <� €’G ‹
‹E� � ‹ ‹ ‹ � áàÿ ‹ ‹ ‹ ‹ ‹ ‹ ‹ � E ‹ � ‹
‹
‹
‹
� � ‹ � EøPQQÝ � � Á � ùÎûÿÿ}
ÝEì‹óÜ
pbD � Mì � EàPèÝ1ÿÿƒÄ � ì€ � C � C� C � C ÿs� E€PèèûÿÿƒÄ � ì€ � C Pÿs � C P� C � C(ÿs� E€Pè � á � }
9U� }
9U ¸ � âÿ � êþ
Û-`€G
Û-l€G ’ ‹ ‹
=
2012-06-04 14:58:17 +00:00
½D � Â �
2011-10-03 18:41:19 +00:00
H½D � ÌÌÌÌÌÌÌÌÆ…pÿÿÿÿèœ
Ût{èÖ
Ût[ÙÀè“
Ût3èr
ÿu
ÿu� Ä0ýÿÿS›Ù½\ÿÿÿ›ƒ= „G � 8ýÿÿ � Ä0ýÿÿS›Ù½\ÿÿÿƒ= „G � 8ýÿÿ � Ä0ýÿÿSÿu � 8ýÿÿ
Àt
Àt3 �
¨½D � ½D
½D � lÿÿÿC‰� vÿÿÿö…8ýÿÿ� u� ½zÿÿÿ¥¥€{ � u� }‚¥¥Ý]Š� …rÿÿÿ� � \ÿÿÿSP‹� lÿÿÿŠC � Ä0ýÿÿSÿu � Ëÿ
ðÅD �  �
@ÆD � I
`ÜD � Â � ÜD
ÜD � ˆ � � � ¨ � € � ¤$ � âÿÿ � ê � êÀþ
� ôD × � âÿÿÿ � áÿÿÿ � Ù � �
ôD � âð � úà ¸ � âÿÿ � ê × � êÀþ � �
p �
0 × � âÿÿÿ � áÿÿÿ � Ù � ¿
Ét
ít
Ét
ít
ít÷ÙàÃÝØéP§ÿÿÝØŠÍë � G � G ‹
? ‹
`� G
`� G
d� G
d� G ‹
? ‹ ‹
h� G � G � þÿÿÛl$ ‹
ÙD$ ‹
ÝD$
ßD$
ÛD$
ÙD$ ‹
ÝD$
ßD$
ÛD$ � G ‹ ‹ ‹ � ãÿ ‹
‹\$0� ãÿ � ãÿ � ã ‹
? ‹ � ãÿ � ãÿ
œ� G � G � ã
Ûl$ ‹
Œ� G ‹ � d$
èÝýÿÿƒÄ0ZÃÛ,$Ûl$ ‹
? ‹
„� G
„� G ‹
„� G � G ‹ ‹ ‹ � ãÿ ‹
‹\$0� ãÿ � ãÿ � ã ‹
? ‹ � ãÿ � ãÿ
œ� G � G � ã
Ûl$ ‹
Œ� G ‹ � d$ ‹
èÚýÿÿƒÄ0ZÃÛ,$Ûl$ ‹
? ‹
„� G
„� G ‹
„� G
� ç
P ¸ � áÿ � ùý � éþ
�
À � ùþ
P
à
Ð � áÿ � ùÿ � áÿÿ � d$
P ¸ � áÿ � ùý � éþ
�
Ð � ùþ
P
ð
à � áÿ � ùÿ � áÿÿ � ¤$
Ð E � @ � < � ú � E × � Â~ � ú| � Ê � Âÿ � áð � ùð � ù � ù+#†ÀrJw‹ � úï9úþr<ë ‹ ‹ � @s…f � I � ƒè€]ÃÙîÜ] � Mðè � EðPèö4 ‹ � EüVPè� ] � EüPÿu
èÌ¢þÿ‹Mü‰ ‹ ‹ � EÜP� EðP‰Mà3Ûè¤i
» � EäP� EðPèø^ � Ë ‹
‹ � ¡þÿÿu � EüSPèÚÛþÿƒÄ � |0ÿŠ
SSSSSèÝ1ÿÿƒÄ
SSSSSèž1ÿÿƒÄ � ~
謟þÿ‹Mð‰ � EøP� EüPÿu � ‘þÿÿuøè•‘þÿƒÄ � � %E
SSSSSèª/ÿÿƒÄ
SSSSSèŒ/ÿÿƒÄ� w‹
;ót
SSSSSèô.ÿÿƒÄ � þÿ‹
SSSSSè®.ÿÿƒÄ� }ôÀ‚G � þÿÿu� ýÿÿƒÄ� þÿ‹} � þÿY‹Eð^_[ÉÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌSV‹D$
‹
Ô‚G
‹
Ø‚G
‹
ЂG � EäPè@ÿÿÿY;Ãt
SSSSSèW,ÿÿƒÄ� EÜPè³þÿÿY;Ãt
SSSSSè<,ÿÿƒÄ� EØPèÑþÿÿY;Ãt
SSSSSè!,ÿÿƒÄ � G � G � G � þÿ@Pèò.ÿÿYY£ð� G � þÿY@Pÿ5ð� G � G
Pè„ŒþÿY‰ � G � G
ì� G � G � G ‹ � G � G � G � G � EÐPSj?‹ � G
‹Eà‹ � EÐPSj?‹Eàÿp� G
SSSSSè/*ÿÿƒÄ � üÿÿ‰0‹uÜèwüÿÿ‰0èò*ÿÿËÿU‹ìƒì � ‡l �
‹ÆÁà � ‡+ � _ÿ¿� � Gÿ™ƒâ � „ � t � ‡l � � ‡l � ‹
pƒG � EüP‰5xƒG
|ƒG ‹ �
xƒG ¸ � Eü3öP‰uüè¶ùÿÿY…Àt
VVVVVè?'ÿÿƒÄ ‹ � G � G
à� G � G � G � G � G � G � G � G � G
Œ� G � � G � G � G ˆ � G � G � G � G
lƒG
3É; � Áë � G � G � G � H¿Fƒù
� y¿Bƒÿ� MðèÄ–þÿ3Û9]
Wÿu‹ � MðQPèØ
ÿÿÿE� MðQPèÆ
ÿÿƒÄ‹ � Mðèž•þÿ � L$ � L$ � F� EðSPèJ6ÿÿ‹ø� F� EðSPè56ÿÿ � F � EðSPè 6ÿÿ � F� EðSPè � F� EðSPèó5ÿÿ � F� EðSPèÞ5ÿÿVj7ÿuü � EðSPèÌ5ÿÿ � F Pj*ÿuü� EðSPè·5ÿÿƒÄP � F$Pj+ÿuü� EðSPèŸ5ÿÿ � F(Pj,ÿuü� EðSPèŠ5ÿÿ � F,Pj-ÿuü� EðSPèu5ÿÿ � F0Pj.ÿuü� EðSPè`5ÿÿƒÄP � F4Pj/ÿuü� EðSPèH5ÿÿ � F � EðSPè35ÿÿ � F8PjDÿuü� EðSPè � F<PjEÿuü� EðSPè 5ÿÿƒÄP � F@PjFÿuü� EðSPèñ4ÿÿ � FDPjGÿuü� EðSPèÜ4ÿÿ � FHPjHÿuü� EðSPèÇ4ÿÿ � FLPjIÿuü� EðSPè²4ÿÿƒÄP � FPPjJÿuü� EðSPèš4ÿÿ � FTPjKÿuü� EðSPè…4ÿÿ � FXPjLÿuü� EðSPèp4ÿÿ � F\PjMÿuü� EðSPè[4ÿÿƒÄP � F`PjNÿuü� EðSPèC4ÿÿ � FdPjOÿuü� EðSPè.4ÿÿ � FhPj8ÿuü� EðSPè � FlPj9ÿuü� EðSPè � FpPj:ÿuü� EðSPèì3ÿÿ � FtPj;ÿuü� EðSPè×3ÿÿ � FxPj<ÿuü� EðSPèÂ3ÿÿ � F|Pj=ÿuü� EðSPè3ÿÿƒÄP � †€ � EðSPè’3ÿÿ � †„ � EðSPèz3ÿÿ � †ˆ � EðPèb3ÿÿ � †Œ � EðSPèJ3ÿÿƒÄP � †� � EðSPè/3ÿÿ � †” � EðSPè � †˜ � EðSPèÿ2ÿÿ � †œ � EðSPèç2ÿÿƒÄP � † � EðSPèÌ2ÿÿ � †¤ � EðSPè´2ÿÿ � †¨ � EðSPè™2ÿÿ � †° � Eðj � � ¸ � ÇÔ ‹ ‹ ‹ ‹ ‹ ‹ � Eèj� F� Eèj� F� Eèj
€é0ˆ � ~
trG ‹ ‹
xrG ‹
|rG ‹ ‹ ‹ ˆ ‹ ‹ � rG ‹ ‹ ˜ � C � Eðj� C� Eðj � C� Eðj � C� Eðj � C � Eðj � C PjPV� Eðj � C$PjQV� Eðj � C(Pj� Eðj � C)Pj � EðPès,ÿÿ � C*PjTV� Eðj � C+PjUV� Eðj � C,PjVV� Eðj � C-PjWV� Eðj � C.PjRV� Eðj � C/PjSV� Eðj � ýÿÿSèûwþÿÿuøèówþÿÿuüèëwþÿƒÄ
€é0ˆ � ~ � F � E´ ‹ � EèPÿv
‹M � ^ � EôPj � uôVèñT ‹ � EôPh � Eôh¼5E � t
„Éu׋Æ^Ã3ÀŠ
B€ùA| � Æœ � E„P‹F � E„Pÿv
ƒN � E„P‹
� U„èØþÿÿ9E
� Æœ � E„P‹F � E„Pÿv � E„P‹F � E„Pÿ6è � N ‹ � E„Pÿ6èjS � E„P‹F � E„Pÿ6èlêÿÿY3ÛY…Àu/� N ‹
� E„Pÿ6è êÿÿYY…Àu � N � Æœ � E„P‹F � E„Pÿ6è � E„Pÿ6èYéÿÿYY…Àu
ƒN ‹ ‹ � Æœ � N � C@� ~ � ÿèý � ÿéý ‹ ‹ ‹ ‹
ÿÿƒÄ � C@Ph
j � G � EøP3öFVhÜ5E � G
j� G � G ‹ ‹ ‹ � � ÿðÿÿ � D? � ‹ ‹ ‹ � M � eì_^[‹Mü3Íè«kþÿÉËÿU‹ìƒì� MðèÁzþÿÿu$� Mðÿu ÿu � {ü…ÿvn‹M � G � G
Ç� G ‹ ‹ � G ‹ ‹ ‹ � � � D? � § � � D ‹ ‹ ‹ ‹ � M � Eøÿu ‹ � eà_^[‹Mü3Íè� Mðè� Mðÿu$ÿu ÿu ‘ ‘
Ç ‘
‹ ‹ × � m � EèPÿu � Eît׊P � EîtïŠP � D � D ‹ ‹ � E � E � eÈ_^[‹Mü3Íè1cþÿÉËÿU‹ìƒì� MðèGrþÿÿu$‹U� Mðÿu � nþÿÇ � €’G ‹ � 8csmàu*ƒx‹ � “G � t ˆ ‹
‹M ‹ � F
3À3Û9Eü
Š
è©C � “G � ‡G � EøPSS� }ôè
þÿÿ‹EøƒÄ � � EøP� }ôèÉýÿÿ‹EøƒÄ ’
j �
@8
…Ãt ÷УäpG � EøPÿ ‹ � EðPÿ ‹ ’ � úþÿƒÄ � €’G ‹ ‹ � ÿÿÿÿ � Mðèõjþÿ‹Eð9X ‹ � ùþÿƒÄ � M � M ‹
ÿÿY…À
‹E ’ ’ � MøQj � MìQj� M
ˆ � KþÿYËÿU‹ì� ì(
èLÿþÿYè* � Üýÿÿ‰•Øýÿÿ‰� Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒ� ìýÿÿfŒ� ÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ¼ýÿÿœ� …ðýÿÿ‹u� E � …Øüÿÿj � …ØüÿÿƒÄ � …0ýÿÿj � …(ýÿÿPÿ � Mðè ’ ‹ ’
j ‹ � D � eì_^[‹Mü3ÍèwSþÿÉËÿU‹ìƒì� Mðè� bþÿÿu � Eðÿu ‹ � MÜè=bþÿ� EÜP3ÛSSSSW� EØP� EðPèé% � EðVPèT ‹ ‹ � MÜè•aþÿ� EÜP3ÛSSSSW� EØP� EðPèA% � EðVPèð ‹ � ù ’ � ‹Çº � T � ÿ$� Ø � h � I � #ÑŠ � I � ä‹DŽè‰D� è‹DŽì‰D� ì‹DŽð‰D� ð‹DŽô‰D� ô‹DŽø‰D� ø‹DŽü‰D� ü� � ‹ � Šˆ � Š� I ˆ � � t1ü� |9ü÷Ç
ýó¥üÿ$•à � � � I � à � ô � I � ŠF � I � � � � � � � � � ‹ � ŠFˆ ‹ � I ˆ ˆ ‹ � ŠFˆ ‹ � Fˆ
ë � ~ � Á ‹ ‹ � Á � Çÿÿ � E� EðPè� EÔPj � uð‹ü¥¥f¥è.1 � EØPÿu � <� €’G ‹
d’G � <…€’G � €’G
èçìþÿY‰]ü9^ � F � D8
è§ëþÿYËÿU‹ì‹E � €’G � D � <
èßëþÿY3ÛC‰]üƒ~ � F � ^
è¤êþÿYÃ}Ü � � Â
ƒ` � Mèè2Vþÿ3Û9]‹ ‹ � ( �
f �
f ‹ � MðèÞSþÿ‹}ô9_ � ‹ ‹ � þÿÿƒÄ � MüQÿuøPÿ � D0 � � €’G � øÿÿY‰}ü‹ � ìˆ ‹ ‹ � xÿÿÿtRHtCHt4Ht%HtFHHt
Ç…|ÿÿÿ � ~ � N� …xÿÿÿP� E€PèNpÿÿƒÄ � � � ç€ � û � û � û � û � û
� L1$Š� €Ê
� L1$Š
€I
� L1$€!€…ÿ_^[u
‹
0’G
‹ � Mðè¨Lþÿ‹Eð9X ‹ � EðP ‹ � MðQj� M � EôPj� E ‹
h„G � UðRP� EôPQÿ � f‹E � L$
‹ÁY”‹ � Mðè¡Jþÿ‹U � EðPRÿu � EðRÿu
‹ � /þÿë
è5ÿÿÿ£€‡G � 4¾ÿ6è � 4¸9 � ÿÿÿÿ?sjj � G �
SSSSSè
S‹Ù� á � ãÿ � ëÿ? � û
@ƒø � }à««j � uà� }Ô¥¥¥‹58„G � N � â � |…àj � � æ � L…à‹1‹ � L…à‹� r
j� |…à+È3Àó«ƒ}
8„G
3À� }à«««é
� � uÔ‹È� }ख़ƒâ � â � \� à‹3‹Î#ωMð‹ÊÓî‹Mü � MèZ+Î;Ð| � N � â � \…à‰Mð… � æ � L…à‹1� < ‹ � L…à‹� r
j� |…à+È3Àó«‹
<„G � â � \� à‹3‹Î#ωMð‹ÊÓî‹Mü � MèZ+Î;Ð| ‹
<„G � }à«««� Mà � â � \� à‹3‹Î#ωMð‹ÊÓî‹Mü � MèZ+Î;Ð|
D„G � � eàÿÿÿ � â � à‹Ï#ΉMð‹ÊÓï‹M � à‹}ð‹MüÓçÿE� MèZ+Î;Ð|
<„G � á
@„G
‹ ‹
2012-06-04 14:58:17 +00:00
ƒù u
2011-10-03 18:41:19 +00:00
S‹Ù� á � ãÿ � ëÿ? � û
@ƒø � }à««j � uà� }Ô¥¥¥‹5P„G � N � â � |…àj � � æ � L…à‹1‹ � L…à‹� r
j� |…à+È3Àó«ƒ}
P„G
3À� }à«««é
� � uÔ‹È� }ख़ƒâ � â � \� à‹3‹Î#ωMð‹ÊÓî‹Mü � MèZ+Î;Ð| � N � â � \…à‰Mð… � æ � L…à‹1� < ‹ � L…à‹� r
j� |…à+È3Àó«‹
T„G � â � \� à‹3‹Î#ωMð‹ÊÓî‹Mü � MèZ+Î;Ð| ‹
T„G � }à«««� Mà � â � \� à‹3‹Î#ωMð‹ÊÓî‹Mü � MèZ+Î;Ð|
\„G � � eàÿÿÿ � â � à‹Ï#ΉMð‹ÊÓï‹M � à‹}ð‹MüÓçÿE� MèZ+Î;Ð|
T„G � á
X„G
‹ ‹
ƒù u � � }à‰]Œ‰u˜‰]´‰]¨‰]¤‰] ‰]œ‰]°‰]”9]$u ‹
t
u � l9D ‹
ƒè ‹ � ( � Jj ´
ÿE´*È ‹ ´ ´ � Jþ‰M¬ŠÈ€é1€ù � Jÿ‰M¬tÂHHt²‹Ñƒ}¨ � ‰
YJƒù
� L1Ð� ùP � [ÿÿÿŠ � EÄPÿu´� EàPè ˜ � "
÷عЅG � � }¸¥¥¥ÿMº� ]¸
3À‰E°‰EÔ‰E؉EÜ‹E΋ñºÿ � æ � �
3À‰EȉEÄé � }ØÇE¨ � D� C � 4 �  � � Âÿÿ � Âÿÿ � áÿÿ � ù � ‰EÈ� á � Á � f‰EÄ‹E؉EÆ‹E܉EÊf‰UÎë
‹ ‹ � >3D ’ ˜ � Mðè05þÿ‹E ‹ ‹ � 'þÿYYëA
@f ‹ � H � E˜ � Fÿ‹È‹ÐÁù � €’G � þ23 � H� |0 � H� D0 � EÜP� E˜PSÿu � � EìPÿuÜÿ � }ð¥¥f¥‰MÔ‹M � t � EðP� EìSPèðhþÿƒÄ � ¿þÿƒÄ� EðPè � | � L ˆ � 4‹ � D‹
� EðPèø!þÿP� EðPÿ6è
SSSSSèë½þÿƒÄ� t
SSSSSèµ½þÿƒÄ
SSSSSè=½þÿƒÄ� t � EðPWVèwþþÿƒÄ
SSSSSè
SSSSSèã¼þÿƒÄ
SSSSSèÀ¼þÿƒÄ
j � MðèR.þÿ9]
½þÿƒÄ � MðQPèS¥þÿÿE� MðQPèA¥þÿƒÄ � } � EôPh
� EôPè^þÿÿY‹Mü3Íè± � MèQPÿÖ‹ � EèPÿu � þðÿÿ � D6 � ‹ � eÀ_^[‹Mü3Íèý� Mðè � u� }ð¥¥f¥‹Uø‹Ê¸ � âÿ � f…Ét
ˆ � þ
;ðu0…ÿu,hÔNE � C
VVVVVèz·þÿƒÄ � C
VVVVVèN·þÿƒÄ � � „
¸Ð…G � }Ä¥¥� EÄ¥ÿMƉE¼
3ɉM¬‰Mð‰Mô‰Mø‹Mê‹ò3ñ� æ � 4
´ � uôÇEÀ ‹ � L
àƒÀ �
;Âr � Ç � Çÿÿ � Çÿÿ � áÿÿ � ù � á � Á � ã � 4
‰]¤ � }ôÇEÀ � M؉M¸� D �
;Úr � Æ � � Æÿÿ � Æÿÿ � áÿÿ � ù � á � Á � ÆB
� îþ? � æÿ � G� Z � uà� }Ä¥¥¥Ñeà‹}àÑeàÁê � � 4 Áè � � <� F‹ � � 4?‰uà‹u¼‰MèÁé � KÿÿÿKŠ‹ � Æ@
€Â ˆP � ù
� á � ù
� ú � ú
;Ñu
@€ � Ê � Ê � Ê � ù � Ê � Ê � Ê
þÿÿ� Ê � Ê � Ê � Ê � á � ù � Ê � Ê � Ê � � ç � Î � ù � ù � Î � Î � Î
ƒè@u� Î � Î � Î � Ê � Ê
� Ê � éÀ
ƒé@u� Ê � Ê � Ê
‹ � }𥥥‹ÊÁé � <� � < � r‹ ‹ � � � < � � 4 � O � Eèðÿ � Eèÿÿ � 4?
‹Mü_^3Í[è � Mìè ‹ �
f �
f ‹ ‹ � I
äŠ
Àt#ƒÆ ‚ � Z � [ ´ � \ –
^ ´
$Authors: R. Ierusalimschy, L. H. de Figueiredo & W. Celes $
$URL: www.lua.org $
– ‘ – ’ ˜ � @ ¸ ’ � @ � @ � š@ � ¢@ � @h � Ò@ ˆ � TG ˜ � 7A � +A ˆ � VG ˜ ¸ ˆ � WG ˜ ´ ˆ � \A ´ ¸ � YA � R¢Fß‘? ˆ � ^G ˜ ´ � @
˜ ¸ � ÆA � ˆ � gG ´
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
- not enough space for locale information
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
- CRT not initialized
- unable to initialize heap
- not enough space for lowio initialization
- not enough space for stdio initialization
- pure virtual function call
- not enough space for _onexit/atexit table
- unable to open console device
- unexpected heap error
- unexpected multithread lock error
- not enough space for thread data
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
- not enough space for environment
- not enough space for arguments
- floating point support not loaded
Program: � � � � G � æ? � ã?
ã? � á? ’ � J= � ò„0= ´ � ÜÁ?Ltm«ŒYE= � › � dHÀÅ?h6_~ÔÅ(=
Ì?í⋱¼
Ñõ*D= � ²%Î � ¥CÒ?]Ôéèu› ˆ � ~ ×
šˆM= � ,ÙuXO= � 1w<=
� Ë–½´C=
âìÝ?ªŠí,lâC= � pnJ= � i†.Egú< � t€à?Û
Îx;Œ;= ‘ � � Ú¿S˜OOõ � Ï ¼I½ �
� ÓNT?½ � w3™kÕ¿rçº1À
Š¹ � Ó¿V
½ � l@ÙÑ¿2À§>× � 4ÆQ!½ � »„d+½ � „'½ � ôŽn¿¼]vQ<)8½
� ¿Mò´-·
Òc‘¿?ãOf¹èF½
ð?
ð?
ð?
ð?
ð?
ð?
ð?
ð?
9&\? � � � Úc?e2—·aþ1= � _:=
M=
t?,&ðš‚Ü8= ’ � òv?+†#� GYM= � òêE M= ˆ ˜ � ž!…O= � ’ � K_Ë<*= � x � ?x ‹ � ?ÁeÓï� fE= � ?K ‚ � ó!¢‚?Šõ)
K= � S7= ˆ › � üH½ › � ˜ � ¤]r¿æL‹Ãv� O½
È®À/N½
1ún¿
^!E½
-=½ � Ù¬zF+½ � ¶I � Ai0T¿� Wq
ÃWI½ � !H½ � O1¿²œO(Ï;>½
� � � � � � � � � � ¸ × � Œ—@=
€ï>� -= ¸
Àõ>b� ÷ß” ˜
€ø>Ôýá9ÎØO= ´ � ¸ ‚ ˜ × –
?Ûõs� ÓëA=
?’
?²
»á � E= � ’ � 3<L=
©rFÒˆK= ˜
‚ � � :ž+NB= × ‘ � ‚
v\ÏÀ4= � F€ � � ÚÍ\…0=
â'½É
qwúG= ‹ � M= � "º¹á � ÀD= � "?u � ? #?ô'œ—á¨A=
A= � Êr€ ‹ � $?áêÜ©Nó:= �
ˆ ¸
� ›á � � � »® � ï¶Õ?½ � ØI½ � B½ � †(+E ½ �
à� M½ �
ÍII½ � Öÿ � ן � 3½
¿!|.4
¿à¶„}‚ˆ3½
¿G"jm
>;½
¢:ŸO½
¿
¿»†¯ò¦°F½
¿ � Çv] � Ъ{•b>½ ‘ � A½ � ‡
/˜C½
<½ � 2ÇF½
½
æxE½
% › � q¼… � ¼t…´ � <ÞöÝ)kpð?&<±âß‘Œ¼È›u‘
aÜJ.¦˜<÷Gr+’Ìð?qOâ � <¢ÑÓ2ìãð?R{Å'‚ ¸ � � ¼ê� Œ8ùŠñ?k � uÇ� <–Ü}‘ � cõáß„ò?}
?Œ:Lš¼áÞ � žò?U� ÙÚÐ
A¼ � <V/>©¯ìò?ƒ#ÕE
þ� •ž¼÷Ÿå4Û§ó?âõaÖ6äu¼å¨
� ¼-‰a`› � ¶£Ás<ÞÓ×ð*£ô?V¾ÑóbË™<'*6ÕÚ¿ô?âB쯗C}<
Ýý™²Üô?3xj¼Ûì˜<§,� v²ùô?ãWYÒ ³”¼BfÏ¢Ú� ¼‚O� V+4õ?¬<± � ¼Ú'µ6Goõ?¬“ � õ?ç – � � u<HŒ¼%"U‚ � ö?d>÷D®8`<Í; � ¼t� ¥Hš?÷?;ÕelÙ¨� ¼ÉgBVë_÷?Óm1WY$� ¼?]ÞOi€÷?,
¸ � ¼Ç#F � ¼åÅÍ°77ù?»~µ� Ç_g¼� ¼º� 𣂑Äù?¾òq°F||<##ã – � Ûn/� ¼X³0� <zóÓ¿kÃú?ÐlçÊ4’� ¼ÓZ™Ÿèú?� Ì]4Í¡—<f¶� )� rYû?ãmº»ßqœ¼G^ûòv � � <zÐÿ_«@ü?
ƃà7E› � ü?D\€H¼¬q<i� ïÜ ·ü?ÛIéÑË � ‚ � ¼|‰
� q{H� ¼‡¤ûÜ ´ – � '¶—¼ö?‹ç.Pþ?� Ì©€‰žƒ<ƒLÇûQzþ?á� � ¤¢¯¤þ?“(œ� <—ºk7+%ÿ?CŽ
¿¥¡“<@En[vPÿ?Š¡Ø-áÓ™<� ¼Ø� ž� Á§ÿ? � +ÂÓÿ?çye–
`B¢� Yóø � tan ´ � “ê � Òu¼
^<
Í¿Ö � � ¿±½€ñ²8ì? � 2Ïk� í? � Øï? � Øï? � 2Ïk� í? � � ?±½€ñ²8ì?
Í?Ö ‹
^< � “ê � Òu¼ ´ ´ � “ê � Òu<
^¼
Í?Ö � � ?±½€ñ²8ì¿ � 2Ïk� í¿ � Øï¿ ˆ � Øï¿ ˆ � 2Ïk� í¿ � � ¿±½€ñ²8ì¿
Í¿Ö
^¼ � “ê � Òu< ´ � ?UUUUUU¥? ´ � = ´ � = ´ � “ê � Òu¼
^<
Í¿Ö � � ¿±½€ñ²8ì? � 2Ïk� í? � Øï? � Øï? � 2Ïk� í? � � ?±½€ñ²8ì?
Í?Ö ‹
^<
΂³«?&1� ˜Hš?,ò³Àb”Å?¸¤ƒ ‘ ˜ � ‹ � ×ô � � ù·*¸aå?ñ}œ Ũ‡< – � Z°ª � a
g � Ô ¸ ¸ – – –
@à}
¿éŸä#ŒZ«¿."S-
ö>Q” � ØZS “+¿ � ‚
C¤U¿äxÙß × � ?c3y¿êÆŸ0Ö� ¾³g\>{ÐO¿>>� šu½†>¤·¾¤± �  � ¨>Ï)¼Ú(‚g?¸¯‰’Vô� ¾í´ � ˆ‹VÐ>|� 2? � D � � k£ãt¾ � k � Ã>õCÔ‘ � “oPè"Q¿?Ôm˹A� >ÿ²˜fÇ°a?+ñkWŠZb¾Üé å� I#¿Ý„ � jö> � >g × � Ã>õCÔ‘ � “oPè"Q??Ôm˹A� >ÿ²˜fÇ°a?+ñkWŠZb>Üé å� I#?Ý„ � D – ˜ ‹ � � k£ãt> � k ’ � ˆ‹VÐ>|� 2? �  � ¨>Ï)¼Ú(‚g?¸¯‰’Vô� >í´ � ?c3y?êÆŸ0Ö� >³g\>{ÐO?>>� šu½†>¤·¾¤± � ØZS “+? � ‚
C¤U?äxÙß ×
?éŸä#ŒZ«?."S-
ö>Q” ´ –
Àà} – � Z°ª � a
g � Ô ¸ ¸ � ×ô � � ù·*¸aå¿ñ}œ Ũ‡¼ � ‹?3™ä?
΂³«?&1� ˜Hš¿,ò³Àb”Å¿¸¤ƒ � ¿ø¥,ÖÙwÊ¿(F_³e¢—?úX2CQÏØ? Ù� µãˆ� ¿ê � ˆ?#§(À › › ˆ
ß
¼"°? � 1y"ã°?ú ¸ �
lc±?
£“Ôx²à< × � ¼
0 � $³?]U ‹ ›
å³?)0>¯BË< ´ � I&³< ´ × � »¿Ä< � 2;¯j¹? ˜ � � ¾ ‚ � X[F´ � .¼?XŽ � Ùôn¼?ÛT©(� +å< – � � ¦>t¿?
—;õ¿?S
Ý< � ¬
ß< � {Ð¥/Â?$¨8 � ÿ< � Èùg
×< � õ< � ó1—<Æ?Væ Ú€
ç1 � Ç?„¨.a � I•¨ˆôÒ<
TÈ<
Ê?ïWm¨Ü`Ï<
Xw·� Ê?ЀYÞ �
UË?£\çz#� ÷< � –Ë?1¼ � Y']ã< ’
eåÍ?>U× � †ø � Ð?� ð ˆ � 6‡
= � tÞ>á< ˜ � ð< � CòÓ?jü � [ô9 � Ã<
ܬ_ì< � Z‡Õ?È¡‰k � *+xi(æ<
ly
‡jý< � åÙã< � ÛÖ?
= ˜ � – � ©ìFÙ?É•Œ«á{¾< � F]Ú?¼� §&µâ ˜
T9éÚ?9*Ë � )ý< ˆ � ‹ � Ü?ߪ€®
j�
=
IöxÜ< ˜ › �
ÉðR
= � °´Ïä?“Aå8‹ ’
u´
=
û§Õ<
� î?k × � ¦ � »ïï?#� DZ9ïï?ÅÖÚ � ìï?M� ð€� � èï?ìët«äçï?{}Š2Fçï?Éüõ´¥æï?_ó˜2 � �
Ýï?� ºõÔKÜï??� .� ž;E<Ùï?ÊfSOsØï?ÄJîQ¨×ï?’
:Ãï?ó� 1(>Âï? � r¼¾ï?6…Š4°¼ï?÷
¤ï?vˆ
S’ï?V©êÑ©� ï?ß–%@øŒï?� ï? ˜ � ‚ ‹ ´ � (Ëüb;ï?†íƒ¿Ì7ï?ˆ � h†0ï? ‚
ï?ÍóÆ$
9Rïî?%’çRÈæî?F¯£ã � î?7¡� ¡“î?Ÿ'³¹®‰î?“VG �
¡MU‰í?Ìzª
Q-� ˜
í?� 1_ú×ûì?$*2 � ^\sY0ë?:Rp£7’ � ól ›
ƒS/©»ä?½£yx|oä?Pž6 d!ä? � ýÓ²§*ã?
TÚÇçÓâ?ñÜó!³zâ?Ø � ®0ˆVÀá?ˆ8 � |ÓÈ•Û?,"¾çQƒÚ?ë/˜
pâíè•Õ?V� aº®"Ô?º � Ò?Pqëj
¼"°? � 1y"ã°?ú ¸ �
lc±?
£“Ôx²à< × � ¼
0 � $³?]U ‹ ›
å³?)0>¯BË< ´ � I&³< ´ × � »¿Ä< � 2;¯j¹? ˜ � � ¾ ‚ � X[F´ � .¼?XŽ � Ùôn¼?ÛT©(� +å< – � � ¦>t¿?
—;õ¿?S
Ý< � ¬
ß< � {Ð¥/Â?$¨8 � ÿ< � Èùg
×< � õ< � ó1—<Æ?Væ Ú€
ç1 � Ç?„¨.a � I•¨ˆôÒ<
TÈ<
Ê?ïWm¨Ü`Ï<
Xw·� Ê?ЀYÞ �
UË?£\çz#� ÷< � –Ë?1¼ � Y']ã< ’
eåÍ?>U× � †ø � Ð?� ð ˆ � 6‡
= � tÞ>á< ˜ � ð< � CòÓ?jü � [ô9 � Ã<
ܬ_ì< � Z‡Õ?È¡‰k � *+xi(æ<
ly
‡jý< � åÙã< � ÛÖ?
= ˜ � – � ©ìFÙ?É•Œ«á{¾< � F]Ú?¼� §&µâ ˜
T9éÚ?9*Ë � )ý< ˆ � ‹ � Ü?ߪ€®
j�
=
IöxÜ< ˜ › �
ÉðR
= � °´Ïä?“Aå8‹ ’
u´
=
û§Õ<
� î?k × � ¦ � »ïï?#� DZ9ïï?ÅÖÚ � ìï?M� ð€� � èï?ìët«äçï?{}Š2Fçï?Éüõ´¥æï?_ó˜2 � �
Ýï?� ºõÔKÜï??� .� ž;E<Ùï?ÊfSOsØï?ÄJîQ¨×ï?’
:Ãï?ó� 1(>Âï? � r¼¾ï?6…Š4°¼ï?÷
¤ï?vˆ
S’ï?V©êÑ©� ï?ß–%@øŒï?� ï? ˜ � ‚ ‹ ´ � (Ëüb;ï?†íƒ¿Ì7ï?ˆ � h†0ï? ‚
ï?ÍóÆ$
9Rïî?%’çRÈæî?F¯£ã � î?7¡� ¡“î?Ÿ'³¹®‰î?“VG �
¡MU‰í?Ìzª
Q-� ˜
í?� 1_ú×ûì?$*2 � ^\sY0ë?:Rp£7’ � ól ›
ƒS/©»ä?½£yx|oä?Pž6 d!ä? � ýÓ²§*ã?
TÚÇçÓâ?ñÜó!³zâ?Ø � ®0ˆVÀá?ˆ8 � |ÓÈ•Û?,"¾çQƒÚ?ë/˜
pâíè•Õ?V� aº®"Ô?º � Ò?Pqëj
9±³¿ � $IÂ?� – � B� B
˜IÂ? � ? › › ´ ‹ � Ì?n � #8= � )Ò?™ü©}z¯ �
¢ú°5= ˆ � ˆ � wÎ,=
> � á?h¢¤…Xg+= � ºX › � B� B � )d “
¨ � W‹ � ñb6 � >ª?†ÓÐÈWÒ!= � wk·?zn ‚ ´ ‚ � ó � ¿?§w·¢¥Ž*= � � 2=
Á?®ðƒËEŠ
Çõ0= ´ � � Æ?Й–ü,”í< � ‘Ì?r¬æ”F¶ � � 1= � � õë = � ”vX �
Ð? ¸ � Jé5= � ñö � i ¸ ¸ ¸ ¸ ˜ � � � ?Z¤fUUUÅ?€íì&WU¥?{áÿÿÿÿß? ¸ � æDAoŠ<ÖŒbˆ ˜ � ž
þ � <ÿ ‹ ‹ ’ � %F¸¨<).÷!
� v<'*6ÕÚ¿ � v²ù � O� V+4 � <)THÝ
Œð™„ ‚
M� ™<Ì;
o ’ � <Û *Bå¬ � ð£‚‘Ä ›
–
×ÿt<ÒÁK� � à„<KÑW.ñg ’ � ïÜ ·
›
’ ‘ � ¤¢¯¤ � Í‘M;‰w<Ø� ž� Á§ � � � � � � � � � � � � � ‚ƒ„…†‡ˆ‰Š‹Œ� Ž� � ‘’“”•–—˜™š›œ� žŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
� ‚ƒ„…†‡ˆ‰Š‹Œ� Ž� � ‘’“”•–—˜™š›œ� žŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€� ‚ƒ„…†‡ˆ‰Š‹Œ� Ž� � ‘’“”•–—˜™š›œ� žŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
� ‚ƒ„…†‡ˆ‰Š‹Œ� Ž� � ‘’“”•–—˜™š›œ� žŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿunited-states ´ � 2E ¸ ¸ ˆ ˜ ˆ ´ ˆ � € ˆ ¸ � wB%±Kí= ´ ˆ ¸
‹MÌø= × � Ë?"ö" � Û*Ö
È ˜ � Ô
Ü?dŒÏøžì ˜
ã � h÷Æ � —ä?¨ � ç?"¨ � ¿:> � ê?
Gì?Üaj èi9> ˆ �
� ‹ ˆ ¸ ‹ � Óð?Ý#/¤'è � ?> ‚ � á¶ñ?Íhc#ò]G>
çF> � R®.N> � ¤¾½7>
6Üf=> ‚ ‚ ¸
@> ¸ ˜ � ó? › � šK>
@
@
@
@ � ô?ßûÀsñ
@> ¸
@
@
@ ˜
@ � öô?>Ÿ&»09C>
”û<ÅA> � – ‘
È‚§q«;> ‘ � ‰õ?o� ÕäoJ> � õ?ð÷Û-©„#> � _!
¾#>
~½Úú= ¸ � m…T2> ¸ � $> � A� ŒÍD> ‘ ˜ � ØÃ-> � /> � Ú ‘ � µ”¸f7O> ‹
i– ˆ � ×ä= � ÈÂJ¼K> › � ;> � /pÃ"> � 5GÈ5> � Úùé� 6:> ˆ × × × � ðö?� …j^ÿ � 0> – ‹
>> ˜ � ³è¼@¤M � B
‘B � ÃB �
C
C
BC ‚ � Z � [ ´ � \ –
^ ´ � ’ × � ‘ ‚
usage: tolua++ [options] input_file
Command line options are:
-v : print version information.
-o file : set output file; default is stdout.
-H file : create include file.
-n name : set package name; default is input file root name.
-p : parse only.
-P : parse and print structure information (for debug).
-S : disable support for c++ strings.
-1 : substract 1 to operator[] index (for compatibility with tolua5).
-L file : run lua file (with dofile()) before doing anything.
-D : disable automatic exporting of destructors for classes that have
constructors (for compatibility with tolua5)
-W : disable warnings for unsupported features (for compatibility
with tolua5)
-C : disable cleanup of included lua code (for easier debugging)
-E value[=value] : add extra values to the luastate
-t : export a list of types asociates with the C++ typeid name
-q : don't print warnings to the console
-h : print this message.
Should the input file be omitted, stdin is assumed;
in that case, the package name must be explicitly set.
argument #%d is array of '%s'; array of '%s' expected.
argument #%d is '%s'; '%s' expected.
value is array of '%s'; array of '%s' expected.
value is '%s'; '%s' expected.
return
end
-- "loadfile"
local function pp_dofile(path)
local loaded = false
local getfile = function()
if loaded then
return
2012-06-04 14:58:17 +00:00
else
2011-10-03 18:41:19 +00:00
local file,err = io.open(path)
if not file then
error("error loading file "..path..": "..err)
end
local ret = file:read("*a")
file:close()
ret = string.gsub(ret, "%.%.%.%s*%)", "...) local arg = {n=select('#', ...), ...};")
loaded = true
return ret
end
end
local f = load(getfile, path)
if not f then
error("error loading file "..path)
end
return f()
end
old_dofile = dofile
dofile = pp_dofile
-- string.gsub
--[[
local ogsub = string.gsub
local function compgsub(a,b,c,d)
if type(c) == "function" then
local oc = c
c = function (...) return oc(...) or '' end
end
return ogsub(a,b,c,d)
end
string.repl = ogsub
--]]
--string.gsub = compgsub
-- Real globals
-- _ALERT
-- _ERRORMESSAGE
-- _VERSION
-- _G
-- assert
-- error
-- metatable
-- next
-- print
-- require
-- tonumber
-- tostring
-- type
-- unpack
-------------------------------------------------------------------
-- collectgarbage
-- gcinfo
-- globals
-- call -> protect(f, err)
-- loadfile
-- loadstring
-- rawget
-- rawset
-- getargs = Main.getargs ??
rawtype = type
function do_ (f, err)
if not f then print(err); return end
local a,b = pcall(f)
if not a then print(b); return nil
else return b or true
end
end
function dostring(s) return do_(loadstring(s)) end
-- function dofile(s) return do_(loadfile(s)) end
-------------------------------------------------------------------
-- Table library
local tab = table
foreach = tab.foreach
foreachi = tab.foreachi
getn = tab.getn
tinsert = tab.insert
tremove = tab.remove
sort = tab.sort
-------------------------------------------------------------------
-- Debug library
local dbg = debug
getinfo = dbg.getinfo
getlocal = dbg.getlocal
setcallhook = function () error"`setcallhook' is deprecated" end
setlinehook = function () error"`setlinehook' is deprecated" end
setlocal = dbg.setlocal
-------------------------------------------------------------------
-- math library
local math = math
abs = math.abs
acos = function (x) return math.deg(math.acos(x)) end
asin = function (x) return math.deg(math.asin(x)) end
atan = function (x) return math.deg(math.atan(x)) end
atan2 = function (x,y) return math.deg(math.atan2(x,y)) end
ceil = math.ceil
cos = function (x) return math.cos(math.rad(x)) end
deg = math.deg
exp = math.exp
floor = math.floor
frexp = math.frexp
ldexp = math.ldexp
log = math.log
log10 = math.log10
max = math.max
min = math.min
mod = math.mod
PI = math.pi
--??? pow = math.pow
rad = math.rad
random = math.random
randomseed = math.randomseed
sin = function (x) return math.sin(math.rad(x)) end
sqrt = math.sqrt
tan = function (x) return math.tan(math.rad(x)) end
-------------------------------------------------------------------
-- string library
local str = string
2012-06-04 14:58:17 +00:00
strbyte = str.byte
2011-10-03 18:41:19 +00:00
strchar = str.char
strfind = str.find
format = str.format
gsub = str.gsub
strlen = str.len
strlower = str.lower
strrep = str.rep
strsub = str.sub
strupper = str.upper
-------------------------------------------------------------------
-- os library
clock = os.clock
date = os.date
difftime = os.difftime
execute = os.execute --?
exit = os.exit
getenv = os.getenv
remove = os.remove
rename = os.rename
setlocale = os.setlocale
time = os.time
tmpname = os.tmpname
-------------------------------------------------------------------
-- compatibility only
getglobal = function (n) return _G[n] end
setglobal = function (n,v) _G[n] = v end
-------------------------------------------------------------------
local io, tab = io, table
-- IO library (files)
_STDIN = io.stdin
_STDERR = io.stderr
_STDOUT = io.stdout
_INPUT = io.stdin
_OUTPUT = io.stdout
seek = io.stdin.seek -- sick ;-)
tmpfile = io.tmpfile
closefile = io.close
openfile = io.open
function flush (f)
if f then f:flush()
else _OUTPUT:flush()
end
end
function readfrom (name)
if name == nil then
local f, err, cod = io.close(_INPUT)
_INPUT = io.stdin
return f, err, cod
else
local f, err, cod = io.open(name, "r")
_INPUT = f or _INPUT
return f, err, cod
end
end
function writeto (name)
if name == nil then
local f, err, cod = io.close(_OUTPUT)
_OUTPUT = io.stdout
return f, err, cod
else
local f, err, cod = io.open(name, "w")
_OUTPUT = f or _OUTPUT
return f, err, cod
end
end
2012-06-04 14:58:17 +00:00
function appendto (name)
2011-10-03 18:41:19 +00:00
local f, err, cod = io.open(name, "a")
_OUTPUT = f or _OUTPUT
return f, err, cod
end
function read (...)
local f = _INPUT
if rawtype(arg[1]) == 'userdata' then
f = tab.remove(arg, 1)
end
return f:read(unpack(arg))
end
function write (...)
local f = _OUTPUT
if rawtype(arg[1]) == 'userdata' then
f = tab.remove(arg, 1)
end
return f:write(unpack(arg))
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- Last update: Apr 2003
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Basic C types and their corresponding Lua types
-- All occurrences of "char*" will be replaced by "_cstring",
-- and all occurrences of "void*" will be replaced by "_userdata"
_basic = {
['void'] = '',
['char'] = 'number',
['int'] = 'number',
['short'] = 'number',
['long'] = 'number',
['unsigned'] = 'number',
['float'] = 'number',
['double'] = 'number',
['_cstring'] = 'string',
['_userdata'] = 'userdata',
['char*'] = 'string',
['void*'] = 'userdata',
['bool'] = 'boolean',
['lua_Object'] = 'value',
['LUA_VALUE'] = 'value', -- for compatibility with tolua 4.0
['lua_State*'] = 'state',
['_lstate'] = 'state',
['lua_Function'] = 'value',
}
_basic_ctype = {
number = "lua_Number",
string = "const char*",
userdata = "void*",
boolean = "bool",
value = "int",
state = "lua_State*",
}
-- functions the are used to do a 'raw push' of basic types
_basic_raw_push = {}
-- List of user defined types
-- Each type corresponds to a variable name that stores its tag value.
_usertype = {}
-- List of types that have to be collected
_collect = {}
-- List of types
_global_types = {n=0}
_global_types_hash = {}
-- list of classes
_global_classes = {}
-- List of enum constants
_global_enums = {}
-- List of auto renaming
_renaming = {}
function appendrenaming (s)
local b,e,old,new = strfind(s,"%s*(.-)%s*@%s*(.-)%s*$")
if not b then
error("#Invalid renaming syntax; it should be of the form: pattern@pattern")
end
tinsert(_renaming,{old=old, new=new})
end
function applyrenaming (s)
for i=1,getn(_renaming) do
local m,n = gsub(s,_renaming[i].old,_renaming[i].new)
if n ~= 0 then
return m
end
2012-06-04 14:58:17 +00:00
end
2011-10-03 18:41:19 +00:00
return nil
end
-- Error handler
function tolua_error (s,f)
if _curr_code then
print("***curr code for error is "..tostring(_curr_code))
print(debug.traceback())
end
local out = _OUTPUT
_OUTPUT = _STDERR
if strsub(s,1,1) == '#' then
write("\n** tolua: "..strsub(s,2)..".\n\n")
if _curr_code then
local _,_,s = strfind(_curr_code,"^%s*(.-\n)") -- extract first line
if s==nil then s = _curr_code end
s = gsub(s,"_userdata","void*") -- return with 'void*'
s = gsub(s,"_cstring","char*") -- return with 'char*'
s = gsub(s,"_lstate","lua_State*") -- return with 'lua_State*'
write("Code being processed:\n"..s.."\n")
end
else
if not f then f = "(f is nil)" end
print("\n** tolua internal error: "..f..s..".\n\n")
return
end
_OUTPUT = out
end
function warning (msg)
if flags.q then return end
local out = _OUTPUT
_OUTPUT = _STDERR
write("\n** tolua warning: "..msg..".\n\n")
_OUTPUT = out
end
-- register an user defined type: returns full type
function regtype (t)
--if isbasic(t) then
-- return t
--end
local ft = findtype(t)
if not _usertype[ft] then
return appendusertype(t)
end
return ft
end
-- return type name: returns full type
function typevar(type)
if type == '' or type == 'void' then
return type
else
local ft = findtype(type)
if ft then
return ft
end
_usertype[type] = type
return type
end
end
-- check if basic type
function isbasic (type)
local t = gsub(type,'const ','')
2012-06-04 14:58:17 +00:00
local m,t = applytypedef('', t)
2011-10-03 18:41:19 +00:00
local b = _basic[t]
if b then
return b,_basic_ctype[b]
end
return nil
end
-- split string using a token
function split (s,t)
local l = {n=0}
local f = function (s)
l.n = l.n + 1
l[l.n] = s
return ""
end
local p = "%s*(.-)%s*"..t.."%s*"
s = gsub(s,"^%s+","")
s = gsub(s,"%s+$","")
s = gsub(s,p,f)
l.n = l.n + 1
l[l.n] = gsub(s,"(%s%s*)$","")
return l
end
-- splits a string using a pattern, considering the spacial cases of C code (templates, function parameters, etc)
-- pattern can't contain the '^' (as used to identify the begining of the line)
-- also strips whitespace
function split_c_tokens(s, pat)
s = string.gsub(s, "^%s*", "")
s = string.gsub(s, "%s*$", "")
local token_begin = 1
local token_end = 1
local ofs = 1
local ret = {n=0}
function add_token(ofs)
local t = string.sub(s, token_begin, ofs)
t = string.gsub(t, "^%s*", "")
t = string.gsub(t, "%s*$", "")
ret.n = ret.n + 1
ret[ret.n] = t
end
while ofs <= string.len(s) do
local sub = string.sub(s, ofs, -1)
local b,e = string.find(sub, "^"..pat)
if b then
add_token(ofs-1)
ofs = ofs+e
token_begin = ofs
else
local char = string.sub(s, ofs, ofs)
if char == "(" or char == "<" then
local block
if char == "(" then block = "^%b()" end
if char == "<" then block = "^%b<>" end
b,e = string.find(sub, block)
if not b then
-- unterminated block?
ofs = ofs+1
else
ofs = ofs + e
end
else
ofs = ofs+1
end
end
end
add_token(ofs)
--if ret.n == 0 then
-- ret.n=1
-- ret[1] = ""
--end
return ret
end
-- concatenate strings of a table
function concat (t,f,l,jstr)
jstr = jstr or " "
local s = ''
local i=f
while i<=l do
s = s..t[i]
i = i+1
if i <= l then s = s..jstr end
end
return s
end
-- concatenate all parameters, following output rules
function concatparam (line, ...)
local i=1
while i<=arg.n do
if _cont and not strfind(_cont,'[%(,"]') and
strfind(arg[i],"^[%a_~]") then
line = line .. ' '
end
line = line .. arg[i]
if arg[i] ~= '' then
_cont = strsub(arg[i],-1,-1)
end
i = i+1
end
if strfind(arg[arg.n],"[%/%)%;%{%}]$") then
_cont=nil line = line .. '\n'
end
return line
end
-- output line
function output (...)
local i=1
while i<=arg.n do
if _cont and not strfind(_cont,'[%(,"]') and
strfind(arg[i],"^[%a_~]") then
write(' ')
end
write(arg[i])
if arg[i] ~= '' then
_cont = strsub(arg[i],-1,-1)
end
i = i+1
end
if strfind(arg[arg.n],"[%/%)%;%{%}]$") then
_cont=nil write('\n')
end
end
function get_property_methods(ptype, name)
if get_property_methods_hook and get_property_methods_hook(ptype,name) then
return get_property_methods_hook(ptype, name)
end
if ptype == "default" then -- get_name, set_name
return "get_"..name, "set_"..name
end
if ptype == "qt" then -- name, setName
return name, "set"..string.upper(string.sub(name, 1, 1))..string.sub(name, 2, -1)
end
if ptype == "overload" then -- name, name
return name,name
end
return nil
end
-------------- the hooks
-- called right after processing the $[ichl]file directives,
-- right before processing anything else
-- takes the package object as the parameter
function preprocess_hook(p)
-- p.code has all the input code from the pkg
end
-- called for every $ifile directive
-- takes a table with a string called 'code' inside, the filename, and any extra arguments
-- passed to $ifile. no return value
function include_file_hook(t, filename, ...)
end
-- called after processing anything that's not code (like '$renaming', comments, etc)
-- and right before parsing the actual code.
-- takes the Package object with all the code on the 'code' key. no return value
function preparse_hook(package)
end
-- called before starting output
function pre_output_hook(package)
end
-- called after writing all the output.
-- takes the Package object
function post_output_hook(package)
end
-- called from 'get_property_methods' to get the methods to retrieve a property
-- according to its type
function get_property_methods_hook(property_type, name)
end
-- called from ClassContainer:doparse with the string being parsed
-- return nil, or a substring
function parser_hook(s)
return nil
end
-- called from classFunction:supcode, before the call to the function is output
function pre_call_hook(f)
end
-- called from classFunction:supcode, after the call to the function is output
function post_call_hook(f)
end
-- called before the register code is output
function pre_register_hook(package)
end
-- called to output an error message
function output_error_hook(...)
return string.format(...)
end
-- custom pushers
_push_functions = {}
_is_functions = {}
_to_functions = {}
_base_push_functions = {}
_base_is_functions = {}
_base_to_functions = {}
local function search_base(t, funcs)
local class = _global_classes[t]
while class do
if funcs[class.type] then
return funcs[class.type]
end
class = _global_classes[class.btype]
end
return nil
end
function get_push_function(t)
return _push_functions[t] or search_base(t, _base_push_functions) or "tolua_pushusertype"
end
function get_to_function(t)
return _to_functions[t] or search_base(t, _base_to_functions) or "tolua_tousertype"
end
function get_is_function(t)
return _is_functions[t] or search_base(t, _base_is_functions) or "tolua_isusertype"
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Feature class
-- Represents the base class of all mapped feature.
classFeature = {
}
classFeature.__index = classFeature
-- write support code
function classFeature:supcode ()
end
-- output tag
function classFeature:decltype ()
end
-- register feature
function classFeature:register (pre)
end
-- translate verbatim
function classFeature:preamble ()
end
-- check if it is a variable
function classFeature:isvariable ()
return false
end
-- check if it requires collection
function classFeature:requirecollection (t)
return false
end
-- build names
function classFeature:buildnames ()
if self.name and self.name~='' then
local n = split(self.name,'@')
self.name = n[1]
self.name = string.gsub(self.name, ":%d*$", "")
if not n[2] then
n[2] = applyrenaming(n[1])
end
self.lname = n[2] or gsub(n[1],"%[.-%]","")
self.lname = string.gsub(self.lname, ":%d*$", "")
self.original_name = self.name
self.lname = clean_template(self.lname)
end
if not self.is_parameter then
self.name = getonlynamespace() .. self.name
end
local parent = classContainer.curr
if parent then
self.access = parent.curr_member_access
self.global_access = self:check_public_access()
else
end
end
function classFeature:check_public_access()
if type(self.global_access) == "boolean" then
return self.global_access
end
if self.access and self.access ~= 0 then
return false
end
local parent = classContainer.curr
while parent do
if parent.access and parent.access ~= 0 then
return false
end
parent = parent.prox
end
return true
end
function clean_template(t)
return string.gsub(t, "[<>:, %*]", "_")
end
-- check if feature is inside a container definition
-- it returns the container class name or nil.
function classFeature:incontainer (which)
if self.parent then
local parent = self.parent
while parent do
if parent.classtype == which then
return parent.name
end
parent = parent.parent
end
end
return nil
end
function classFeature:inclass ()
return self:incontainer('class')
end
function classFeature:inmodule ()
return self:incontainer('module')
end
function classFeature:innamespace ()
return self:incontainer('namespace')
end
-- return C binding function name based on name
-- the client specifies a prefix
function classFeature:cfuncname (n)
if self.parent then
n = self.parent:cfuncname(n)
end
local fname = self.lname
if not fname or fname == '' then
fname = self.name
end
n = string.gsub(n..'_'.. (fname), "[<>:, \.%*&]", "_")
return n
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: verbatim.lua,v 1.3 2000/01/24 20:41:16 celes Exp $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Verbatim class
-- Represents a line translated directed to the binding file.
-- The following filds are stored:
-- line = line text
classVerbatim = {
line = '',
cond = nil, -- condition: where to generate the code (s=suport, r=register)
}
classVerbatim.__index = classVerbatim
setmetatable(classVerbatim,classFeature)
-- preamble verbatim
function classVerbatim:preamble ()
if self.cond == '' then
write(self.line)
end
end
-- support code
function classVerbatim:supcode ()
if strfind(self.cond,'s') then
write(self.line)
write('\n')
end
end
-- register code
function classVerbatim:register (pre)
if strfind(self.cond,'r') then
write(self.line)
end
end
-- Print method
function classVerbatim:print (ident,close)
print(ident.."Verbatim{")
print(ident.." line = '"..self.line.."',")
print(ident.."}"..close)
end
-- Internal constructor
function _Verbatim (t)
setmetatable(t,classVerbatim)
append(t)
return t
end
-- Constructor
-- Expects a string representing the text line
function Verbatim (l,cond)
if strsub(l,1,1) == "'" then
l = strsub(l,2)
elseif strsub(l,1,1) == '$' then
cond = 'sr' -- generates in both suport and register fragments
l = strsub(l,2)
end
return _Verbatim {
line = l,
cond = cond or '',
}
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1999
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- global
code_n = 1
-- Code class
-- Represents Lua code to be compiled and included
-- in the initialization function.
-- The following fields are stored:
-- text = text code
classCode = {
text = '',
}
classCode.__index = classCode
setmetatable(classCode,classFeature)
-- register code
function classCode:register (pre)
pre = pre or ''
-- clean Lua code
local s = clean(self.text)
if not s then
--print(self.text)
error("parser error in embedded code")
end
-- get first line
local _, _, first_line=string.find(self.text, "^([^\n\r]*)")
if string.find(first_line, "^%s*%-%-") then
if string.find(first_line, "^%-%-##") then
first_line = string.gsub(first_line, "^%-%-##", "")
if flags['C'] then
s = string.gsub(s, "^%-%-##[^\n\r]*\n", "")
end
end
else
first_line = ""
end
-- pad to 16 bytes
local npad = 16 - (#s % 16)
local spad = ""
for i=1,npad do
spad = spad .. "-"
end
s = s..spad
-- convert to C
output('\n'..pre..'{ /* begin embedded lua code */\n')
output(pre..' int top = lua_gettop(tolua_S);')
output(pre..' static const unsigned char B[] = {\n ')
local t={n=0}
local b = gsub(s,'(.)',function (c)
local e = ''
t.n=t.n+1 if t.n==15 then t.n=0 e='\n'..pre..' ' end
return format('%3u,%s',strbyte(c),e)
end
)
output(b..strbyte(" "))
output('\n'..pre..' };\n')
if first_line and first_line ~= "" then
output(pre..' tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua embedded: '..first_line..'");')
else
output(pre..' tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code '..code_n..'");')
end
output(pre..' lua_settop(tolua_S, top);')
output(pre..'} /* end of embedded lua code */\n\n')
code_n = code_n +1
end
-- Print method
function classCode:print (ident,close)
print(ident.."Code{")
print(ident.." text = [["..self.text.."]],")
print(ident.."}"..close)
end
-- Internal constructor
function _Code (t)
setmetatable(t,classCode)
append(t)
return t
end
-- Constructor
-- Expects a string representing the code text
function Code (l)
return _Code {
text = l
}
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Typedef class
-- Represents a type synonym.
-- The 'de facto' type replaces the typedef before the
-- remaining code is parsed.
-- The following fields are stored:
-- utype = typedef name
-- type = 'the facto' type
-- mod = modifiers to the 'de facto' type
classTypedef = {
utype = '',
mod = '',
type = ''
}
classTypedef.__index = classTypedef
-- Print method
function classTypedef:print (ident,close)
print(ident.."Typedef{")
print(ident.." utype = '"..self.utype.."',")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.."}"..close)
end
-- Return it's not a variable
function classTypedef:isvariable ()
return false
end
-- Internal constructor
function _Typedef (t)
setmetatable(t,classTypedef)
t.type = resolve_template_types(t.type)
appendtypedef(t)
return t
end
-- Constructor
-- Expects one string representing the type definition.
function Typedef (s)
if strfind(string.gsub(s, '%b<>', ''),'[%*&]') then
tolua_error("#invalid typedef: pointers (and references) are not supported")
end
local o = {mod = ''}
if string.find(s, "[<>]") then
_,_,o.type,o.utype = string.find(s, "^%s*([^<>]+%b<>[^%s]*)%s+(.-)$")
else
local t = split(gsub(s,"%s%s*"," ")," ")
o = {
utype = t[t.n],
type = t[t.n-1],
mod = concat(t,1,t.n-2),
}
end
return _Typedef(o)
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- table to store namespaced typedefs/enums in global scope
global_typedefs = {}
global_enums = {}
-- Container class
-- Represents a container of features to be bound
-- to lua.
classContainer =
{
curr = nil,
}
classContainer.__index = classContainer
setmetatable(classContainer,classFeature)
-- output tags
function classContainer:decltype ()
push(self)
local i=1
while self[i] do
self[i]:decltype()
i = i+1
end
pop()
end
-- write support code
function classContainer:supcode ()
if not self:check_public_access() then
return
end
push(self)
local i=1
while self[i] do
if self[i]:check_public_access() then
self[i]:supcode()
end
i = i+1
end
pop()
end
function classContainer:hasvar ()
local i=1
while self[i] do
if self[i]:isvariable() then
return 1
end
i = i+1
end
return 0
end
-- Internal container constructor
function _Container (self)
setmetatable(self,classContainer)
self.n = 0
self.typedefs = {tolua_n=0}
self.usertypes = {}
self.enums = {tolua_n=0}
self.lnames = {}
return self
end
-- push container
function push (t)
t.prox = classContainer.curr
classContainer.curr = t
end
-- pop container
function pop ()
--print("name",classContainer.curr.name)
--foreach(classContainer.curr.usertypes,print)
--print("______________")
classContainer.curr = classContainer.curr.prox
end
-- get current namespace
function getcurrnamespace ()
return getnamespace(classContainer.curr)
end
-- append to current container
function append (t)
return classContainer.curr:append(t)
end
-- append typedef to current container
function appendtypedef (t)
return classContainer.curr:appendtypedef(t)
end
-- append usertype to current container
function appendusertype (t)
return classContainer.curr:appendusertype(t)
end
-- append enum to current container
function appendenum (t)
return classContainer.curr:appendenum(t)
end
-- substitute typedef
function applytypedef (mod,type)
return classContainer.curr:applytypedef(mod,type)
end
-- check if is type
function findtype (type)
local t = classContainer.curr:findtype(type)
return t
end
-- check if is typedef
function istypedef (type)
return classContainer.curr:istypedef(type)
end
-- get fulltype (with namespace)
function fulltype (t)
local curr = classContainer.curr
while curr do
if curr then
if curr.typedefs and curr.typedefs[t] then
return curr.typedefs[t]
elseif curr.usertypes and curr.usertypes[t] then
2012-06-04 14:58:17 +00:00
return curr.usertypes[t]
2011-10-03 18:41:19 +00:00
end
end
curr = curr.prox
end
return t
end
-- checks if it requires collection
function classContainer:requirecollection (t)
push(self)
local i=1
local r = false
while self[i] do
r = self[i]:requirecollection(t) or r
i = i+1
end
pop()
return r
end
-- get namesapce
function getnamespace (curr)
local namespace = ''
while curr do
if curr and
( curr.classtype == 'class' or curr.classtype == 'namespace')
then
namespace = (curr.original_name or curr.name) .. '::' .. namespace
--namespace = curr.name .. '::' .. namespace
end
curr = curr.prox
end
return namespace
end
-- get namespace (only namespace)
function getonlynamespace ()
local curr = classContainer.curr
local namespace = ''
while curr do
if curr.classtype == 'class' then
return namespace
elseif curr.classtype == 'namespace' then
namespace = curr.name .. '::' .. namespace
end
curr = curr.prox
end
return namespace
end
-- check if is enum
function isenum (type)
return classContainer.curr:isenum(type)
end
-- append feature to container
function classContainer:append (t)
self.n = self.n + 1
self[self.n] = t
t.parent = self
end
-- append typedef
function classContainer:appendtypedef (t)
local namespace = getnamespace(classContainer.curr)
self.typedefs.tolua_n = self.typedefs.tolua_n + 1
self.typedefs[self.typedefs.tolua_n] = t
self.typedefs[t.utype] = namespace .. t.utype
global_typedefs[namespace..t.utype] = t
t.ftype = findtype(t.type) or t.type
--print("appending typedef "..t.utype.." as "..namespace..t.utype.." with ftype "..t.ftype)
append_global_type(namespace..t.utype)
if t.ftype and isenum(t.ftype) then
global_enums[namespace..t.utype] = true
end
end
-- append usertype: return full type
function classContainer:appendusertype (t)
local container
if t == (self.original_name or self.name) then
container = self.prox
else
container = self
end
local ft = getnamespace(container) .. t
container.usertypes[t] = ft
_usertype[ft] = ft
return ft
end
-- append enum
function classContainer:appendenum (t)
local namespace = getnamespace(classContainer.curr)
self.enums.tolua_n = self.enums.tolua_n + 1
self.enums[self.enums.tolua_n] = t
global_enums[namespace..t.name] = t
end
-- determine lua function name overload
function classContainer:overload (lname)
if not self.lnames[lname] then
self.lnames[lname] = 0
else
self.lnames[lname] = self.lnames[lname] + 1
end
return format("%02d",self.lnames[lname])
end
-- applies typedef: returns the 'the facto' modifier and type
function classContainer:applytypedef (mod,type)
if global_typedefs[type] then
--print("found typedef "..global_typedefs[type].type)
local mod1, type1 = global_typedefs[type].mod, global_typedefs[type].ftype
local mod2, type2 = applytypedef(mod.." "..mod1, type1)
--return mod2 .. ' ' .. mod1, type2
return mod2, type2
end
do return mod,type end
end
-- check if it is a typedef
function classContainer:istypedef (type)
local env = self
while env do
if env.typedefs then
local i=1
while env.typedefs[i] do
if env.typedefs[i].utype == type then
return type
end
i = i+1
end
end
env = env.parent
end
return nil
end
function find_enum_var(var)
if tonumber(var) then return var end
local c = classContainer.curr
while c do
local ns = getnamespace(c)
for k,v in pairs(_global_enums) do
if match_type(var, v, ns) then
return v
end
end
if c.base and c.base ~= '' then
c = _global_classes[c:findtype(c.base)]
else
c = nil
end
end
return var
end
-- check if is a registered type: return full type or nil
function classContainer:findtype (t)
t = string.gsub(t, "=.*", "")
if _basic[t] then
return t
end
local _,_,em = string.find(t, "([&%*])%s*$")
t = string.gsub(t, "%s*([&%*])%s*$", "")
p = self
while p and type(p)=='table' do
local st = getnamespace(p)
for i=_global_types.n,1,-1 do -- in reverse order
if match_type(t, _global_types[i], st) then
return _global_types[i]..(em or "")
end
end
if p.base and p.base ~= '' and p.base ~= t then
--print("type is "..t..", p is "..p.base.." self.type is "..self.type.." self.name is "..self.name)
p = _global_classes[p:findtype(p.base)]
else
p = nil
end
end
return nil
end
function append_global_type(t, class)
_global_types.n = _global_types.n +1
_global_types[_global_types.n] = t
_global_types_hash[t] = 1
if class then append_class_type(t, class) end
end
function append_class_type(t,class)
if _global_classes[t] then
class.flags = _global_classes[t].flags
class.lnames = _global_classes[t].lnames
if _global_classes[t].base and (_global_classes[t].base ~= '') then
class.base = _global_classes[t].base or class.base
end
end
_global_classes[t] = class
class.flags = class.flags or {}
end
function match_type(childtype, regtype, st)
--print("findtype "..childtype..", "..regtype..", "..st)
local b,e = string.find(regtype, childtype, -string.len(childtype), true)
if b then
if e == string.len(regtype) and
(b == 1 or (string.sub(regtype, b-1, b-1) == ':' and
string.sub(regtype, 1, b-1) == string.sub(st, 1, b-1))) then
return true
end
end
return false
end
function findtype_on_childs(self, t)
local tchild
if self.classtype == 'class' or self.classtype == 'namespace' then
for k,v in ipairs(self) do
if v.classtype == 'class' or v.classtype == 'namespace' then
if v.typedefs and v.typedefs[t] then
return v.typedefs[t]
elseif v.usertypes and v.usertypes[t] then
return v.usertypes[t]
end
tchild = findtype_on_childs(v, t)
if tchild then return tchild end
end
end
end
return nil
end
function classContainer:isenum (type)
if global_enums[type] then
return type
else
return false
end
local basetype = gsub(type,"^.*::","")
local env = self
while env do
if env.enums then
local i=1
while env.enums[i] do
if env.enums[i].name == basetype then
return true
end
i = i+1
end
end
env = env.parent
end
return false
end
methodisvirtual = false -- a global
-- parse chunk
function classContainer:doparse (s)
--print ("parse "..s)
-- try the parser hook
do
local sub = parser_hook(s)
if sub then
return sub
end
end
-- try the null statement
do
local b,e,code = string.find(s, "^%s*;")
if b then
return strsub(s,e+1)
end
end
-- try empty verbatim line
do
local b,e,code = string.find(s, "^%s*$\n")
if b then
return strsub(s,e+1)
end
end
-- try Lua code
do
local b,e,code = strfind(s,"^%s*(%b\1\2)")
if b then
Code(strsub(code,2,-2))
return strsub(s,e+1)
end
end
-- try C code
do
local b,e,code = strfind(s,"^%s*(%b\3\4)")
if b then
code = '{'..strsub(code,2,-2)..'\n}\n'
Verbatim(code,'r') -- verbatim code for 'r'egister fragment
return strsub(s,e+1)
end
end
-- try C code for preamble section
do
local b,e,code = string.find(s, "^%s*(%b\5\6)")
if b then
code = string.sub(code, 2, -2).."\n"
Verbatim(code, '')
return string.sub(s, e+1)
end
end
-- try default_property directive
do
local b,e,ptype = strfind(s, "^%s*TOLUA_PROPERTY_TYPE%s*%(+%s*([^%)%s]*)%s*%)+%s*;?")
if b then
if not ptype or ptype == "" then
ptype = "default"
end
self:set_property_type(ptype)
return strsub(s, e+1)
end
2012-06-04 14:58:17 +00:00
end
2011-10-03 18:41:19 +00:00
-- try protected_destructor directive
do
local b,e = string.find(s, "^%s*TOLUA_PROTECTED_DESTRUCTOR%s*;?")
if b then
if self.set_protected_destructor then
self:set_protected_destructor(true)
end
return strsub(s, e+1)
end
end
-- try 'extern' keyword
do
local b,e = string.find(s, "^%s*extern%s+")
if b then
-- do nothing
return strsub(s, e+1)
end
end
-- try 'virtual' keyworkd
do
local b,e = string.find(s, "^%s*virtual%s+")
if b then
methodisvirtual = true
return strsub(s, e+1)
end
end
-- try labels (public, private, etc)
do
local b,e = string.find(s, "^%s*%w*%s*:[^:]")
if b then
return strsub(s, e) -- preserve the [^:]
end
end
-- try module
do
local b,e,name,body = strfind(s,"^%s*module%s%s*([_%w][_%w]*)%s*(%b{})%s*")
if b then
_curr_code = strsub(s,b,e)
Module(name,body)
return strsub(s,e+1)
end
end
-- try namesapce
do
local b,e,name,body = strfind(s,"^%s*namespace%s%s*([_%w][_%w]*)%s*(%b{})%s*;?")
if b then
_curr_code = strsub(s,b,e)
Namespace(name,body)
return strsub(s,e+1)
end
end
-- try define
do
local b,e,name = strfind(s,"^%s*#define%s%s*([^%s]*)[^\n]*\n%s*")
if b then
_curr_code = strsub(s,b,e)
Define(name)
2012-06-04 14:58:17 +00:00
return strsub(s,e+1)
2011-10-03 18:41:19 +00:00
end
end
-- try enumerates
do
local b,e,name,body,varname = strfind(s,"^%s*enum%s+(%S*)%s*(%b{})%s*([^%s;]*)%s*;?%s*")
if b then
--error("#Sorry, declaration of enums and variables on the same statement is not supported.\nDeclare your variable separately (example: '"..name.." "..varname..";')")
_curr_code = strsub(s,b,e)
Enumerate(name,body,varname)
return strsub(s,e+1)
end
end
-- do
-- local b,e,name,body = strfind(s,"^%s*enum%s+(%S*)%s*(%b{})%s*;?%s*")
-- if b then
-- _curr_code = strsub(s,b,e)
-- Enumerate(name,body)
-- return strsub(s,e+1)
-- end
-- end
do
local b,e,body,name = strfind(s,"^%s*typedef%s+enum[^{]*(%b{})%s*([%w_][^%s]*)%s*;%s*")
if b then
_curr_code = strsub(s,b,e)
Enumerate(name,body)
return strsub(s,e+1)
end
end
-- try operator
do
local b,e,decl,kind,arg,const = strfind(s,"^%s*([_%w][_%w%s%*&:<>,]-%s+operator)%s*([^%s][^%s]*)%s*(%b())%s*(c?o?n?s?t?)%s*;%s*")
if not b then
-- try inline
b,e,decl,kind,arg,const = strfind(s,"^%s*([_%w][_%w%s%*&:<>,]-%s+operator)%s*([^%s][^%s]*)%s*(%b())%s*(c?o?n?s?t?)[%s\n]*%b{}%s*;?%s*")
end
if not b then
-- try cast operator
b,e,decl,kind,arg,const = strfind(s, "^%s*(operator)%s+([%w_:%d<>%*%&%s]+)%s*(%b())%s*(c?o?n?s?t?)");
if b then
local _,ie = string.find(s, "^%s*%b{}", e+1)
if ie then
e = ie
end
end
2012-06-04 14:58:17 +00:00
end
2011-10-03 18:41:19 +00:00
if b then
_curr_code = strsub(s,b,e)
Operator(decl,kind,arg,const)
return strsub(s,e+1)
end
end
-- try function
do
--local b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w])%s*(%b())%s*(c?o?n?s?t?)%s*=?%s*0?%s*;%s*")
local b,e,decl,arg,const,virt = strfind(s,"^%s*([^%(\n]+)%s*(%b())%s*(c?o?n?s?t?)%s*(=?%s*0?)%s*;%s*")
if not b then
-- try function with template
b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w]%b<>)%s*(%b())%s*(c?o?n?s?t?)%s*=?%s*0?%s*;%s*")
end
if not b then
-- try a single letter function name
b,e,decl,arg,const = strfind(s,"^%s*([_%w])%s*(%b())%s*(c?o?n?s?t?)%s*;%s*")
end
if not b then
-- try function pointer
b,e,decl,arg,const = strfind(s,"^%s*([^%(;\n]+%b())%s*(%b())%s*;%s*")
if b then
decl = string.gsub(decl, "%(%s*%*([^%)]*)%s*%)", " %1 ")
end
end
if b then
if virt and string.find(virt, "[=0]") then
if self.flags then
self.flags.pure_virtual = true
end
end
_curr_code = strsub(s,b,e)
Function(decl,arg,const)
return strsub(s,e+1)
end
end
-- try inline function
do
local b,e,decl,arg,const = strfind(s,"^%s*([^%(\n]+)%s*(%b())%s*(c?o?n?s?t?)[^;{]*%b{}%s*;?%s*")
--local b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w>])%s*(%b())%s*(c?o?n?s?t?)[^;]*%b{}%s*;?%s*")
if not b then
-- try a single letter function name
b,e,decl,arg,const = strfind(s,"^%s*([_%w])%s*(%b())%s*(c?o?n?s?t?).-%b{}%s*;?%s*")
end
if b then
_curr_code = strsub(s,b,e)
Function(decl,arg,const)
return strsub(s,e+1)
end
end
-- try class
do
local b,e,name,base,body
base = '' body = ''
b,e,name = strfind(s,"^%s*class%s*([_%w][_%w@]*)%s*;") -- dummy class
local dummy = false
2012-06-04 14:58:17 +00:00
if not b then
2011-10-03 18:41:19 +00:00
b,e,name = strfind(s,"^%s*struct%s*([_%w][_%w@]*)%s*;") -- dummy struct
if not b then
b,e,name,base,body = strfind(s,"^%s*class%s*([_%w][_%w@]*)%s*([^{]-)%s*(%b{})%s*")
if not b then
b,e,name,base,body = strfind(s,"^%s*struct%s+([_%w][_%w@]*)%s*([^{]-)%s*(%b{})%s*")
if not b then
b,e,name,base,body = strfind(s,"^%s*union%s*([_%w][_%w@]*)%s*([^{]-)%s*(%b{})%s*")
if not b then
base = ''
b,e,body,name = strfind(s,"^%s*typedef%s%s*struct%s%s*[_%w]*%s*(%b{})%s*([_%w][_%w@]*)%s*;")
end
end
end
else dummy = 1 end
else dummy = 1 end
if b then
if base ~= '' then
base = string.gsub(base, "^%s*:%s*", "")
base = string.gsub(base, "%s*public%s*", "")
base = split(base, ",")
--local b,e
--b,e,base = strfind(base,".-([_%w][_%w<>,:]*)$")
else
base = {}
end
_curr_code = strsub(s,b,e)
Class(name,base,body)
if not dummy then
varb,vare,varname = string.find(s, "^%s*([_%w]+)%s*;", e+1)
if varb then
Variable(name.." "..varname)
e = vare
end
end
return strsub(s,e+1)
end
end
-- try typedef
do
local b,e,types = strfind(s,"^%s*typedef%s%s*(.-)%s*;%s*")
if b then
_curr_code = strsub(s,b,e)
Typedef(types)
return strsub(s,e+1)
end
end
-- try variable
do
local b,e,decl = strfind(s,"^%s*([_%w][_@%s%w%d%*&:<>,]*[_%w%d])%s*;%s*")
if b then
_curr_code = strsub(s,b,e)
local list = split_c_tokens(decl, ",")
Variable(list[1])
if list.n > 1 then
local _,_,type = strfind(list[1], "(.-)%s+([^%s]*)$");
local i =2;
while list[i] do
Variable(type.." "..list[i])
i=i+1
end
end
--Variable(decl)
return strsub(s,e+1)
end
end
-- try string
do
local b,e,decl = strfind(s,"^%s*([_%w]?[_%s%w%d]-char%s+[_@%w%d]*%s*%[%s*%S+%s*%])%s*;%s*")
if b then
_curr_code = strsub(s,b,e)
Variable(decl)
return strsub(s,e+1)
end
end
-- try array
do
local b,e,decl = strfind(s,"^%s*([_%w][][_@%s%w%d%*&:<>]*[]_%w%d])%s*;%s*")
if b then
_curr_code = strsub(s,b,e)
Array(decl)
return strsub(s,e+1)
end
end
-- no matching
if gsub(s,"%s%s*","") ~= "" then
_curr_code = s
error("#parse error")
else
return ""
end
end
function classContainer:parse (s)
--self.curr_member_access = nil
2012-06-04 14:58:17 +00:00
2011-10-03 18:41:19 +00:00
while s ~= '' do
s = self:doparse(s)
methodisvirtual = false
end
end
-- property types
function get_property_type()
return classContainer.curr:get_property_type()
end
function classContainer:set_property_type(ptype)
ptype = string.gsub(ptype, "^%s*", "")
ptype = string.gsub(ptype, "%s*$", "")
self.property_type = ptype
end
function classContainer:get_property_type()
return self.property_type or (self.parent and self.parent:get_property_type()) or "default"
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Package class
-- Represents the whole package being bound.
-- The following fields are stored:
-- {i} = list of objects in the package.
classPackage = {
classtype = 'package'
}
classPackage.__index = classPackage
setmetatable(classPackage,classContainer)
-- Print method
function classPackage:print ()
print("Package: "..self.name)
local i=1
while self[i] do
self[i]:print("","")
i = i+1
end
end
function classPackage:preprocess ()
-- avoid preprocessing embedded Lua code
local L = {}
self.code = gsub(self.code,"\n%s*%$%[","\1") -- deal with embedded lua code
self.code = gsub(self.code,"\n%s*%$%]","\2")
self.code = gsub(self.code,"(%b\1\2)", function (c)
tinsert(L,c)
return "\n#["..getn(L).."]#"
end)
-- avoid preprocessing embedded C code
local C = {}
self.code = gsub(self.code,"\n%s*%$%<","\3") -- deal with embedded C code
self.code = gsub(self.code,"\n%s*%$%>","\4")
self.code = gsub(self.code,"(%b\3\4)", function (c)
tinsert(C,c)
return "\n#<"..getn(C)..">#"
end)
-- avoid preprocessing embedded C code
self.code = gsub(self.code,"\n%s*%$%{","\5") -- deal with embedded C code
self.code = gsub(self.code,"\n%s*%$%}","\6")
self.code = gsub(self.code,"(%b\5\6)", function (c)
tinsert(C,c)
return "\n#<"..getn(C)..">#"
end)
--self.code = gsub(self.code,"\n%s*#[^d][^\n]*\n", "\n\n") -- eliminate preprocessor directives that don't start with 'd'
self.code = gsub(self.code,"\n[ \t]*#[ \t]*[^d%<%[]", "\n//") -- eliminate preprocessor directives that don't start with 'd'
-- avoid preprocessing verbatim lines
local V = {}
self.code = gsub(self.code,"\n(%s*%$[^%[%]][^\n]*)",function (v)
tinsert(V,v)
return "\n#"..getn(V).."#"
end)
-- perform global substitution
self.code = gsub(self.code,"(//[^\n]*)","") -- eliminate C++ comments
self.code = gsub(self.code,"/%*","\1")
self.code = gsub(self.code,"%*/","\2")
self.code = gsub(self.code,"%b\1\2","")
self.code = gsub(self.code,"\1","/%*")
self.code = gsub(self.code,"\2","%*/")
self.code = gsub(self.code,"%s*@%s*","@") -- eliminate spaces beside @
self.code = gsub(self.code,"%s?inline(%s)","%1") -- eliminate 'inline' keyword
--self.code = gsub(self.code,"%s?extern(%s)","%1") -- eliminate 'extern' keyword
--self.code = gsub(self.code,"%s?virtual(%s)","%1") -- eliminate 'virtual' keyword
--self.code = gsub(self.code,"public:","") -- eliminate 'public:' keyword
self.code = gsub(self.code,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*'
self.code = gsub(self.code,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*'
self.code = gsub(self.code,"([^%w_])char%s*%*","%1_cstring ") -- substitute 'char*'
self.code = gsub(self.code,"([^%w_])lua_State%s*%*","%1_lstate ") -- substitute 'lua_State*'
-- restore embedded Lua code
self.code = gsub(self.code,"%#%[(%d+)%]%#",function (n)
return L[tonumber(n)]
end)
-- restore embedded C code
self.code = gsub(self.code,"%#%<(%d+)%>%#",function (n)
return C[tonumber(n)]
end)
-- restore verbatim lines
self.code = gsub(self.code,"%#(%d+)%#",function (n)
return V[tonumber(n)]
end)
self.code = string.gsub(self.code, "\n%s*%$([^\n]+)", function (l)
Verbatim(l.."\n")
return "\n"
end)
end
-- translate verbatim
function classPackage:preamble ()
output('/*\n')
output('** Lua binding: '..self.name..'\n')
output('** Generated automatically by '..TOLUA_VERSION..' on '..date()..'.\n')
output('*/\n\n')
output('#ifndef __cplusplus\n')
output('#include "stdlib.h"\n')
output('#endif\n')
output('#include "string.h"\n\n')
output('#include "tolua++.h"\n\n')
if not flags.h then
output('/* Exported function */')
output('TOLUA_API int tolua_'..self.name..'_open (lua_State* tolua_S);')
output('\n')
end
local i=1
while self[i] do
self[i]:preamble()
i = i+1
end
if self:requirecollection(_collect) then
output('\n')
output('/* function to release collected object via destructor */')
output('#ifdef __cplusplus\n')
for i,v in pairs(_collect) do
output('\nstatic int '..v..' (lua_State* tolua_S)')
output('{')
output(' '..i..'* self = ('..i..'*) tolua_tousertype(tolua_S,1,0);')
output(' Mtolua_delete(self);')
output(' return 0;')
output('}')
end
output('#endif\n\n')
end
output('\n')
output('/* function to register type */')
output('static void tolua_reg_types (lua_State* tolua_S)')
output('{')
if flags.t then
output("#ifndef Mtolua_typeid\n#define Mtolua_typeid(L,TI,T)\n#endif\n")
end
foreach(_usertype,function(n,v)
if (not _global_classes[v]) or _global_classes[v]:check_public_access() then
output(' tolua_usertype(tolua_S,"',v,'");')
if flags.t then
output(' Mtolua_typeid(tolua_S,typeid(',v,'), "',v,'");')
end
end
end)
output('}')
output('\n')
end
-- register package
-- write package open function
function classPackage:register (pre)
pre = pre or ''
push(self)
output(pre.."/* Open function */")
output(pre.."TOLUA_API int tolua_"..self.name.."_open (lua_State* tolua_S)")
output(pre.."{")
output(pre.." tolua_open(tolua_S);")
output(pre.." tolua_reg_types(tolua_S);")
output(pre.." tolua_module(tolua_S,NULL,",self:hasvar(),");")
output(pre.." tolua_beginmodule(tolua_S,NULL);")
local i=1
while self[i] do
self[i]:register(pre.." ")
i = i+1
end
output(pre.." tolua_endmodule(tolua_S);")
output(pre.." return 1;")
output(pre.."}")
output("\n\n")
output("#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501\n");
output(pre.."TOLUA_API int luaopen_"..self.name.." (lua_State* tolua_S) {")
output(pre.." return tolua_"..self.name.."_open(tolua_S);")
output(pre.."};")
output("#endif\n\n")
pop()
end
-- write header file
function classPackage:header ()
output('/*\n') output('** Lua binding: '..self.name..'\n')
output('** Generated automatically by '..TOLUA_VERSION..' on '..date()..'.\n')
output('*/\n\n')
if not flags.h then
output('/* Exported function */')
output('TOLUA_API int tolua_'..self.name..'_open (lua_State* tolua_S);')
output('\n')
end
end
-- Internal constructor
function _Package (self)
setmetatable(self,classPackage)
return self
end
-- Parse C header file with tolua directives
-- *** Thanks to Ariel Manzur for fixing bugs in nested directives ***
function extract_code(fn,s)
local code = '\n$#include "'..fn..'"\n'
s= "\n" .. s .. "\n" -- add blank lines as sentinels
local _,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n")
while e do
t = strlower(t)
if t == "begin" then
_,e,c = strfind(s,"(.-)\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[Ee][Nn][Dd][^\n]*\n",e)
if not e then
tolua_error("Unbalanced 'tolua_begin' directive in header file")
end
end
code = code .. c .. "\n"
_,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n",e)
end
return code
end
-- Constructor
-- Expects the package name, the file extension, and the file text.
function Package (name,fn)
local ext = "pkg"
-- open input file, if any
local st,msg
if fn then
st, msg = readfrom(flags.f)
if not st then
error('#'..msg)
end
local _; _, _, ext = strfind(fn,".*%.(.*)$")
end
local code
if ext == 'pkg' then
code = prep(st)
else
code = "\n" .. read('*a')
if ext == 'h' or ext == 'hpp' then
code = extract_code(fn,code)
end
end
-- close file
if fn then
readfrom()
end
-- deal with include directive
local nsubst
repeat
code,nsubst = gsub(code,'\n%s*%$(.)file%s*"(.-)"([^\n]*)\n',
function (kind,fn,extra)
local _, _, ext = strfind(fn,".*%.(.*)$")
local fp,msg = openfile(fn,'r')
if not fp then
error('#'..msg..': '..fn)
end
if kind == 'p' then
local s = prep(fp)
closefile(fp)
return s
end
local s = read(fp,'*a')
closefile(fp)
if kind == 'c' or kind == 'h' then
return extract_code(fn,s)
elseif kind == 'l' then
return "\n$[--##"..fn.."\n" .. s .. "\n$]\n"
elseif kind == 'i' then
local t = {code=s}
extra = string.gsub(extra, "^%s*,%s*", "")
local pars = split_c_tokens(extra, ",")
include_file_hook(t, fn, unpack(pars))
return "\n\n" .. t.code
else
error('#Invalid include directive (use $cfile, $pfile, $lfile or $ifile)')
end
end)
until nsubst==0
-- deal with renaming directive
repeat -- I don't know why this is necesary
code,nsubst = gsub(code,'\n%s*%$renaming%s*(.-)%s*\n', function (r) appendrenaming(r) return "\n" end)
until nsubst == 0
local t = _Package(_Container{name=name, code=code})
push(t)
preprocess_hook(t)
t:preprocess()
preparse_hook(t)
t:parse(t.code)
pop()
return t
end
setmetatable(_extra_parameters, { __index = _G })
function prep(file)
local chunk = {'local __ret = {"\\n"}\n'}
for line in file:lines() do
if string.find(line, "^##") then
table.insert(chunk, string.sub(line, 3) .. "\n")
else
local last = 1
for text, expr, index in string.gfind(line, "(.-)$(%b())()") do
last = index
if text ~= "" then
table.insert(chunk, string.format('table.insert(__ret, %q )', text))
end
table.insert(chunk, string.format('table.insert(__ret, %s )', expr))
end
table.insert(chunk, string.format('table.insert(__ret, %q)\n',
string.sub(line, last).."\n"))
end
end
table.insert(chunk, '\nreturn table.concat(__ret)\n')
local f,e = loadstring(table.concat(chunk))
if e then
error("#"..e)
end
setfenv(f, _extra_parameters)
return f()
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Module class
-- Represents module.
-- The following fields are stored:
-- {i} = list of objects in the module.
classModule = {
classtype = 'module'
}
classModule.__index = classModule
setmetatable(classModule,classContainer)
-- register module
function classModule:register (pre)
pre = pre or ''
push(self)
output(pre..'tolua_module(tolua_S,"'..self.name..'",',self:hasvar(),');')
output(pre..'tolua_beginmodule(tolua_S,"'..self.name..'");')
local i=1
while self[i] do
self[i]:register(pre..' ')
i = i+1
end
output(pre..'tolua_endmodule(tolua_S);')
pop()
end
-- Print method
function classModule:print (ident,close)
print(ident.."Module{")
print(ident.." name = '"..self.name.."';")
local i=1
while self[i] do
self[i]:print(ident.." ",",")
i = i+1
end
print(ident.."}"..close)
end
-- Internal constructor
function _Module (t)
setmetatable(t,classModule)
append(t)
return t
end
-- Constructor
-- Expects two string representing the module name and body.
function Module (n,b)
local t = _Module(_Container{name=n})
push(t)
t:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces
pop()
return t
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 2003
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Namespace class
-- Represents a namesapce definition.
-- Stores the following fields:
-- name = class name
-- {i} = list of members
classNamespace = {
classtype = 'namespace',
name = '',
}
classNamespace.__index = classNamespace
setmetatable(classNamespace,classModule)
-- Print method
function classNamespace:print (ident,close)
print(ident.."Namespace{")
print(ident.." name = '"..self.name.."',")
local i=1
while self[i] do
self[i]:print(ident.." ",",")
i = i+1
end
print(ident.."}"..close)
end
-- Internal constructor
function _Namespace (t)
setmetatable(t,classNamespace)
append(t)
return t
end
-- Constructor
-- Expects the name and the body of the namespace.
function Namespace (n,b)
local c = _Namespace(_Container{name=n})
push(c)
c:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces
pop()
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: define.lua,v 1.2 1999/07/28 22:21:08 celes Exp $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Define class
-- Represents a numeric const definition
-- The following filds are stored:
-- name = constant name
classDefine = {
name = '',
}
classDefine.__index = classDefine
setmetatable(classDefine,classFeature)
-- register define
function classDefine:register (pre)
if not self:check_public_access() then
return
end
pre = pre or ''
output(pre..'tolua_constant(tolua_S,"'..self.lname..'",'..self.name..');')
end
-- Print method
function classDefine:print (ident,close)
print(ident.."Define{")
print(ident.." name = '"..self.name.."',")
print(ident.." lname = '"..self.lname.."',")
print(ident.."}"..close)
end
-- Internal constructor
function _Define (t)
setmetatable(t,classDefine)
t:buildnames()
if t.name == '' then
error("#invalid define")
end
append(t)
return t
end
-- Constructor
-- Expects a string representing the constant name
function Define (n)
return _Define{
name = n
}
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: enumerate.lua,v 1.3 2000/01/24 20:41:15 celes Exp $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Enumerate class
-- Represents enumeration
-- The following fields are stored:
-- {i} = list of constant names
classEnumerate = {
}
classEnumerate.__index = classEnumerate
setmetatable(classEnumerate,classFeature)
-- register enumeration
function classEnumerate:register (pre)
if not self:check_public_access() then
return
end
pre = pre or ''
local nspace = getnamespace(classContainer.curr)
local i=1
while self[i] do
if self.lnames[i] and self.lnames[i] ~= "" then
output(pre..'tolua_constant(tolua_S,"'..self.lnames[i]..'",'..nspace..self[i]..');')
end
i = i+1
end
2012-06-04 14:58:17 +00:00
end
2011-10-03 18:41:19 +00:00
-- Print method
function classEnumerate:print (ident,close)
print(ident.."Enumerate{")
print(ident.." name = "..self.name)
local i=1
while self[i] do
print(ident.." '"..self[i].."'("..self.lnames[i].."),")
i = i+1
end
print(ident.."}"..close)
end
-- Internal constructor
function _Enumerate (t,varname)
setmetatable(t,classEnumerate)
append(t)
appendenum(t)
if varname and varname ~= "" then
if t.name ~= "" then
Variable(t.name.." "..varname)
else
local ns = getcurrnamespace()
warning("Variable "..ns..varname.." of type <anonymous enum> is declared as read-only")
Variable("tolua_readonly int "..varname)
end
end
local parent = classContainer.curr
if parent then
t.access = parent.curr_member_access
t.global_access = t:check_public_access()
end
return t
end
-- Constructor
-- Expects a string representing the enumerate body
function Enumerate (n,b,varname)
b = string.gsub(b, ",[%s\n]*}", "\n}") -- eliminate last ','
local t = split(strsub(b,2,-2),',') -- eliminate braces
local i = 1
local e = {n=0}
while t[i] do
local tt = split(t[i],'=') -- discard initial value
e.n = e.n + 1
e[e.n] = tt[1]
i = i+1
end
-- set lua names
i = 1
e.lnames = {}
local ns = getcurrnamespace()
while e[i] do
local t = split(e[i],'@')
e[i] = t[1]
if not t[2] then
t[2] = applyrenaming(t[1])
end
e.lnames[i] = t[2] or t[1]
_global_enums[ ns..e[i] ] = (ns..e[i])
i = i+1
end
e.name = n
if n ~= "" then
Typedef("int "..n)
end
return _Enumerate(e, varname)
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Declaration class
-- Represents variable, function, or argument declaration.
-- Stores the following fields:
-- mod = type modifiers
-- type = type
-- ptr = "*" or "&", if representing a pointer or a reference
-- name = name
-- dim = dimension, if a vector
-- def = default value, if any (only for arguments)
-- ret = "*" or "&", if value is to be returned (only for arguments)
classDeclaration = {
mod = '',
type = '',
ptr = '',
name = '',
dim = '',
ret = '',
def = ''
}
classDeclaration.__index = classDeclaration
setmetatable(classDeclaration,classFeature)
-- Create an unique variable name
function create_varname ()
if not _varnumber then _varnumber = 0 end
_varnumber = _varnumber + 1
return "tolua_var_".._varnumber
end
-- Check declaration name
-- It also identifies default values
function classDeclaration:checkname ()
if strsub(self.name,1,1) == '[' and not findtype(self.type) then
self.name = self.type..self.name
local m = split(self.mod,'%s%s*')
self.type = m[m.n]
self.mod = concat(m,1,m.n-1)
end
local t = split(self.name,'=')
if t.n==2 then
self.name = t[1]
self.def = find_enum_var(t[t.n])
end
local b,e,d = strfind(self.name,"%[(.-)%]")
if b then
self.name = strsub(self.name,1,b-1)
self.dim = find_enum_var(d)
end
if self.type ~= '' and self.type ~= 'void' and self.name == '' then
self.name = create_varname()
elseif self.kind=='var' then
if self.type=='' and self.name~='' then
self.type = self.type..self.name
self.name = create_varname()
elseif findtype(self.name) then
if self.type=='' then self.type = self.name
else self.type = self.type..' '..self.name end
self.name = create_varname()
end
end
-- adjust type of string
if self.type == 'char' and self.dim ~= '' then
self.type = 'char*'
end
if self.kind and self.kind == 'var' then
self.name = string.gsub(self.name, ":.*$", "") -- ???
end
end
-- Check declaration type
-- Substitutes typedef's.
function classDeclaration:checktype ()
-- check if there is a pointer to basic type
local basic = isbasic(self.type)
if self.kind == 'func' and basic=='number' and string.find(self.ptr, "%*") then
self.type = '_userdata'
self.ptr = ""
end
if basic and self.ptr~='' then
self.ret = self.ptr
self.ptr = nil
if isbasic(self.type) == 'number' then
self.return_userdata = true
end
end
-- check if there is array to be returned
if self.dim~='' and self.ret~='' then
error('#invalid parameter: cannot return an array of values')
end
-- restore 'void*' and 'string*'
if self.type == '_userdata' then self.type = 'void*'
elseif self.type == '_cstring' then self.type = 'char*'
elseif self.type == '_lstate' then self.type = 'lua_State*'
end
-- resolve types inside the templates
if self.type then
self.type = resolve_template_types(self.type)
end
--
-- -- if returning value, automatically set default value
-- if self.ret ~= '' and self.def == '' then
-- self.def = '0'
-- end
--
end
function resolve_template_types(type)
if isbasic(type) then
return type
end
local b,_,m = string.find(type, "(%b<>)")
if b then
m = split_c_tokens(string.sub(m, 2, -2), ",")
for i=1, table.getn(m) do
m[i] = string.gsub(m[i],"%s*([%*&])", "%1")
if not isbasic(m[i]) then
if not isenum(m[i]) then _, m[i] = applytypedef("", m[i]) end
m[i] = findtype(m[i]) or m[i]
m[i] = resolve_template_types(m[i])
end
end
local b,i
type,b,i = break_template(type)
--print("concat is ",concat(m, 1, m.n))
local template_part = "<"..concat(m, 1, m.n, ",")..">"
type = rebuild_template(type, b, template_part)
type = string.gsub(type, ">>", "> >")
end
return type
end
function break_template(s)
local b,e,timpl = string.find(s, "(%b<>)")
if timpl then
s = string.gsub(s, "%b<>", "")
return s, b, timpl
else
return s, 0, nil
end
end
function rebuild_template(s, b, timpl)
if b == 0 then
return s
end
return string.sub(s, 1, b-1)..timpl..string.sub(s, b, -1)
end
-- Print method
function classDeclaration:print (ident,close)
print(ident.."Declaration{")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.." ptr = '"..self.ptr.."',")
print(ident.." name = '"..self.name.."',")
print(ident.." dim = '"..self.dim.."',")
print(ident.." def = '"..self.def.."',")
print(ident.." ret = '"..self.ret.."',")
print(ident.."}"..close)
end
-- check if array of values are returned to Lua
function classDeclaration:requirecollection (t)
if self.mod ~= 'const' and
self.dim and self.dim ~= '' and
not isbasic(self.type) and
self.ptr == '' and self:check_public_access() then
local type = gsub(self.type,"%s*const%s+","")
t[type] = "tolua_collect_" .. clean_template(type)
return true
end
return false
end
-- declare tag
function classDeclaration:decltype ()
self.type = typevar(self.type)
if strfind(self.mod,'const') then
self.type = 'const '..self.type
self.mod = gsub(self.mod,'const%s*','')
end
end
-- output type checking
function classDeclaration:outchecktype (narg)
local def
local t = isbasic(self.type)
if self.def~='' then
def = 1
else
def = 0
end
if self.dim ~= '' then
--if t=='string' then
-- return 'tolua_isstringarray(tolua_S,'..narg..','..def..',&tolua_err)'
--else
return '!tolua_istable(tolua_S,'..narg..',0,&tolua_err)'
--end
2012-06-04 14:58:17 +00:00
elseif t then
2011-10-03 18:41:19 +00:00
return '!tolua_is'..t..'(tolua_S,'..narg..','..def..',&tolua_err)'
else
local is_func = get_is_function(self.type)
if self.ptr == '&' or self.ptr == '' then
return '(tolua_isvaluenil(tolua_S,'..narg..',&tolua_err) || !'..is_func..'(tolua_S,'..narg..',"'..self.type..'",'..def..',&tolua_err))'
else
return '!'..is_func..'(tolua_S,'..narg..',"'..self.type..'",'..def..',&tolua_err)'
end
end
end
function classDeclaration:builddeclaration (narg, cplusplus)
local array = self.dim ~= '' and tonumber(self.dim)==nil
local line = ""
local ptr = ''
local mod
local type = self.type
local nctype = gsub(self.type,'const%s+','')
if self.dim ~= '' then
type = gsub(self.type,'const%s+','') -- eliminates const modifier for arrays
end
if self.ptr~='' and not isbasic(type) then ptr = '*' end
line = concatparam(line," ",self.mod,type,ptr)
if array then
line = concatparam(line,'*')
end
line = concatparam(line,self.name)
if self.dim ~= '' then
if tonumber(self.dim)~=nil then
line = concatparam(line,'[',self.dim,'];')
else
if cplusplus then
line = concatparam(line,' = Mtolua_new_dim(',type,ptr,', '..self.dim..');')
else
line = concatparam(line,' = (',type,ptr,'*)',
'malloc((',self.dim,')*sizeof(',type,ptr,'));')
end
end
else
local t = isbasic(type)
line = concatparam(line,' = ')
if t == 'state' then
line = concatparam(line, 'tolua_S;')
else
--print("t is "..tostring(t)..", ptr is "..tostring(self.ptr))
if t == 'number' and string.find(self.ptr, "%*") then
t = 'userdata'
end
if not t and ptr=='' then line = concatparam(line,'*') end
line = concatparam(line,'((',self.mod,type)
if not t then
line = concatparam(line,'*')
end
line = concatparam(line,') ')
if isenum(nctype) then
line = concatparam(line,'(int) ')
end
local def = 0
if self.def ~= '' then
def = self.def
if (ptr == '' or self.ptr == '&') and not t then
def = "(void*)&(const "..type..")"..def
end
end
if t then
line = concatparam(line,'tolua_to'..t,'(tolua_S,',narg,',',def,'));')
else
local to_func = get_to_function(type)
line = concatparam(line,to_func..'(tolua_S,',narg,',',def,'));')
end
end
end
return line
end
-- Declare variable
function classDeclaration:declare (narg)
if self.dim ~= '' and tonumber(self.dim)==nil then
output('#ifdef __cplusplus\n')
output(self:builddeclaration(narg,true))
output('#else\n')
output(self:builddeclaration(narg,false))
output('#endif\n')
else
output(self:builddeclaration(narg,false))
end
end
-- Get parameter value
function classDeclaration:getarray (narg)
if self.dim ~= '' then
local type = gsub(self.type,'const ','')
output(' {')
output('#ifndef TOLUA_RELEASE\n')
local def; if self.def~='' then def=1 else def=0 end
local t = isbasic(type)
if (t) then
output(' if (!tolua_is'..t..'array(tolua_S,',narg,',',self.dim,',',def,',&tolua_err))')
else
output(' if (!tolua_isusertypearray(tolua_S,',narg,',"',type,'",',self.dim,',',def,',&tolua_err))')
end
output(' goto tolua_lerror;')
output(' else\n')
output('#endif\n')
output(' {')
output(' int i;')
output(' for(i=0; i<'..self.dim..';i++)')
local t = isbasic(type)
local ptr = ''
if self.ptr~='' then ptr = '*' end
output(' ',self.name..'[i] = ')
if not t and ptr=='' then output('*') end
output('((',type)
if not t then
output('*')
end
output(') ')
local def = 0
if self.def ~= '' then def = self.def end
if t then
output('tolua_tofield'..t..'(tolua_S,',narg,',i+1,',def,'));')
else
output('tolua_tofieldusertype(tolua_S,',narg,',i+1,',def,'));')
end
output(' }')
output(' }')
end
end
-- Get parameter value
function classDeclaration:setarray (narg)
if not strfind(self.type,'const%s+') and self.dim ~= '' then
local type = gsub(self.type,'const ','')
output(' {')
output(' int i;')
output(' for(i=0; i<'..self.dim..';i++)')
local t,ct = isbasic(type)
if t then
output(' tolua_pushfield'..t..'(tolua_S,',narg,',i+1,(',ct,')',self.name,'[i]);')
else
if self.ptr == '' then
output(' {')
output('#ifdef __cplusplus\n')
output(' void* tolua_obj = Mtolua_new((',type,')(',self.name,'[i]));')
output(' tolua_pushfieldusertype_and_takeownership(tolua_S,',narg,',i+1,tolua_obj,"',type,'");')
output('#else\n')
output(' void* tolua_obj = tolua_copy(tolua_S,(void*)&',self.name,'[i],sizeof(',type,'));')
output(' tolua_pushfieldusertype(tolua_S,',narg,',i+1,tolua_obj,"',type,'");')
output('#endif\n')
output(' }')
else
output(' tolua_pushfieldusertype(tolua_S,',narg,',i+1,(void*)',self.name,'[i],"',type,'");')
end
end
output(' }')
end
end
-- Free dynamically allocated array
function classDeclaration:freearray ()
if self.dim ~= '' and tonumber(self.dim)==nil then
output('#ifdef __cplusplus\n')
output(' Mtolua_delete_dim(',self.name,');')
output('#else\n')
output(' free(',self.name,');')
output('#endif\n')
end
end
-- Pass parameter
function classDeclaration:passpar ()
if self.ptr=='&' and not isbasic(self.type) then
output('*'..self.name)
elseif self.ret=='*' then
output('&'..self.name)
else
output(self.name)
end
end
-- Return parameter value
function classDeclaration:retvalue ()
if self.ret ~= '' then
local t,ct = isbasic(self.type)
if t and t~='' then
output(' tolua_push'..t..'(tolua_S,(',ct,')'..self.name..');')
else
local push_func = get_push_function(self.type)
output(' ',push_func,'(tolua_S,(void*)'..self.name..',"',self.type,'");')
end
return 1
end
return 0
end
-- Internal constructor
function _Declaration (t)
setmetatable(t,classDeclaration)
t:buildnames()
t:checkname()
t:checktype()
local ft = findtype(t.type) or t.type
if not isenum(ft) then
t.mod, t.type = applytypedef(t.mod, ft)
end
if t.kind=="var" and (string.find(t.mod, "tolua_property%s") or string.find(t.mod, "tolua_property$")) then
t.mod = string.gsub(t.mod, "tolua_property", "tolua_property__"..get_property_type())
end
return t
end
-- Constructor
-- Expects the string declaration.
-- The kind of declaration can be "var" or "func".
function Declaration (s,kind,is_parameter)
-- eliminate spaces if default value is provided
s = gsub(s,"%s*=%s*","=")
s = gsub(s, "%s*<", "<")
local defb,tmpdef
defb,_,tmpdef = string.find(s, "(=.*)$")
if defb then
s = string.gsub(s, "=.*$", "")
else
tmpdef = ''
2012-06-04 14:58:17 +00:00
end
2011-10-03 18:41:19 +00:00
if kind == "var" then
-- check the form: void
if s == '' or s == 'void' then
return _Declaration{type = 'void', kind = kind, is_parameter = is_parameter}
end
end
-- check the form: mod type*& name
local t = split_c_tokens(s,'%*%s*&')
if t.n == 2 then
if kind == 'func' then
error("#invalid function return type: "..s)
end
--local m = split(t[1],'%s%s*')
local m = split_c_tokens(t[1],'%s+')
return _Declaration{
name = t[2]..tmpdef,
ptr = '*',
ret = '&',
--type = rebuild_template(m[m.n], tb, timpl),
type = m[m.n],
mod = concat(m,1,m.n-1),
is_parameter = is_parameter,
kind = kind
}
end
-- check the form: mod type** name
t = split_c_tokens(s,'%*%s*%*')
if t.n == 2 then
if kind == 'func' then
error("#invalid function return type: "..s)
end
--local m = split(t[1],'%s%s*')
local m = split_c_tokens(t[1],'%s+')
return _Declaration{
name = t[2]..tmpdef,
ptr = '*',
ret = '*',
--type = rebuild_template(m[m.n], tb, timpl),
type = m[m.n],
mod = concat(m,1,m.n-1),
is_parameter = is_parameter,
kind = kind
}
end
-- check the form: mod type& name
t = split_c_tokens(s,'&')
if t.n == 2 then
--local m = split(t[1],'%s%s*')
local m = split_c_tokens(t[1],'%s+')
return _Declaration{
name = t[2]..tmpdef,
ptr = '&',
--type = rebuild_template(m[m.n], tb, timpl),
type = m[m.n],
mod = concat(m,1,m.n-1),
is_parameter = is_parameter,
kind = kind
}
end
-- check the form: mod type* name
local s1 = gsub(s,"(%b\[\])",function (n) return gsub(n,'%*','\1') end)
t = split_c_tokens(s1,'%*')
if t.n == 2 then
t[2] = gsub(t[2],'\1','%*') -- restore * in dimension expression
--local m = split(t[1],'%s%s*')
local m = split_c_tokens(t[1],'%s+')
return _Declaration{
name = t[2]..tmpdef,
ptr = '*',
type = m[m.n],
--type = rebuild_template(m[m.n], tb, timpl),
mod = concat(m,1,m.n-1) ,
is_parameter = is_parameter,
kind = kind
}
end
if kind == 'var' then
-- check the form: mod type name
--t = split(s,'%s%s*')
t = split_c_tokens(s,'%s+')
local v
if findtype(t[t.n]) then v = create_varname() else v = t[t.n]; t.n = t.n-1 end
return _Declaration{
name = v..tmpdef,
--type = rebuild_template(t[t.n], tb, timpl),
type = t[t.n],
mod = concat(t,1,t.n-1),
is_parameter = is_parameter,
kind = kind
}
else -- kind == "func"
-- check the form: mod type name
--t = split(s,'%s%s*')
t = split_c_tokens(s,'%s+')
local v = t[t.n] -- last word is the function name
local tp,md
if t.n>1 then
tp = t[t.n-1]
md = concat(t,1,t.n-2)
end
--if tp then tp = rebuild_template(tp, tb, timpl) end
return _Declaration{
name = v,
type = tp,
mod = md,
is_parameter = is_parameter,
kind = kind
}
end
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Variable class
-- Represents a extern variable or a public member of a class.
-- Stores all fields present in a declaration.
classVariable = {
_get = {}, -- mapped get functions
_set = {}, -- mapped set functions
}
classVariable.__index = classVariable
setmetatable(classVariable,classDeclaration)
-- Print method
function classVariable:print (ident,close)
print(ident.."Variable{")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.." ptr = '"..self.ptr.."',")
print(ident.." name = '"..self.name.."',")
if self.dim then print(ident.." dim = '"..self.dim.."',") end
print(ident.." def = '"..self.def.."',")
print(ident.." ret = '"..self.ret.."',")
print(ident.."}"..close)
end
-- Generates C function name
function classVariable:cfuncname (prefix)
local parent = ""
local unsigned = ""
local ptr = ""
local p = self:inmodule() or self:innamespace() or self:inclass()
if p then
if self.parent.classtype == 'class' then
parent = "_" .. self.parent.type
else
parent = "_" .. p
end
end
if strfind(self.mod,"(unsigned)") then
unsigned = "_unsigned"
end
if self.ptr == "*" then ptr = "_ptr"
elseif self.ptr == "&" then ptr = "_ref"
end
local name = prefix .. parent .. unsigned .. "_" .. gsub(self.lname or self.name,".*::","") .. ptr
name = clean_template(name)
return name
end
-- check if it is a variable
function classVariable:isvariable ()
return true
end
-- get variable value
function classVariable:getvalue (class,static, prop_get)
local name
if prop_get then
name = prop_get.."()"
else
name = self.name
end
if class and static then
return self.parent.type..'::'..name
elseif class then
return 'self->'..name
else
return name
end
end
-- get variable pointer value
function classVariable:getpointervalue (class,static)
if class and static then
return class..'::p'
elseif class then
return 'self->p'
else
return 'p'
end
end
-- Write binding functions
function classVariable:supcode ()
local class = self:inclass()
local prop_get,prop_set
if string.find(self.mod, 'tolua_property') then
local _,_,type = string.find(self.mod, "tolua_property__([^%s]*)")
type = type or "default"
prop_get,prop_set = get_property_methods(type, self.name)
self.mod = string.gsub(self.mod, "tolua_property[^%s]*", "")
end
-- get function ------------------------------------------------
if class then
output("/* get function:",self.name," of class ",class," */")
else
output("/* get function:",self.name," */")
end
self.cgetname = self:cfuncname("tolua_get")
output("#ifndef TOLUA_DISABLE_"..self.cgetname)
output("\nstatic int",self.cgetname,"(lua_State* tolua_S)")
output("{")
-- declare self, if the case
local _,_,static = strfind(self.mod,'^%s*(static)')
if class and static==nil then
output(' ',self.parent.type,'*','self = ')
output('(',self.parent.type,'*) ')
local to_func = get_to_function(self.parent.type)
output(to_func,'(tolua_S,1,0);')
elseif static then
_,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
end
-- check self value
if class and static==nil then
output('#ifndef TOLUA_RELEASE\n')
output(' if (!self) tolua_error(tolua_S,"'..output_error_hook("invalid \'self\' in accessing variable \'%s\'", self.name)..'",NULL);');
output('#endif\n')
end
-- return value
if string.find(self.mod, 'tolua_inherits') then
local push_func = get_push_function(self.type)
output('#ifdef __cplusplus\n')
output(' ',push_func,'(tolua_S,(void*)static_cast<'..self.type..'*>(self), "',self.type,'");')
output('#else\n')
output(' ',push_func,'(tolua_S,(void*)(('..self.type..'*)self), "',self.type,'");')
output('#endif\n')
else
local t,ct = isbasic(self.type)
if t then
output(' tolua_push'..t..'(tolua_S,(',ct,')'..self:getvalue(class,static,prop_get)..');')
else
local push_func = get_push_function(self.type)
t = self.type
if self.ptr == '&' or self.ptr == '' then
output(' ',push_func,'(tolua_S,(void*)&'..self:getvalue(class,static,prop_get)..',"',t,'");')
else
output(' ',push_func,'(tolua_S,(void*)'..self:getvalue(class,static,prop_get)..',"',t,'");')
end
end
end
output(' return 1;')
output('}')
output('#endif //#ifndef TOLUA_DISABLE\n')
output('\n')
-- set function ------------------------------------------------
if not (strfind(self.type,'const%s+') or string.find(self.mod, 'tolua_readonly') or string.find(self.mod, 'tolua_inherits')) then
if class then
output("/* set function:",self.name," of class ",class," */")
else
output("/* set function:",self.name," */")
end
self.csetname = self:cfuncname("tolua_set")
output("#ifndef TOLUA_DISABLE_"..self.csetname)
output("\nstatic int",self.csetname,"(lua_State* tolua_S)")
output("{")
-- declare self, if the case
if class and static==nil then
output(' ',self.parent.type,'*','self = ')
output('(',self.parent.type,'*) ')
local to_func = get_to_function(self.parent.type)
output(to_func,'(tolua_S,1,0);')
-- check self value
end
-- check types
output('#ifndef TOLUA_RELEASE\n')
output(' tolua_Error tolua_err;')
if class and static==nil then
output(' if (!self) tolua_error(tolua_S,"'..output_error_hook("invalid \'self\' in accessing variable \'%s\'", self.name)..'",NULL);');
elseif static then
_,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
end
-- check variable type
output(' if ('..self:outchecktype(2)..')')
output(' tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);')
output('#endif\n')
-- assign value
local def = 0
if self.def ~= '' then def = self.def end
if self.type == 'char*' and self.dim ~= '' then -- is string
output(' strncpy((char*)')
if class and static then
output(self.parent.type..'::'..self.name)
elseif class then
output('self->'..self.name)
else
output(self.name)
end
output(',(const char*)tolua_tostring(tolua_S,2,',def,'),',self.dim,'-1);')
else
local ptr = ''
if self.ptr~='' then ptr = '*' end
output(' ')
local name = prop_set or self.name
if class and static then
output(self.parent.type..'::'..name)
elseif class then
output('self->'..name)
else
output(name)
end
local t = isbasic(self.type)
if prop_set then
output('(')
else
output(' = ')
end
if not t and ptr=='' then output('*') end
output('((',self.mod,self.type)
if not t then
output('*')
end
output(') ')
if t then
if isenum(self.type) then
output('(int) ')
end
output('tolua_to'..t,'(tolua_S,2,',def,'))')
else
local to_func = get_to_function(self.type)
output(to_func,'(tolua_S,2,',def,'))')
end
if prop_set then
output(")")
end
output(";")
end
output(' return 0;')
output('}')
output('#endif //#ifndef TOLUA_DISABLE\n')
output('\n')
end
end
function classVariable:register (pre)
if not self:check_public_access() then
return
end
pre = pre or ''
local parent = self:inmodule() or self:innamespace() or self:inclass()
if not parent then
if classVariable._warning==nil then
warning("Mapping variable to global may degrade performance")
classVariable._warning = 1
end
end
if self.csetname then
output(pre..'tolua_variable(tolua_S,"'..self.lname..'",'..self.cgetname..','..self.csetname..');')
else
output(pre..'tolua_variable(tolua_S,"'..self.lname..'",'..self.cgetname..',NULL);')
end
end
-- Internal constructor
function _Variable (t)
setmetatable(t,classVariable)
append(t)
return t
end
-- Constructor
-- Expects a string representing the variable declaration.
function Variable (s)
return _Variable (Declaration(s,'var'))
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1999
-- $Id: array.lua,v 1.1 2000/11/06 22:03:57 celes Exp $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Array class
-- Represents a extern array variable or a public member of a class.
-- Stores all fields present in a declaration.
classArray = {
}
classArray.__index = classArray
setmetatable(classArray,classDeclaration)
-- Print method
function classArray:print (ident,close)
print(ident.."Array{")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.." ptr = '"..self.ptr.."',")
print(ident.." name = '"..self.name.."',")
print(ident.." def = '"..self.def.."',")
print(ident.." dim = '"..self.dim.."',")
print(ident.." ret = '"..self.ret.."',")
print(ident.."}"..close)
end
-- check if it is a variable
function classArray:isvariable ()
return true
end
-- get variable value
function classArray:getvalue (class,static)
if class and static then
return class..'::'..self.name..'[tolua_index]'
elseif class then
return 'self->'..self.name..'[tolua_index]'
else
return self.name..'[tolua_index]'
end
end
-- Write binding functions
function classArray:supcode ()
local class = self:inclass()
-- get function ------------------------------------------------
if class then
output("/* get function:",self.name," of class ",class," */")
else
output("/* get function:",self.name," */")
end
self.cgetname = self:cfuncname("tolua_get")
output("#ifndef TOLUA_DISABLE_"..self.cgetname)
output("\nstatic int",self.cgetname,"(lua_State* tolua_S)")
output("{")
output(" int tolua_index;")
-- declare self, if the case
local _,_,static = strfind(self.mod,'^%s*(static)')
if class and static==nil then
output(' ',self.parent.type,'*','self;')
output(' lua_pushstring(tolua_S,".self");')
output(' lua_rawget(tolua_S,1);')
output(' self = ')
output('(',self.parent.type,'*) ')
output('lua_touserdata(tolua_S,-1);')
elseif static then
_,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
end
-- check index
output('#ifndef TOLUA_RELEASE\n')
output(' {')
output(' tolua_Error tolua_err;')
output(' if (!tolua_isnumber(tolua_S,2,0,&tolua_err))')
output(' tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);')
output(' }')
output('#endif\n')
if flags['1'] then -- for compatibility with tolua5 ?
output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;')
else
output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0);')
end
output('#ifndef TOLUA_RELEASE\n')
if self.dim and self.dim ~= '' then
output(' if (tolua_index<0 || tolua_index>='..self.dim..')')
else
output(' if (tolua_index<0)')
end
output(' tolua_error(tolua_S,"array indexing out of range.",NULL);')
output('#endif\n')
-- return value
local t,ct = isbasic(self.type)
local push_func = get_push_function(t)
if t then
output(' tolua_push'..t..'(tolua_S,(',ct,')'..self:getvalue(class,static)..');')
else
t = self.type
if self.ptr == '&' or self.ptr == '' then
output(' ',push_func,'(tolua_S,(void*)&'..self:getvalue(class,static)..',"',t,'");')
else
output(' ',push_func,'(tolua_S,(void*)'..self:getvalue(class,static)..',"',t,'");')
end
end
output(' return 1;')
output('}')
output('#endif //#ifndef TOLUA_DISABLE\n')
output('\n')
-- set function ------------------------------------------------
if not strfind(self.type,'const') then
if class then
output("/* set function:",self.name," of class ",class," */")
else
output("/* set function:",self.name," */")
end
self.csetname = self:cfuncname("tolua_set")
output("#ifndef TOLUA_DISABLE_"..self.csetname)
output("\nstatic int",self.csetname,"(lua_State* tolua_S)")
output("{")
-- declare index
output(' int tolua_index;')
-- declare self, if the case
local _,_,static = strfind(self.mod,'^%s*(static)')
if class and static==nil then
output(' ',self.parent.type,'*','self;')
output(' lua_pushstring(tolua_S,".self");')
output(' lua_rawget(tolua_S,1);')
output(' self = ')
output('(',self.parent.type,'*) ')
output('lua_touserdata(tolua_S,-1);')
elseif static then
_,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
end
-- check index
output('#ifndef TOLUA_RELEASE\n')
output(' {')
output(' tolua_Error tolua_err;')
output(' if (!tolua_isnumber(tolua_S,2,0,&tolua_err))')
output(' tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);')
output(' }')
output('#endif\n')
if flags['1'] then -- for compatibility with tolua5 ?
output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;')
else
2012-06-04 14:58:17 +00:00
output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0);')
2011-10-03 18:41:19 +00:00
end
output('#ifndef TOLUA_RELEASE\n')
if self.dim and self.dim ~= '' then
output(' if (tolua_index<0 || tolua_index>='..self.dim..')')
else
output(' if (tolua_index<0)')
end
output(' tolua_error(tolua_S,"array indexing out of range.",NULL);')
output('#endif\n')
-- assign value
local ptr = ''
if self.ptr~='' then ptr = '*' end
output(' ')
if class and static then
output(class..'::'..self.name..'[tolua_index]')
elseif class then
output('self->'..self.name..'[tolua_index]')
else
output(self.name..'[tolua_index]')
end
local t = isbasic(self.type)
output(' = ')
if not t and ptr=='' then output('*') end
output('((',self.mod,self.type)
if not t then
output('*')
end
output(') ')
local def = 0
if self.def ~= '' then def = self.def end
if t then
output('tolua_to'..t,'(tolua_S,3,',def,'));')
else
local to_func = get_to_function(self.type)
output(to_func,'(tolua_S,3,',def,'));')
end
output(' return 0;')
output('}')
output('#endif //#ifndef TOLUA_DISABLE\n')
output('\n')
end
end
function classArray:register (pre)
if not self:check_public_access() then
return
end
pre = pre or ''
if self.csetname then
output(pre..'tolua_array(tolua_S,"'..self.lname..'",'..self.cgetname..','..self.csetname..');')
else
output(pre..'tolua_array(tolua_S,"'..self.lname..'",'..self.cgetname..',NULL);')
end
end
-- Internal constructor
function _Array (t)
setmetatable(t,classArray)
append(t)
return t
end
-- Constructor
-- Expects a string representing the variable declaration.
function Array (s)
return _Array (Declaration(s,'var'))
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Function class
-- Represents a function or a class method.
-- The following fields are stored:
-- mod = type modifiers
-- type = type
-- ptr = "*" or "&", if representing a pointer or a reference
-- name = name
-- lname = lua name
-- args = list of argument declarations
-- const = if it is a method receiving a const "this".
classFunction = {
mod = '',
type = '',
ptr = '',
name = '',
args = {n=0},
const = '',
}
classFunction.__index = classFunction
setmetatable(classFunction,classFeature)
-- declare tags
function classFunction:decltype ()
self.type = typevar(self.type)
if strfind(self.mod,'const') then
self.type = 'const '..self.type
self.mod = gsub(self.mod,'const','')
end
local i=1
while self.args[i] do
self.args[i]:decltype()
i = i+1
end
end
-- Write binding function
-- Outputs C/C++ binding function.
function classFunction:supcode (local_constructor)
local overload = strsub(self.cname,-2,-1) - 1 -- indicate overloaded func
local nret = 0 -- number of returned values
local class = self:inclass()
local _,_,static = strfind(self.mod,'^%s*(static)')
if class then
if self.name == 'new' and self.parent.flags.pure_virtual then
-- no constructor for classes with pure virtual methods
return
end
if local_constructor then
output("/* method: new_local of class ",class," */")
else
output("/* method:",self.name," of class ",class," */")
end
else
output("/* function:",self.name," */")
end
if local_constructor then
output("#ifndef TOLUA_DISABLE_"..self.cname.."_local")
output("\nstatic int",self.cname.."_local","(lua_State* tolua_S)")
else
output("#ifndef TOLUA_DISABLE_"..self.cname)
output("\nstatic int",self.cname,"(lua_State* tolua_S)")
end
output("{")
-- check types
if overload < 0 then
output('#ifndef TOLUA_RELEASE\n')
end
output(' tolua_Error tolua_err;')
output(' if (\n')
-- check self
local narg
if class then narg=2 else narg=1 end
if class then
local func = get_is_function(self.parent.type)
local type = self.parent.type
if self.name=='new' or static~=nil then
func = 'tolua_isusertable'
type = self.parent.type
end
if self.const ~= '' then
type = "const "..type
end
output(' !'..func..'(tolua_S,1,"'..type..'",0,&tolua_err) ||\n')
end
-- check args
if self.args[1].type ~= 'void' then
local i=1
while self.args[i] do
local btype = isbasic(self.args[i].type)
if btype ~= 'value' and btype ~= 'state' then
output(' '..self.args[i]:outchecktype(narg)..' ||\n')
end
if btype ~= 'state' then
narg = narg+1
end
i = i+1
end
end
-- check end of list
output(' !tolua_isnoobj(tolua_S,'..narg..',&tolua_err)\n )')
output(' goto tolua_lerror;')
output(' else\n')
if overload < 0 then
output('#endif\n')
end
output(' {')
-- declare self, if the case
local narg
if class then narg=2 else narg=1 end
if class and self.name~='new' and static==nil then
output(' ',self.const,self.parent.type,'*','self = ')
output('(',self.const,self.parent.type,'*) ')
local to_func = get_to_function(self.parent.type)
output(to_func,'(tolua_S,1,0);')
elseif static then
_,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
end
-- declare parameters
if self.args[1].type ~= 'void' then
local i=1
while self.args[i] do
self.args[i]:declare(narg)
if isbasic(self.args[i].type) ~= "state" then
narg = narg+1
end
2012-06-04 14:58:17 +00:00
i = i+1
2011-10-03 18:41:19 +00:00
end
end
-- check self
if class and self.name~='new' and static==nil then
output('#ifndef TOLUA_RELEASE\n')
output(' if (!self) tolua_error(tolua_S,"'..output_error_hook("invalid \'self\' in function \'%s\'", self.name)..'", NULL);');
output('#endif\n')
end
-- get array element values
if class then narg=2 else narg=1 end
if self.args[1].type ~= 'void' then
local i=1
while self.args[i] do
self.args[i]:getarray(narg)
narg = narg+1
i = i+1
end
end
pre_call_hook(self)
local out = string.find(self.mod, "tolua_outside")
-- call function
if class and self.name=='delete' then
output(' Mtolua_delete(self);')
elseif class and self.name == 'operator&[]' then
if flags['1'] then -- for compatibility with tolua5 ?
output(' self->operator[](',self.args[1].name,'-1) = ',self.args[2].name,';')
else
output(' self->operator[](',self.args[1].name,') = ',self.args[2].name,';')
end
else
output(' {')
if self.type ~= '' and self.type ~= 'void' then
output(' ',self.mod,self.type,self.ptr,'tolua_ret = ')
output('(',self.mod,self.type,self.ptr,') ')
else
output(' ')
end
if class and self.name=='new' then
output('Mtolua_new((',self.type,')(')
elseif class and static then
if out then
output(self.name,'(')
else
output(class..'::'..self.name,'(')
end
elseif class then
if out then
output(self.name,'(')
else
if self.cast_operator then
--output('static_cast<',self.mod,self.type,self.ptr,' >(*self')
output('self->operator ',self.mod,self.type,'(')
else
output('self->'..self.name,'(')
end
end
else
output(self.name,'(')
end
if out and not static then
output('self')
if self.args[1] and self.args[1].name ~= '' then
output(',')
end
end
-- write parameters
local i=1
while self.args[i] do
self.args[i]:passpar()
i = i+1
if self.args[i] then
output(',')
end
end
2012-06-04 14:58:17 +00:00
if class and self.name == 'operator[]' and flags['1'] then
2011-10-03 18:41:19 +00:00
output('-1);')
else
if class and self.name=='new' then
output('));') -- close Mtolua_new(
else
output(');')
end
end
-- return values
if self.type ~= '' and self.type ~= 'void' then
nret = nret + 1
local t,ct = isbasic(self.type)
if t and self.name ~= "new" then
if self.cast_operator and _basic_raw_push[t] then
output(' ',_basic_raw_push[t],'(tolua_S,(',ct,')tolua_ret);')
else
output(' tolua_push'..t..'(tolua_S,(',ct,')tolua_ret);')
end
else
t = self.type
new_t = string.gsub(t, "const%s+", "")
local owned = false
if string.find(self.mod, "tolua_owned") then
owned = true
end
local push_func = get_push_function(t)
if self.ptr == '' then
output(' {')
output('#ifdef __cplusplus\n')
output(' void* tolua_obj = Mtolua_new((',new_t,')(tolua_ret));')
output(' ',push_func,'(tolua_S,tolua_obj,"',t,'");')
output(' tolua_register_gc(tolua_S,lua_gettop(tolua_S));')
output('#else\n')
output(' void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(',t,'));')
output(' ',push_func,'(tolua_S,tolua_obj,"',t,'");')
output(' tolua_register_gc(tolua_S,lua_gettop(tolua_S));')
output('#endif\n')
output(' }')
elseif self.ptr == '&' then
output(' ',push_func,'(tolua_S,(void*)&tolua_ret,"',t,'");')
else
output(' ',push_func,'(tolua_S,(void*)tolua_ret,"',t,'");')
if owned or local_constructor then
output(' tolua_register_gc(tolua_S,lua_gettop(tolua_S));')
end
end
end
end
local i=1
while self.args[i] do
nret = nret + self.args[i]:retvalue()
i = i+1
end
output(' }')
-- set array element values
if class then narg=2 else narg=1 end
if self.args[1].type ~= 'void' then
local i=1
while self.args[i] do
self.args[i]:setarray(narg)
narg = narg+1
i = i+1
end
end
-- free dynamically allocated array
if self.args[1].type ~= 'void' then
local i=1
while self.args[i] do
self.args[i]:freearray()
i = i+1
end
end
end
post_call_hook(self)
output(' }')
output(' return '..nret..';')
-- call overloaded function or generate error
if overload < 0 then
output('#ifndef TOLUA_RELEASE\n')
output('tolua_lerror:\n')
output(' tolua_error(tolua_S,"'..output_error_hook("#ferror in function \'%s\'.", self.lname)..'",&tolua_err);')
output(' return 0;')
output('#endif\n')
else
local _local = ""
if local_constructor then
_local = "_local"
end
output('tolua_lerror:\n')
output(' return '..strsub(self.cname,1,-3)..format("%02d",overload).._local..'(tolua_S);')
end
output('}')
output('#endif //#ifndef TOLUA_DISABLE\n')
output('\n')
-- recursive call to write local constructor
if class and self.name=='new' and not local_constructor then
self:supcode(1)
end
end
-- register function
function classFunction:register (pre)
if not self:check_public_access() then
return
end
if self.name == 'new' and self.parent.flags.pure_virtual then
-- no constructor for classes with pure virtual methods
return
end
output(pre..'tolua_function(tolua_S,"'..self.lname..'",'..self.cname..');')
if self.name == 'new' then
output(pre..'tolua_function(tolua_S,"new_local",'..self.cname..'_local);')
output(pre..'tolua_function(tolua_S,".call",'..self.cname..'_local);')
--output(' tolua_set_call_event(tolua_S,'..self.cname..'_local, "'..self.parent.type..'");')
end
end
-- Print method
function classFunction:print (ident,close)
print(ident.."Function{")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.." ptr = '"..self.ptr.."',")
print(ident.." name = '"..self.name.."',")
print(ident.." lname = '"..self.lname.."',")
print(ident.." const = '"..self.const.."',")
print(ident.." cname = '"..self.cname.."',")
print(ident.." lname = '"..self.lname.."',")
print(ident.." args = {")
local i=1
while self.args[i] do
self.args[i]:print(ident.." ",",")
i = i+1
end
print(ident.." }")
print(ident.."}"..close)
end
-- check if it returns an object by value
function classFunction:requirecollection (t)
local r = false
if self.type ~= '' and not isbasic(self.type) and self.ptr=='' then
local type = gsub(self.type,"%s*const%s+","")
t[type] = "tolua_collect_" .. clean_template(type)
r = true
end
local i=1
while self.args[i] do
r = self.args[i]:requirecollection(t) or r
i = i+1
end
return r
end
-- determine lua function name overload
function classFunction:overload ()
return self.parent:overload(self.lname)
end
function param_object(par) -- returns true if the parameter has an object as its default value
if not string.find(par, '=') then return false end -- it has no default value
local _,_,def = string.find(par, "=(.*)$")
if string.find(par, "|") then -- a list of flags
return true
end
if string.find(par, "%*") then -- it's a pointer with a default value
if string.find(par, '=%s*new') or string.find(par, "%(") then -- it's a pointer with an instance as default parameter.. is that valid?
return true
end
return false -- default value is 'NULL' or something
end
if string.find(par, "[%(&]") then
return true
end -- default value is a constructor call (most likely for a const reference)
--if string.find(par, "&") then
2012-06-04 14:58:17 +00:00
2011-10-03 18:41:19 +00:00
-- if string.find(def, ":") or string.find(def, "^%s*new%s+") then
-- -- it's a reference with default to something like Class::member, or 'new Class'
-- return true
-- end
--end
return false -- ?
end
function strip_last_arg(all_args, last_arg) -- strips the default value from the last argument
local _,_,s_arg = string.find(last_arg, "^([^=]+)")
last_arg = string.gsub(last_arg, "([%%%(%)])", "%%%1");
all_args = string.gsub(all_args, "%s*,%s*"..last_arg.."%s*%)%s*$", ")")
return all_args, s_arg
end
-- Internal constructor
function _Function (t)
setmetatable(t,classFunction)
if t.const ~= 'const' and t.const ~= '' then
error("#invalid 'const' specification")
end
append(t)
if t:inclass() then
--print ('t.name is '..t.name..', parent.name is '..t.parent.name)
if string.gsub(t.name, "%b<>", "") == string.gsub(t.parent.original_name or t.parent.name, "%b<>", "") then
t.name = 'new'
t.lname = 'new'
t.parent._new = true
t.type = t.parent.name
t.ptr = '*'
elseif string.gsub(t.name, "%b<>", "") == '~'..string.gsub(t.parent.original_name or t.parent.name, "%b<>", "") then
t.name = 'delete'
t.lname = 'delete'
t.parent._delete = true
end
end
t.cname = t:cfuncname("tolua")..t:overload(t)
return t
end
-- Constructor
-- Expects three strings: one representing the function declaration,
-- another representing the argument list, and the third representing
-- the "const" or empty string.
function Function (d,a,c)
--local t = split(strsub(a,2,-2),',') -- eliminate braces
--local t = split_params(strsub(a,2,-2))
if not flags['W'] and string.find(a, "%.%.%.%s*%)") then
warning("Functions with variable arguments (`...') are not supported. Ignoring "..d..a..c)
return nil
end
local i=1
local l = {n=0}
a = string.gsub(a, "%s*([%(%)])%s*", "%1")
local t,strip,last = strip_pars(strsub(a,2,-2));
if strip then
--local ns = string.sub(strsub(a,1,-2), 1, -(string.len(last)+1))
local ns = join(t, ",", 1, last-1)
ns = "("..string.gsub(ns, "%s*,%s*$", "")..')'
--ns = strip_defaults(ns)
local f = Function(d, ns, c)
for i=1,last do
2012-06-04 14:58:17 +00:00
t[i] = string.gsub(t[i], "=.*$", "")
2011-10-03 18:41:19 +00:00
end
end
while t[i] do
l.n = l.n+1
l[l.n] = Declaration(t[i],'var',true)
i = i+1
end
local f = Declaration(d,'func')
f.args = l
f.const = c
return _Function(f)
end
function join(t, sep, first, last)
first = first or 1
last = last or table.getn(t)
local lsep = ""
local ret = ""
local loop = false
for i = first,last do
ret = ret..lsep..t[i]
lsep = sep
loop = true
end
if not loop then
return ""
end
return ret
end
function strip_pars(s)
local t = split_c_tokens(s, ',')
local strip = false
local last
for i=t.n,1,-1 do
if not strip and param_object(t[i]) then
last = i
strip = true
end
2012-06-04 14:58:17 +00:00
--if strip then
2011-10-03 18:41:19 +00:00
-- t[i] = string.gsub(t[i], "=.*$", "")
2012-06-04 14:58:17 +00:00
--end
2011-10-03 18:41:19 +00:00
end
return t,strip,last
end
function strip_defaults(s)
s = string.gsub(s, "^%(", "")
s = string.gsub(s, "%)$", "")
local t = split_c_tokens(s, ",")
local sep, ret = "",""
for i=1,t.n do
t[i] = string.gsub(t[i], "=.*$", "")
ret = ret..sep..t[i]
sep = ","
end
return "("..ret..")"
end
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Operator class
-- Represents an operator function or a class operator method.
-- It stores the same fields as functions do plus:
-- kind = set of character representing the operator (as it appers in C++ code)
classOperator = {
kind = '',
}
classOperator.__index = classOperator
setmetatable(classOperator,classFunction)
-- table to transform operator kind into the appropriate tag method name
_TM = {['+'] = 'add',
['-'] = 'sub',
['*'] = 'mul',
['/'] = 'div',
['<'] = 'lt',
['<='] = 'le',
['=='] = 'eq',
2012-06-04 14:58:17 +00:00
['[]'] = 'geti',
['&[]'] = 'seti',
--['->'] = 'flechita',
2011-10-03 18:41:19 +00:00
}
-- Print method
function classOperator:print (ident,close)
2012-06-04 14:58:17 +00:00
print(ident.."Operator{")
print(ident.." kind = '"..self.kind.."',")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.." ptr = '"..self.ptr.."',")
print(ident.." name = '"..self.name.."',")
print(ident.." const = '"..self.const.."',")
print(ident.." cname = '"..self.cname.."',")
print(ident.." lname = '"..self.lname.."',")
print(ident.." args = {")
local i=1
while self.args[i] do
self.args[i]:print(ident.." ",",")
i = i+1
end
print(ident.." }")
print(ident.."}"..close)
end
function classOperator:supcode_tmp()
if not _TM[self.kind] then
return classFunction.supcode(self)
end
-- no overload, no parameters, always inclass
output("/* method:",self.name," of class ",self:inclass()," */")
output("#ifndef TOLUA_DISABLE_"..self.cname)
output("\nstatic int",self.cname,"(lua_State* tolua_S)")
if overload < 0 then
output('#ifndef TOLUA_RELEASE\n')
end
output(' tolua_Error tolua_err;')
output(' if (\n')
-- check self
local is_func = get_is_function(self.parent.type)
output(' !'..is_func..'(tolua_S,1,"'..self.parent.type..'",0,&tolua_err) ||\n')
output(' !tolua_isnoobj(tolua_S,2,&tolua_err)\n )')
output(' goto tolua_lerror;')
output(' else\n')
2011-10-03 18:41:19 +00:00
output('#endif\n') -- tolua_release
output(' {')
2012-06-04 14:58:17 +00:00
-- declare self
output(' ',self.const,self.parent.type,'*','self = ')
output('(',self.const,self.parent.type,'*) ')
local to_func = get_to_func(self.parent.type)
output(to_func,'(tolua_S,1,0);')
2011-10-03 18:41:19 +00:00
-- check self
output('#ifndef TOLUA_RELEASE\n')
2012-06-04 14:58:17 +00:00
output(' if (!self) tolua_error(tolua_S,"'..output_error_hook("invalid \'self\' in function \'%s\'", self.name)..'",NULL);');
2011-10-03 18:41:19 +00:00
output('#endif\n')
-- cast self
output(' ',self.mod,self.type,self.ptr,'tolua_ret = ')
output('(',self.mod,self.type,self.ptr,')(*self);')
-- return value
2012-06-04 14:58:17 +00:00
local t,ct = isbasic(self.type)
