با انتشار اولین نسخه DoLang مشخص میشه که من چرا اسم زبانم رو DoLang گذاشتم. سعی کردم که زبان رو بشه به راحتی توسعه داد. هنوز خیلی از قسمت های اون نوشته نشده و دلیلش هم درد دست من هست. تا الان خیلی از قسمت ها رو زبان پشتیبانی میکنه و به زودی بعد از خوب شدن درد دستم تمامی قسمت های زبان رو تکمیل میکنم و برای تمام Cpu ها هم اون رو توسعه میدم. جذابیت DoLang این هست که خروجی به همراه Assembly هست و شما میتونید ساز و کار کامپایل و تبدیل کد به اسمبلی رو ببینید.

https://github.com/pejman-hkh/dolang

( قسمت هایی از کتاب رعنا. با نویسندگی خودم. برای خرید کتاب رعنا ( ۱۰۰ صفحه ) از قسمت کامنت ها پیام بدین. ۵۰ هزارتومان )

آخر باغ در اتاق کوچکی که صاحب باغ به من داده زندگی میکنم، صاحب باغ اینجا را به من داده تا هم در آن زندگی کنم و هم از باغ مراقبت کنم، اتاقی با دیوارهای سفید و یک لامپ زرد که وسط اتاق همیشه خدا روشن است، از همان روز اولی که من را دید از من خوشش امد، اخر من پسر سر به زیری بودم، به قول خودش من حتی یکبار هم به صورت دخترش نگاه نکرده ام، مادر دخترک چند سال پیش در تصادف مرده بود و پدر دخترش را خودش بزرگ کرده بود، راست میگفت، من حتی یکبار هم سرم را بالا نیاوردم تا صورت دخترش را نگاه کنم

از همان روز اول که دخترک با لباس سفید را در باغ بر سر قبر مادرش دیدم به خودم گفتم مادرش انطرفتر دارد نگاهش میکند، اما دریغ که دخترک نمیتواند مادرش را ببیند، هر بار که ساعت از ۱۲ رد میشود عروسکش را در دستانش میگیرد و با ان لباس ژولیده ای که بر تن دارد بر سر قبر مادرش می اید،

دخترک هر شب بر سر قبر مادرش گریه میکند و مادرش را صدا میزند، انطرف مادرش با دیدن اشکهای دخترش زجه میزند چون که دلش برای دخترش تنگ شده است

اقای خانه چند هفته ای بود که با دخترش به باغ نیامده بودند، خانم من را صدا کرد تا برای خرید خانه با او همراه شوم

در ادامه طراحی dolang یکی از مهمترین قسمت ها تعریف متغییر global چه به صورت کلی و چه در کلاس ها هست. در کلاس ها باید این متغییر global با دسترسی private یا public امکان تغییر برای هر object را به صورت مجزا داشته باشد.

چلنج کار من این قسمت هست. یعنی تعریف و تغییر متغیر برای هر object به صور مجزا. که متدهای کلاس ها رو به این شکل بهم دیگه وصل میکنیم ...

در ادامه در object ها باید بتونم fuction هم نگه دارم و اون رو call کنم ...

نوشتن در مورد اینکه چه کاری قرار هست انجام بدم به من انگیزه میده ...

در ادامه object و مقدار دهی شبیه به js رو شبیه سازی کردم ...

	var arr = {};

	for( var i = 0; i < 10; i++ ) {
		var a = [];

		var b =  test()+i;

		var l = i+test();

		a.id = i;
		a.name = b;

		arr[i] = a;
	
	}

	for( var k,v in arr ) {
		print(k);
		print(" : ");
		print(v);
		print("\n");

	}
    ```

الان متغییر های لوکال تنها scope مربوط به فانکشن رو رعایت میکنن و هنوز متغییر هایی با دسترسی مشابه let در js رو پیاده سازی نکردم.

الان باید برم سراغ تعریف متغییر های global چه به صورت کلی و چه در کلاس ها.

بعد از این مرحله به سراغ تکمیل کلاس ها و اضافه کردن construct و destruct و extends و ... میرم.

نمونه برنامه تا الان زبان dolang

این رو بگم که در خروجی برنامه برای برخی از کارها من تابع c در assembly صدا زدم. که بعد ها در صورت امکان و مقرون به صرفه بودن و برای افزایش سرعت کار اون ها رو تبدیل به assembly میکنم.

مثلا برای ست کردن مقدار آرایه بعد از تعریف از set_val استفاده کردم و ...

test() {
	return "aaaa";
}

class test1 {
	a(b) {
		for( var j = 0; j < 10; j++ ) {
			print("j : "+j+" / ");
			for( var s = 0; s < 10; s++ ) {
				print("s:"+s+",");
			}

			print("\n");
		}
		return "aaa";
	}

	c(var d) {
	}

}

main() {

	var aa = new test1;
	print( aa.a() );



	var arr = [];

	for( var i = 0; i < 10; i++ ) {
		var a = [];

		var b =  test()+i;

		var l = i+test();

		a['id'] = i;
		a['name'] = b;

		arr[i] = a;
	
	}

	for( var k,v in arr ) {
		print(k);
		print(" : ");
		print(v);
		print("\n");
	}

	print("test\n");

	var s = "ddd\n";
	print(s);

	print("test1\n");

}

خروجی برنامه :

push %ebp
mov %esp,%ebp
mov 0x5807d1ac,%eax
jmp $
leave
ret
push %ebp
mov %esp,%ebp
sub $,%esp
mov 0x0,%eax
sub $,%esp
mov %eax,0(%esp)
call do_to_var 0x64864d63
add $,%esp
mov %eax,-4(%ebp)
mov -4(%ebp),%eax
push %eax
mov 0xa,%eax
sub $,%esp
mov %eax,0(%esp)
call do_to_var 0x64864d39
add $,%esp
pop %ecx
mov  0x4(%eax),%eax
mov  0x4(%ecx),%ecx
cmp %eax,%ecx
mov $0x0,%eax
setl %al
sub $,%esp
mov %eax,0(%esp)
call do_to_var 0x64864d10
add $,%esp
jmp  $
mov -4(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
call do_fn_plus_plus 0x64864b07
add $,%esp
jmp  $
mov  0x4(%eax),%eax
test %eax,%eax
je $
sub $,%esp
mov 0x5807d1da,%eax
push %eax
mov -4(%ebp),%eax
pop %ecx
sub $,%esp
mov %eax,0(%esp)
mov %ecx, %eax
mov %eax,4(%esp)
call do_fn_add 0x64864ae6
add $,%esp
push %eax
mov 0x5807d1e1,%eax
pop %ecx
sub $,%esp
mov %eax,0(%esp)
mov %ecx, %eax
mov %eax,4(%esp)
call do_fn_add 0x64864abe
add $,%esp
mov %eax,0(%esp)
call print 0x648649a7
add $,%esp
mov 0x0,%eax
sub $,%esp
mov %eax,0(%esp)
call do_to_var 0x64864c52
add $,%esp
mov %eax,-8(%ebp)
mov -8(%ebp),%eax
push %eax
mov 0xa,%eax
sub $,%esp
mov %eax,0(%esp)
call do_to_var 0x64864c28
add $,%esp
pop %ecx
mov  0x4(%eax),%eax
mov  0x4(%ecx),%ecx
cmp %eax,%ecx
mov $0x0,%eax
setl %al
sub $,%esp
mov %eax,0(%esp)
call do_to_var 0x64864bff
add $,%esp
jmp  $
mov -8(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
call do_fn_plus_plus 0x648649f6
add $,%esp
jmp  $
mov  0x4(%eax),%eax
test %eax,%eax
je $
sub $,%esp
mov 0x5807d1fe,%eax
push %eax
mov -8(%ebp),%eax
pop %ecx
sub $,%esp
mov %eax,0(%esp)
mov %ecx, %eax
mov %eax,4(%esp)
call do_fn_add 0x648649d5
add $,%esp
push %eax
mov 0x5807d203,%eax
pop %ecx
sub $,%esp
mov %eax,0(%esp)
mov %ecx, %eax
mov %eax,4(%esp)
call do_fn_add 0x648649ad
add $,%esp
mov %eax,0(%esp)
call print 0x64864896
add $,%esp
jmp  $
sub $,%esp
mov 0x5807d20b,%eax
mov %eax,0(%esp)
call print 0x64864874
add $,%esp
jmp  $
mov 0x5807d214,%eax
jmp $
leave
ret
push %ebp
mov %esp,%ebp
leave
ret
push %ebp
mov %esp,%ebp
sub $,%esp
sub $,%esp
mov -4(%ebp),%eax
sub $,%esp
call  0xfffffd7d
mov %eax,0(%esp)
call print 0x6486482c
add $,%esp
sub $,%esp
call do_fn_create_array 0x64865eb7
add $,%esp
mov %eax,-16(%ebp)
mov -16(%ebp),%eax
mov %eax,-8(%ebp)
mov 0x0,%eax
sub $,%esp
mov %eax,0(%esp)
call do_to_var 0x64864ab4
add $,%esp
mov %eax,-20(%ebp)
mov -20(%ebp),%eax
push %eax
mov 0xa,%eax
sub $,%esp
mov %eax,0(%esp)
call do_to_var 0x64864a8a
add $,%esp
pop %ecx
mov  0x4(%eax),%eax
mov  0x4(%ecx),%ecx
cmp %eax,%ecx
mov $0x0,%eax
setl %al
sub $,%esp
mov %eax,0(%esp)
call do_to_var 0x64864a61
add $,%esp
jmp  $
mov -20(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
call do_fn_plus_plus 0x64864858
add $,%esp
jmp  $
mov  0x4(%eax),%eax
test %eax,%eax
je $
sub $,%esp
call do_fn_create_array 0x64865df1
add $,%esp
mov %eax,-32(%ebp)
mov -32(%ebp),%eax
mov %eax,-24(%ebp)
sub $,%esp
call test 0xfffffc68
push %eax
mov -20(%ebp),%eax
pop %ecx
sub $,%esp
mov %eax,0(%esp)
mov %ecx, %eax
mov %eax,4(%esp)
call do_fn_add 0x64864814
add $,%esp
mov %eax,8(%ebp)
mov -20(%ebp),%eax
push %eax
sub $,%esp
call test 0xfffffc27
pop %ecx
sub $,%esp
mov %eax,0(%esp)
mov %ecx, %eax
mov %eax,4(%esp)
call do_fn_add 0x648647da
add $,%esp
mov %eax,-40(%ebp)
mov -24(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
mov 0x5807d27e,%eax
mov %eax,4(%esp)
call array_get 0x64864315
add $,%esp
sub $,%esp
mov %eax,0(%esp)
mov -20(%ebp),%eax
mov %eax,4(%esp)
call set_val 0x6486455b
add $,%esp
mov -24(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
mov 0x5807d285,%eax
mov %eax,4(%esp)
call array_get 0x648642c6
add $,%esp
sub $,%esp
mov %eax,0(%esp)
mov 8(%ebp),%eax
mov %eax,4(%esp)
call set_val 0x6486450c
add $,%esp
mov -8(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
mov -20(%ebp),%eax
mov %eax,4(%esp)
call array_get 0x64864276
add $,%esp
sub $,%esp
mov %eax,0(%esp)
mov -24(%ebp),%eax
mov %eax,4(%esp)
call set_val 0x648644bc
add $,%esp
jmp  $
mov -52(%ebp),%eax
mov 0x0,%eax
sub $,%esp
mov %eax,0(%esp)
call do_to_var 0x64864881
add $,%esp
mov %eax,-52(%ebp)
mov -52(%ebp),%eax
push %eax
sub $,%esp
mov -8(%ebp),%eax
mov %eax,-56(%ebp)
mov %eax,0(%esp)
call array_len 0x64864416
add $,%esp
pop %ecx
mov  0x4(%eax),%eax
mov  0x4(%ecx),%ecx
cmp %eax,%ecx
mov $0x0,%eax
setl %al
test %eax,%eax
je $
sub $,%esp
mov -56(%ebp),%eax
mov %eax,0(%esp)
mov -52(%ebp),%eax
mov %eax,4(%esp)
call array_key 0x6486436f
add $,%esp
mov %eax,-44(%ebp)
sub $,%esp
mov -56(%ebp),%eax
mov %eax,0(%esp)
mov -52(%ebp),%eax
mov %eax,4(%esp)
call array_value 0x6486436f
add $,%esp
mov %eax,-48(%ebp)
sub $,%esp
mov -44(%ebp),%eax
mov %eax,0(%esp)
call print 0x648644ef
add $,%esp
sub $,%esp
mov 0x5807d2b5,%eax
mov %eax,0(%esp)
call print 0x648644d2
add $,%esp
sub $,%esp
mov -48(%ebp),%eax
mov %eax,0(%esp)
call print 0x648644b4
add $,%esp
sub $,%esp
mov 0x5807d2c7,%eax
mov %eax,0(%esp)
call print 0x64864497
add $,%esp
mov -52(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
call do_fn_plus_plus 0x6486455b
add $,%esp
jmp  $
sub $,%esp
mov 0x5807d2cf,%eax
mov %eax,0(%esp)
call print 0x64864457
add $,%esp
mov 0x5807d2db,%eax
mov %eax,-8(%ebp)
sub $,%esp
mov -8(%ebp),%eax
mov %eax,0(%esp)
call print 0x6486442e
add $,%esp
sub $,%esp
mov 0x5807d2ee,%eax
mov %eax,0(%esp)
call print 0x64864411
add $,%esp
leave
ret
j : 0 / s:0,s:1,s:2,s:3,s:4,s:5,s:6,s:7,s:8,s:9,
j : 1 / s:0,s:1,s:2,s:3,s:4,s:5,s:6,s:7,s:8,s:9,
j : 2 / s:0,s:1,s:2,s:3,s:4,s:5,s:6,s:7,s:8,s:9,
j : 3 / s:0,s:1,s:2,s:3,s:4,s:5,s:6,s:7,s:8,s:9,
j : 4 / s:0,s:1,s:2,s:3,s:4,s:5,s:6,s:7,s:8,s:9,
j : 5 / s:0,s:1,s:2,s:3,s:4,s:5,s:6,s:7,s:8,s:9,
j : 6 / s:0,s:1,s:2,s:3,s:4,s:5,s:6,s:7,s:8,s:9,
j : 7 / s:0,s:1,s:2,s:3,s:4,s:5,s:6,s:7,s:8,s:9,
j : 8 / s:0,s:1,s:2,s:3,s:4,s:5,s:6,s:7,s:8,s:9,
j : 9 / s:0,s:1,s:2,s:3,s:4,s:5,s:6,s:7,s:8,s:9,
aaa0 : [id:0,name:aaaa0]
1 : [id:1,name:aaaa1]
2 : [id:2,name:aaaa2]
3 : [id:3,name:aaaa3]
4 : [id:4,name:aaaa4]
5 : [id:5,name:aaaa5]
6 : [id:6,name:aaaa6]
7 : [id:7,name:aaaa7]
8 : [id:8,name:aaaa8]
9 : [id:9,name:aaaa9]
test
ddd
test1

پیاده سازی for in

خب بالاخره این قسمت رو هم پیاده سازی کردم ... این قسمت خیلی سخت و زمانگیر بود. مغزمو کمی متلاشی کرد :-D

	var arr = [];
	var i = 0;
	while( i < 10 ) {
		var a = [];

		var b =  test()+i;

		a['id'] = i;
		a['name'] = b;

		arr[i] = a;
		i++;
	}

	for( var k,v in arr ) {
		print(k);
		print(" : ")
		print(v);
		print("\n");
	}

push %ebp
mov %esp,%ebp
mov 0x583dd1ac,%eax
sub $,%esp
mov %eax,-4(%ebp)
movb $0x2,-8(%ebp)
lea -8(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
call do_fn_return 0x64794346
add $,%esp
jmp $
leave
ret
push %ebp
mov %esp,%ebp
sub $
,%esp
sub $,%esp
call do_fn_create_array 0x647952e5
add $,%esp
mov %eax,-12(%ebp)
mov -12(%ebp),%eax
mov %eax,-4(%ebp)
mov 0x0,%eax
mov %eax,-20(%ebp)
movb $0x2,-24(%ebp)
lea -24(%ebp),%eax
mov %eax,-16(%ebp)
mov -16(%ebp),%eax
push %eax
mov 0xa,%eax
mov %eax,-28(%ebp)
movb $0x2,-32(%ebp)
lea -32(%ebp),%eax
pop %ecx
mov  0x4(%eax),%eax
mov  0x4(%ecx),%ecx
cmp %eax,%ecx
mov $0x0,%eax
setl %al
mov %eax,-36(%ebp)
movb $0x2,-40(%ebp)
lea -40(%ebp),%eax
mov  0x4(%eax),%eax
test %eax,%eax
je $
sub $,%esp
call do_fn_create_array 0x64795271
add $,%esp
mov %eax,-52(%ebp)
mov -52(%ebp),%eax
mov %eax,-44(%ebp)
sub $,%esp
call test 0xffffff1e
push %eax
mov -16(%ebp),%eax
pop %ecx
sub $,%esp
mov %eax,0(%esp)
mov %ecx, %eax
mov %eax,4(%esp)
call do_fn_add 0x64793aca
add $,%esp
mov %eax,-56(%ebp)
mov -44(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
mov 0x583dd1e6,%eax
mov %eax,-60(%ebp)
movb $0x2,-64(%ebp)
lea -64(%ebp),%eax
mov %eax,4(%esp)
call array_get 0x647935fb
add $,%esp
sub $,%esp
mov %eax,0(%esp)
mov -16(%ebp),%eax
mov %eax,4(%esp)
call set_val 0x64793841
add $,%esp
mov -44(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
mov 0x583dd1ed,%eax
mov %eax,-68(%ebp)
movb $0x2,-72(%ebp)
lea -72(%ebp),%eax
mov %eax,4(%esp)
call array_get 0x647935a2
add $,%esp
sub $,%esp
mov %eax,0(%esp)
mov -56(%ebp),%eax
mov %eax,4(%esp)
call set_val 0x647937e8
add $,%esp
mov -4(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
mov -16(%ebp),%eax
mov %eax,4(%esp)
call array_get 0x64793552
add $,%esp
sub $,%esp
mov %eax,0(%esp)
mov -44(%ebp),%eax
mov %eax,4(%esp)
call set_val 0x64793798
add $,%esp
mov -16(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
call do_fn_plus_plus 0x64793981
add $,%esp
jmp  $
in for 
mov -84(%ebp),%eax
mov 0x0,%eax
mov %eax,-88(%ebp)
movb $0x2,-92(%ebp)
lea -92(%ebp),%eax
mov %eax,-84(%ebp)
mov -84(%ebp),%eax
push %eax
sub $,%esp
mov -4(%ebp),%eax
mov %eax,-96(%ebp)
mov %eax,0(%esp)
call array_len 0x647936e2
add $,%esp
pop %ecx
mov  0x4(%eax),%eax
mov  0x4(%ecx),%ecx
cmp %eax,%ecx
mov $0x0,%eax
setl %al
test %eax,%eax
je $
sub $,%esp
mov -96(%ebp),%eax
mov %eax,0(%esp)
mov -84(%ebp),%eax
mov %eax,4(%esp)
call array_key 0x6479363b
add $,%esp
mov %eax,-76(%ebp)
sub $,%esp
mov -96(%ebp),%eax
mov %eax,0(%esp)
mov -84(%ebp),%eax
mov %eax,4(%esp)
call array_value 0x6479363b
add $,%esp
mov %eax,-80(%ebp)
sub $,%esp
mov -76(%ebp),%eax
mov %eax,0(%esp)
call print 0x647937bb
add $,%esp
sub $,%esp
mov 0x583dd21f,%eax
mov %eax,-100(%ebp)
movb $0x2,-104(%ebp)
lea -104(%ebp),%eax
mov %eax,0(%esp)
call print 0x64793794
add $,%esp
sub $,%esp
mov -80(%ebp),%eax
mov %eax,0(%esp)
call print 0x64793776
add $,%esp
sub $,%esp
mov 0x583dd231,%eax
mov %eax,-108(%ebp)
movb $0x2,-112(%ebp)
lea -112(%ebp),%eax
mov %eax,0(%esp)
call print 0x6479374f
add $,%esp
mov -84(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
call do_fn_plus_plus 0x64793813
add $,%esp
jmp  $
leave
ret
0 : [id:0,name:aaaa0]
1 : [id:1,name:aaaa1]
2 : [id:2,name:aaaa2]
3 : [id:3,name:aaaa3]
4 : [id:4,name:aaaa4]
5 : [id:5,name:aaaa5]
6 : [id:6,name:aaaa6]
7 : [id:7,name:aaaa7]
8 : [id:8,name:aaaa8]
9 : [id:9,name:aaaa9]

خب همونجور که قبلا گفتم تمامی مقادیر خودشون یک struct هستن که مقدار و نوع اون رو نگه میداریم.

برای گرفتن این مقدار و استفاده مستقیم در توابع c از .val استفاده میکنیم.

مثلا برای چاپ کردن یک رشته :

	var a = "val";
	printf("key : %s\n".val, a.val );

پیاده سازی آرایه با اسمبلی واقعا برام زمانبر بود. دیباگ کردن و تریس کردن کار و رسوندن کار به جایی که همه چیز اوکی باشه خیلی سخت بود که بالاخره انجام شد.

چلنج آخر که باعث برطرف شدن یکسری باگ ها هم شد و در آخر آرایه رو هم چاپ کردم ...

var arr = [];
var i = 0;
while( i < 10 ) {
	var a = [];

	var b = "abbas "+i;

	a['id'] = i;
	a['name'] = b;

	arr[i] = a;
	i++;
}

print( arr );

push %ebp
mov %esp,%ebp
sub $,%esp
sub $,%esp
call do_fn_create_array 0x647de29a
add $,%esp
mov %eax,-12(%ebp)
mov -12(%ebp),%eax
mov %eax,-4(%ebp)
mov 0x0,%eax
mov %eax,-20(%ebp)
movb $0x2,-24(%ebp)
lea -24(%ebp),%eax
mov %eax,-16(%ebp)
mov -16(%ebp),%eax
push %eax
mov 0xa,%eax
mov %eax,-28(%ebp)
movb $0x2,-32(%ebp)
lea -32(%ebp),%eax
pop %ecx
mov  0x4(%eax),%eax
mov  0x4(%ecx),%ecx
cmp %eax,%ecx
mov $0x0,%eax
setl %al
mov %eax,-36(%ebp)
movb $0x2,-40(%ebp)
lea -40(%ebp),%eax
mov  0x4(%eax),%eax
test %eax,%eax
je $
sub $,%esp
call do_fn_create_array 0x647de226
add $,%esp
mov %eax,-52(%ebp)
mov -52(%ebp),%eax
mov %eax,-44(%ebp)
mov 0x57f321cc,%eax
mov %eax,-60(%ebp)
movb $0x2,-64(%ebp)
lea -64(%ebp),%eax
push %eax
mov -16(%ebp),%eax
pop %ecx
sub $,%esp
mov %eax,0(%esp)
mov %ecx, %eax
mov %eax,4(%esp)
call do_fn_add 0x647dcadc
add $,%esp
mov %eax,-56(%ebp)
mov -44(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
mov 0x57f321d7,%eax
mov %eax,-68(%ebp)
movb $0x2,-72(%ebp)
lea -72(%ebp),%eax
mov %eax,4(%esp)
call array_get 0x647dc62e
add $,%esp
sub $,%esp
mov %eax,0(%esp)
mov -16(%ebp),%eax
mov %eax,4(%esp)
call set_val 0x647dc853
add $,%esp
mov -44(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
mov 0x57f321de,%eax
mov %eax,-76(%ebp)
movb $0x2,-80(%ebp)
lea -80(%ebp),%eax
mov %eax,4(%esp)
call array_get 0x647dc5d5
add $,%esp
sub $,%esp
mov %eax,0(%esp)
mov -56(%ebp),%eax
mov %eax,4(%esp)
call set_val 0x647dc7fa
add $,%esp
mov -4(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
mov -16(%ebp),%eax
mov %eax,4(%esp)
call array_get 0x647dc585
add $,%esp
sub $,%esp
mov %eax,0(%esp)
mov -44(%ebp),%eax
mov %eax,4(%esp)
call set_val 0x647dc7aa
add $,%esp
mov -16(%ebp),%eax
sub $,%esp
mov %eax,0(%esp)
call do_fn_plus_plus 0x647dc993
add $,%esp
jmp  $
sub $,%esp
mov -4(%ebp),%eax
mov %eax,0(%esp)
call print 0x647dc88e
add $,%esp
leave
ret
[0:[id:0,name:abbas 0],1:[id:1,name:abbas 1],2:[id:2,name:abbas 2],3:[id:3,name:abbas 3],4:[id:4,name:abbas 4],5:[id:5,name:abbas 5],6:[id:6,name:abbas 6],7:[id:7,name:abbas 7],8:[id:8,name:abbas 8],9:[id:9,name:abbas 9]]

آخر نتونستم بدون کامپیوتر سر کنم.

تنهایی امان من را بریده. دلم هم صحبتی میخواد. دلم تفریح میخواد.

دو سه روزی هست خودم رو گول میزنم و روزی یک ساعت از کامپیوتر استفاده میکنم. در این مدت حلقه while و for رو کامل تر کردم.

آرایه ها رو به طور کامل دیباگ کردم و برنامه های زیر رو اجرا کردم.

	var i = 0;
	var arr = [];
	while( i < 10 ) {
		arr[i] = "abbas : "+i+"\n";
		i++;
	}

	i = 0;
	while( i < 10 ) {
		print( arr[i]+"\n" );
		i++;
	}

اما دلیل اینکه خیلی از قسمت ها بازنویسی شد چی هست ؟

زبان های برنامه نویسی به دو شکل پیاده سازی میشوند. یکی داینامیک تایپ و دیگری استتیک تایپ.

در پیاده سازی استاتیک خود متغییر type داره ولی در پیاده سازی داینامیک مقادیر هستند که type دارند. این رو من وسط پست های قبل اشاره ای بهشون کردم.

برای پیاده سازی زبان مشابه js و php باید زبان به صورت dynamic type طراحی بشه. یعنی مثلا اگر یک عدد داشته باشم. باید نوع اون رو هم کنار عدد نگه داری کنم. که خود این ملزم تغییراتی در کد بود که همگی انجام شدند.

	var arr = [];
	for( var d = 0; d < 10; d++ ) {
		arr[d] = ( "abbas : "+d+"\n" );
	}

	var i = 0;
	while(  i < array_len(arr) ) {
		var k = array_key(arr, i);
		var v = array_value(arr, i);
		print( k );
		print("\n");
		print( v );

		i++;
	}

این مدل آخر باید تبدیل به for in بشه که در حال پیاده سازی اون هستم.