توسعه سیستم عامل – طراحی IDT, IRQ و ISR

اگر یادتون باشه، مدتهای پیش، یک سری مقاله نوشتم، که آخرین مقاله این بود. توی حدود چهار تا مقاله، بررسی کردیم چطور میتونیم یه سیستم عامل ساده و ۱۶ بیتی بنویسیم. اونقدری نگذشت که تصمیم گرفتم برنامه نویسی رو به C تعمیم بدم و سپس NanOS رو بعنوان نسخه اولیه نوشتم، تجربه جالبی بود چون یه درایور ساده کارت گرافیک و کیبرد داشت و چند تا پیام میتونست نشون کاربر بده. اونقدری نگذشت که یه تجمعی به اسم «بنیاد نانو» درست کردیم که NanOS رو توضیح بدیم. NanOS الان سه تا چیزی رو داره که خیلی جالبن : IDT, IRQ  و ISR .

برای این که ببینیم اینها چی به چین، اگر توی داس اسمبلی نوشته باشید، احتمالا برای چاپ رشته و کرکتر و خوندنشون این عدد و این عملگر رو دیدید :

کد   
int 21h

خب همونطور که توی مقالات قبلی هم گفتم، int اینجا به معنای «عدد صحیح» نیست، بلکه به معنای «وقفه» است. وقفه های سخت افزاری و نرم افزاری که تا الان استفاده کردیم چه کار میکردن؟ عملکرد پردازنده رو متوقف میکنن و میگن که یه کار جدید انجام بده (به ساده ترین زبان ممکن!). خیلی راحت بگم فرض کنید توی یک کلاس دارید درس میدید (عمل جاری) ، یک نفر در میزنه و شما کار درس دادن رو متوقف میکنید و اینجاست که وقفه اجرا میشه (عمل جدید). خب IDT چیه؟ IDT مخفف Interrupt Descriptor Table ــه که به معنای «جدول توضیح وقفه ها» ست. این جدول، یک ساختمان داده‌ست که توش توضیح میدیم پردازنده چه جوابی باید به وقفه هایی که بهش وارد میشه بده. در این بین یه IRQ یا Interrupt Request داریم که درخواست دهنده وقفه هاست. درخواست دهنده وقفه، توی خود پردازنده وجود داره، و ما برای استفاده ازش باید براش کد بزنیم. کار IRQ چیه؟ این که نسبت به وقفه ها واکنش نشون بده و سیگنال های مربوطه رو بفرسته. سپس، با استفاده از هندل کننده وقفه ها جواب وقفه ها رو بسنجه، یا برنامه ای رو متوقف کنه و به برنامه جدید اجازه اجرا بده.

خب، در نهایت باید Interrupt Service Routine یا ISR داشته باشیم. ISR کارش کلا اینه که بیاد و چک کنه که وقفه درست انجام شده یا نه، بعدش، بیاد و یک مقدار منطقی به ما بده، که بفهمیم وقفه درست انجام شده یا نه.

بعنوان یک جمع بندی نهایی، میشه گفت که ما اول باید بگیم چه وقفه هایی داریم و هرکدوم چه میکنه (IDT) ، بعد همه اینا رو با یک قطعه خاص تست کنیم (IRQ) و نهایتا با یک نرم افزار از درست کار کردن وقفه هامون مطمئن شیم (ISR). کاربرد این قضیه چیه؟ فرض کنیم سیستم عامل تا حدی پیشرفت کرد و تونست برنامه اجرا کنه، با استفاده از جدول و هندل کننده های وقفه ها، میتونیم برای سیستم عامل خودمون یه اسمبلر طراحی کنیم، کامپایلر ها رو روش بیاریم و برنامه هایی که دسترسی سطح پایین میخواند رو اجرا کنیم.

موفق باشید 🙂

Share

گسترش Makefile ها – استفاده از متغیر در Makefile

توی این پست بود که تصمیم گرفتم در مورد نوشتن Makefile توضیح بدم. اما قضیه نوشتن میک فایل، به اون چیزی که اونجا مطرح کردیم محدود نمیشه. میتونیم توی Makefile هامون تعدادی متغیر داشته باشیم. متغیر میتونه کامپایلرمون، ورودی ها و خروجی هاش رو مشخص کنه. حتی سوییچ هایی که برای کامپایل کردن برنامه نیاز داریم میتونیم توی Makefile قرار بدیم. بسیار خوب، خود میک یه دستور echo هم داره که میتونیم برای چاپ پیام ازش استفاده کنیم (به جای استفاده از echo بش). حالا سوال پیش میاد که چطور از این دستور ها و قابلیت ها استفاده میکنیم؟

این خط رو در نظر بگیرید :

کد   
gcc -std=c99 main.c mpc.c -ledit -lm -o main -Wincompatible-pointer-types

الان ما میتونیم هرچی که با L شروع میشه رو توی یک متغیر بریزیم، std رو هم همینطور و همچنین incompatible-pointer-types رو. اینطوری چه سودی بهمون میرسه؟ یک میک فایل تر و تمیز خواهیم داشت. پس به این شکل توی میک فایلمون درش میاریم :

کد   
CC = gcc
STD = -std=c99
LINK = -ledit -lm
FLAGS = -Wincompatible-pointer-types

الان هرچی که لازم بود رو توی متغیرهامون گذاشتیم، ولی نوع استفاده از متغیر هم مهمه. همون کد بالا رو در نظر بگیرید، حالا میایم از متغیرها استفاده میکنیم و به چنین چیزی میرسیم:

کد   
$(CC) $(STD) main.c mpc.c $(LINK) -o main $(FLAGS)

دقت کنید که پرانتز هم برای صدا زدن متغیرها لازمه. الان ما یک میک فایل تر و تمیز داریم. کل میک فایلمون به این شکل در اومده الان :

کد   
CC = gcc
STD = -std=c99
LINK = -ledit -lm
FLAGS = -Wincompatible-pointer-types
all:
	$(CC) $(STD) main.c mpc.c $(LINK) -o main $(FLAGS)
 
clean:
	rm main

خب الان میخوایم یک پیام هم چاپ کنیم و به کاربر خوش آمد بگیم، یا بگیم که صبور باشه و بعد کامپایل شدن پیام کامپایل با موفقیت رو چاپ کنه! کافیه به این فرمت چیزی که میخوایم رو بنویسیم:

کد   
@echo "Compiling proccess may take a long time, please be patient"

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

امیدوارم که این پست هم مفید واقع شده باشه، چون واقعا رفرنس برای نوشتن Makefile توی اینترنت نیست.

موفق و پیروز باشید 🙂

Share

ساخت کراس کامپایلر GCC

اگر لینوکسی باشید (یا حداقل با یکی از سیستم عاملهای خانواده *NIX کار کرده باشید) ، به احتمال خیلی زیاد GCC رو میشناسید. GCC که مخفف GNU Compiler Collection هست یک کامپایلر بزرگ، یا بهتر بگیم یه مجموعه از کامپایلرهاست که توسط پروژه گنو ارائه شده. این کامپایلر به صورت پیشفرض روی تمام توزیع های لینوکس هست (چون چیزیه که عمده ابزارهای لینوکس باهاش کامپایل شدند) و احتمالا روزهای اولی که خواستید توی لینوکس کد C بزنید با این کامپایلر بوده و البته کلی هم فحش دادید بهش 😀 . اگر کمی پیش بریم و برسیم به کسایی که تجربه ساخت LFS رو داشتن، اونها هم احتمالا با کامپایل کردن GCC مواجه شدن. شاید نفس گیر ترین بخش ماجرا در LFS همین GCC باشه ، چون هم طولانیه و هم کلی کانفیگ داره! . اما خب کراس کامپایلر قضیش یکم متفاوته.

من چند وقتیه (خیلی وقته!) درگیر ساخت یک سیستم عاملم و کلی هم برای خودم تحقیق کردم و داکیومنت خوندم و حتی داکیومنت هام رو بازنشر دادم. اما مشکل اینجاست که سیستم عامل قبلیمون کاملا با اسمبلی بود ولی این یکی رو میخوایم با C پیاده سازی کنیم. به نظرتون چی میشه؟ هیچی نمیشه! فقط نیاز داریم تا به جای این که صرفا از NASM استفاده کنیم، جناب GCC که برای خودش غولیه رو هم بازی بدیم. اما اگر سیستممون ۶۴ بیتی باشه چطور؟ اصلا اگر سیستم عامل مقصدمون برای پردازنده ای مثل ARM نوشته شده باشه چی؟ برای این که بتونیم نتیجه و خروجی درست و حسابی بگیریم، نیاز داریم تا کراس کامپایلر داشته باشیم. (برای دونستن اهمیت کراس کامپایلر این لینک رو بخونید).

خب GCC برای کامپایل شدن به Binutils نیاز داره. همچنین قبل از کامپایل Binutils برای معماری مورد نظرمون، باید این کتابخونه ها رو نصب کنیم :

کد   
sudo apt-get install libgmp3-dev libmpfr-dev libmpc-dev texinfo

خب، حالا که این کتابخونه ها رو نصب کردیم میریم که محیط ساخت و ساز (ممکنه درست نباشه ولی باحال ترین معادل ممکن برای Build Environment بود!) رو فراهم کنیم. من میخوام gcc من، برای i686-elf کار کنه. همچنین نمیخوام خیلی پر و بال بدم به ماجرا و نصب رو راحت و با کاربر خودم انجام بدم، پس این کد ها رو وارد ترمینال میکنم تا توی همون پوشه خونگی، gcc مورد نظرمون قرار بگیره!

کد   
export PREFIX="$HOME/opt/cross"
# فراموش نکنید این پوشه رو خودتون باید بسازید 🙂
export TARGET=i686-elf
export PATH="$PREFIX/bin:$PATH"

خب، حالا باید binutils رو از اینجا و gcc رو هم از اینجا دانلود کنید، و سورس ها رو درون پوشه ای به اسم src قرار بدید (پوشه src داخل پوشه خونگی شما قرار داره!). بسیار خوب! توی پوشه src پوشه ای بسازید به اسم build-binutils و سپس سورس binutils رو از حالت فشرده خارج کنید. حالا وارد پوشه build-binutils بشید (هیچی رو وارد این پوشه نکنید!) و سپس تایپ کنید :

کد   
../binutils-*/configure --prefix="$PREFIX" \
--target=$TARGET \
--with-sysroot --disable-nls --disable-werror

بعد از زدن این دستور، اسکریپت configure براتون Makefile درست میکنه. من از نسخه ۲.۲۵ استفاده کردم و واقعا بی مشکل بود، شما هم بهتره از همین نسخه استفاده کنید. حالا که Makefile برامون تولید شده کافیه به ترتیب make و سپس make install رو تایپ کنیم تا binutils مون نصب شه. حالا نوبتی هم باشه نوبت gcc دوست داشتنیه!

خب پوشه build-gcc هم بسازیم و بریم داخلش! حالا باید از فایل configure دوباره برای ساختن Makefile استفاده کنیم!

کد   
../gcc-*/configure --prefix="$PREFIX" \
--target="$TARGET" \
--disable-nls \
--enable-languages=c,c++ \
--without-headers

بعد از انجام این مرحله، باید یکی یکی دستورات زیر رو بزنیم :

کد   
make all-gcc
make all-target-libgcc
make install-gcc
make install-target-libgcc

تا gcc برامون نصب شه! الان با فراخوانی دستوری مثل i686-elf-gcc ، میتونیم به gcc ساخته شدمون دسترسی پیدا کنیم!

امیدوارم که این مطلب مفید واقع شده باشه، موفق باشید 🙂

Share

بازی با سوییفت

زبان برنامه نویسی سوییفت ، زبانی که اپل ارائه کرده و همچنین به تازگی هم اوپن سورس شده. این زبان یه زبان باحال، قشنگ و خوش ساخته، و البته قشنگی ماجرا اینه که خیلی راحت میشه روی لینوکس یا FreeBSD و … هم اجراش کرد. فرمورک Foundation هم که یکی از فرمورکهای کلیدی اپل بوده، برای این زبان به صورت اوپن سورس ارائه شده، و این یعنی اوپن سورس بیش از پیش بهشت برنامه نویسان شده (با این حساب حتی اگر دیوایس اپل ندارید میتونید این زبان رو یاد بگیرید و تمرین کنید). بسیار خوب، بریم سراغ این که ببینیم این زبان چه شکلیه و چطوریه! اول از همه این که سینتکس کاملا شبیه Objective C داره، و اگر قبلا آبجکتیو سی کد زدید، سوییفت یاد گرفتن براتون بی نهایت آسون میشه. خب، اولین مثال و به نوعی مثال روتین برای آشنا شدن با یک زبان، یا همون «سلام دنیا» (که در مقاله پیشین بهش اشاره شد) ، به این شکله :

کد   
print("Hello, World!")

خب، این روش برای چاپ رشته خیلی مرسومه (استفاده از یه تابع چاپ و یک رشته) ، اما برای این که مفاهیم بهتر منتقل شن، میتونیم رشته رو داخل یک متغیر بریزیم :

کد   
var welcomeMessage: String = "Hello, World"

خب الان که متغیر welcomeMessage رو داریم میریم که چاپش کنیم :

کد   
print(welcomeMessage)

خب میخوایم بریم سراغ چیزایی که توی یه زبان خیلی مرسومن، مثلا حلقه while و این چیزا! خب اگر C و Objective C و این زبانا رو بلد باشید خیلی کارتون راحته چون دقیقا همونه :

کد   
while(true){
 print(welcomeMessage)
 }

خب این هم چاپ بی نهایت همون پیامی که توی متغیر welcomeMessage ریختیم 😀 . برای اطلاعات بیشتر از ساختارهای کنترلی میتونید این لینک رو بخونید.

بسیار خوب، ساختار فانکشن ها هم همونطور شبیه C و Objective C و البته شبیه Go هم هست! این یه تابع بازگشتیه (که البته توی REPL زبان خیلی اذیتم کرد ولی موقع کامپایل خیلی مظلومانه (:D) اجرا شد!

کد   
func factorial(x: UInt) -> UInt {
 if(x == 0) {
   return 1
   } else {
   return x * factorial(x - 1)
   }
 }

خب این تابع یک عدد صحیح بدون علامت رو میگیره و فاکتوریلش رو حساب میکنه و بعد بر میگردونه، همونطور که دیدید اگر با زبان های شبیه C آشنا باشید خواهید دید که تقریبا هیچ فرق خاصی از نظر سینتکس نداره. فقط باید یک مقدار روی دیتاتایپ ها و … دقیق بشید تا بفهمید قضیه چیه وگرنه در کل اصلا زبان سختی نیست. اگر میخواید یادش بگیرید کتابی که خود اپل ارائه کرده رو میتونید دریافت کنید (روی iBooks هم هست!).

امیدوارم که این مطلب مفید واقع شده باشه.

موفق باشید 🙂

Share

قطعه کد «سلام دنیا» در زبان های مورد علاقه من – سری دوم

توی این مطلب یه تعداد از زبان های مورد علاقم رو معرفی کردم و درونشون قطعه کد سلام دنیا یا همون Hello World رو نوشتم. الان قصد دارم یه تعداد زبان دیگه رو معرفی کنم و این کد رو درون اون زبانها اجرا کنم. این زبانها هم جنبه فان دارن و در عین حال خیلی هم کاربردین.

۱. Arendelle :

این زبان، که سایتش از این آدرس  در دسترسه، ساخته دست دوست خوبم پویا کاری هست (اطلاعات شخصی ایشون توی وبسایت لینک شده). یک زبان برنامه نویسی فان برای کودکان که کلاینت آی او اس و آندروید هم داره.

کد   
'Hello, World'

۲. Apple Swift

زبان سوییفت اپل (نه اون سوییفتی که برای برنامه نویسی موازی و همروند استفاده میشه) به تازگی اوپن سورس شده و حقیقتا نتونستم تحمل کنم و نصبش کردم اون هم روی اوبونتو! و خب کار باهاش خیلی فانه (و به زودی هم یه سری مطلب در موردش میذارم) و البته اگر فرمورک های درست و حسابی تحت لینوکس هم براش ارائه شه، میشه گفت میتونه به یکی از بی رقیب ترین ها تبدیل شه!

کد   
print("Hello, World")

۳. Ada

خب، زبان Ada هم از زبانهایی بود که همیشه میخواستم یاد بگیرم، مدتها پیش در موردش خوندم و جالب ترین نکته این بود که اسم گذاریش از روی اولین برنامه نویس جهان بوده، پس مصمم شدم که حتما یکم باهاش بازی کنم 🙂

کد   
with Ada.Text_IO; use Ada.Text_IO:
procedure Hello is
 begin
  Put_Line("Hello, World");
 end Hello;

۴. Verilog HDL

این زبان هم برای شبیه سازی سخت افزار ازش استفاده میشه. شدیدا کاربردی و باحاله و میتونید کلی پروژه کول پیدا کنید که روی این زبان هستن، مثلا پیاده سازی اوپن سورس از پردازنده های مختلف مثل MIPS, x86, sparc و … .

کد   
module main;
 initial
  begin
   $display("Hello, World");
   $finish;
  end
endmodule

 

خب، این یکی مطلب کوتاه تر از نسخه قبلیش بود! اما یه نکته خیلی ریزی داشت، و اونم اینه که توی این چهارتا زبان میشه چهارتا طیف کاملا متفاوت رو دید. شما هم اگر پیشنهادی دارید دریغ نکنید و بذارید بدونیم 🙂

موفق باشید.

Share

نوشتن Makefile برای تسریع فرایند ساخت

احتمال خیلی زیاد، همه ما یک بار توی عمرمون این صحنه رو دیدیم :

کد   
make
make install
make clean

خب ما وقتی یه سورس کدی رو دریافت میکنیم معمولا همراهشم یه Makefile داریم، سازنده اون برنامه، یا همون دوست عزیزی که سورس کد رو برامون نوشته، میتونست بگه کسی که دانلود کرد دیگه خودش بشینه یکی یکی کد ها رو کامپایل کنه و آخرش لینک کنه و این حرفا. ولی خب چون همه توانایی، وقت یا دانش لازم رو ندارن، معمولا یه Makefile نوشته میشه که این کارها درونش صورت بگیره! توی این پست، قراره ما یاد بگیریم که چطور Makefile بنویسیم. اول ببینیم make چیه؟ همونطور که میدونید make به معنای ساختنه. و نرم افزار make هم ساخته شده که بسازه. طبق تعریفی که توی ویکیپدیا و صفحه رسمیش هست، میگن که «نرم افزاریه که فایل های قابل اجرا از یک سری سورس تولید میکنه». البته کارهای دیگری هم میشه باهاش کرد! مثلا همون سورس ها و … رو باهاش منتقل کنیم به جایی که میخوایم و از این قبیل کارا. خب برای نوشتن یک Makefile نیاز به یک ادیتور متنی، نرم افزار make (دقت کنید این نرم افزار جزئی از استاندارد POSIX به حساب میاد و معمولا روی همه یونیکس-لایک ها نصبه)، یک محیط یونیکس لایک (اگر ویندوزی هستید Cygwin یا یک یونیکس لایک مجازی) نیاز داریم. همین؟ درسته همین. حالا با make قراره چی کار کنیم؟ اول بیایم یه Makefile ساده بنویسیم.

سناریوی کلی ما استفاده از نرم افزار echo هست که اونم در یونیکس لایک ها موجوده. ما میخوایم با استفاده از make و echo پیام معروف Hello, World رو نشون بدیم :

کد   
all:
	echo "Hello, World"

خب اینجا دو تا توضیح داریم :

یکی این که all چیه؟ این all یه سوییچ عمومی هست که توی همه Makefile ها موجوده. وقتی که شما صرفا تایپ کنید make هرچی که به این سوییچ گفته شده اجرا میشه، حالا میتونه روی فایل خاصی تغییر اعمال کنه یا نه، مثل ما صرفا یکی از برنامه ها رو فراخوانی کنه. و این که اون فاصله زیاد برای چیه؟ هر وقت نوشتید all (یا هر سوییچ دیگه ای) ، کافیه بیاید خط بعدی و Tab رو بزنید (دقت کنید مطلقا از Space استفاده نکنید چون با هم فرق دارن!) و دستور مورد نظرتون رو وارد کنید!. الان میتونید این تکه کد رو در یک فایل به اسم Makefile ذخیره کنید و بعدش تایپ کنید make و نتیجه رو ببینید! خواهید دید اول دستوری که بهش دادیم و سپس نتیجش رو نشون میده.

بسیار خوب! بیایم یک سناریوی دیگه پیاده کنیم. فرض کنیم شما اومدید :

یک برنامه به زبان C نوشتید، و الان میخواید اون رو کامپایل کنید، در یک دایرکتوری خاص به اسم path (که زیرشاخه دایرکتوری Root هست) قرار بدید، و سپس با یک دستور فایل باینری رو از دایرکتوری سورس حذف کنید. 

قطعا به صورت دستی هم میشه انجام داد، ولی خب منطقی ترش اینه که بیایم و از Makefile استفاده کنیم! فرض میکنیم اسم سورس شما src.c هست و در دایرکتوری ای قرار داره! خب میک فایل ما به این شکل میشه :

کد   
all: src.c
	gcc -o src src.c
 
install: src
	cp -v src /path
 
clean: src
	rm -v src

خب برای این که اینجا، ما سوییچ های all و install و clean رو روی فایلهای مورد نظرمون اعمال کنیم، اسم فایل های مورد نظر رو جلوی سوییچ ها قرار دادیم. توی all میاد از src.c یک فایل باینری به اسم src میسازه! توی install هم اون باینری رو کپی میکنه توی path (البته چون path زیرشاخه دایرکتوری ریشه ماست، باید make رو با sudo اجرا کنید و فکر کنم ترکیب sudo و make و install شدیدا براتون آشناس 😀 )، توی clean هم اومدیم اون فایل باینری رو پاک کردیم! به همین سادگی!

توی این پست سعی کردم تا حد امکان، ساده توضیح بدم چرا که واقعا ساده تر از این نمیشد make رو توضیح داد. البته میشه Makefile های بسیار پیچیده تری هم نوشت که همه می بینیم هستن! مثلا Makefile های FreeBSD هر کدوم غولی به حساب میان. ولی برای پروژه های ساده، خوندن و دونستن همین پست هم کافیه.

امیدوارم که این پست به دردتون خورده باشه، موفق باشید 🙂

Share

نوشتن یک سیستم عامل ساده – قسمت آخر

بهرحال، هر شروعی یک پایانی داره و اینجاس که ما به پایان خودمون نزدیک میشیم! پایان قشنگ و دوست داشتنی، وقتی می بینیم دست رنجمون در طول چند هفته (بسته به مهارت برنامه نویسی و حوصله و زمانی که صرف این کار کردید) ، تبدیل شده به یه چیز «تقریبا» قابل استفاده، دوست داشتنی تر هم میشه! بسیار خب کد اسمبلی که نوشتیم و کامل شده به این شکله :

کد   
org 0x7c00
bits 16
 
mov ax, 0
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0x7c00
 
mov si, welcome 
call print_string 
 
mov si, about
call print_string
 
mov si, newline
call print_string
 
mainloop:
 mov si, prompt
 call print_string
 
 mov di, buffer
 call get_string
 
 mov si, buffer
 cmp byte [si], 0
 je mainloop
 
 mov si, buffer
 mov di, cmd_reboot
 call strcmp
 jc .reboot
 
 mov si, buffer
 mov di, cmd_about
 call strcmp
 jc .about
 
 mov si, buffer
 mov di, cmd_help
 call strcmp
 jc .help
 
 mov si, badcommand
 call print_string
 jmp mainloop
 
 .reboot:
  int 0x19
  jmp mainloop
 
 .about:
 mov si, msg_about
 call print_string
 jmp mainloop
 
 .help:
 mov si, msg_help
 call print_string
 jmp mainloop
 
 
welcome db  'Welcome to my OS', 0x0d, 0x0a, 0
about db  'Written in 16-bit real mode', 0x0d, 0x0a, 0
buffer times 64 db 0
prompt db '>> ', 0
newline db ' ', 0x0d, 0x0a, 0
badcommand db 'Bad command entered', 0x0d, 0x0a, 0
cmd_reboot db 'reboot',0
cmd_about db 'about', 0
msg_about db 'This is a 16 bit operating system, works in real mode and written in assembly language', 0x0d, 0x0a, 0
cmd_help db 'help', 0
msg_help db 'Commands are : about, help and reboot', 0x0d, 0x0a, 0
 
 
 
print_string:
 lodsb
 or al, al
 jz .done 
 
 mov ah, 0x0e
 int 0x10
 
  jmp print_string
 
 
 .done:
   ret
 
get_string:
 xor cl, cl
 .loop:
   mov ah, 0
   int 0x16
 
   cmp al, 0x08
   je .backspace
 
   cmp al, 0x0D
   je .done
 
   cmp cl, 0x3F
   je .loop
 
   mov ah, 0x0e
   int 0x10
 
   stosb
   inc cl
   jmp .loop
 
   .backspace:
    cmp cl, 0
    je .loop
 
    dec di
    mov byte [di], 0
    dec cl
 
    mov ah, 0x0e
    mov al, 0x08
    int 0x10
 
    mov al, ' '
    int 0x10
 
    mov al, 0x08
    int 0x10
 
    jmp .loop
 
    .done:
      mov al,0
      stosb
 
      mov ah, 0x0e
      mov al, 0x0d
      int 0x10
      mov al, 0x0a
      int 0x10
 
      ret
 
strcmp:
 .loop:
  mov al, [si]
  mov bl, [di]
  cmp al, bl
  jne .notequal
 
  cmp al, 0
  je .done
 
  inc di
  inc si
 
  jmp .loop
 
  .notequal:
   clc
   ret
  .done:
    stc
    ret
 
times 510-($-$$) db 0
dw 0xaa55

 

همونطور که می بینید چن قسمت جدید شروع شده ، مثلا تابع strcmp رو ساختیم، چن تا دستور و پیام تعریف کردیم و زیر تابع های reboot و about و help رو هم تعریف کردیم. خب اول یه توضیح کوچیک : دستورات باید حتما معرفی بشن. چرا؟ چون تابع strcmp ورودی کاربر رو با یه سری اطلاعات از پیش تعیین شده میاد مقایسه میکنه و در صورت برابری با مقدار وارد شده، اون دستوری که در برنامه تعریف شده رو اجرا میکنه. پس بخشی که چندین db پشت هم تعریف شده رو جدی بگیرید! بسیار خوب، یکی از توابع خوب و زیبامون تابع strcmp هست. این تابع چیه؟ ما یه دستوری در اسمبلی داریم به اسم cmp که کارش مقایسه است. حالا برای این که ببینیم دو تا رشته با هم برابرن اومدیم strcmp نوشتیم. در واقع مخفف string compare هست. خب این تابع در کد ما به این شکله :

کد   
strcmp:
 .loop:
  mov al, [si]
  mov bl, [di]
  cmp al, bl
  jne .notequal
 
  cmp al, 0
  je .done
 
  inc di
  inc si
 
  jmp .loop
 
  .notequal:
   clc
   ret
  .done:
    stc
    ret

این تابع ، میاد اول یک بایت از si رو میریزه توی ۸ بیت پایینی AX . بعدش یک بایت از di رو میریزه توی هشت بیت پایینی BX . بعد با cmp مقایسه‌ش میکنه، در صورتی که برابر نبودن، میره سراغ notequal که توضیح داده میشه، و اگر برابر باشن، هشت بیت پایین AX چک میشه و اگر خالی بود میره done. در غیر این صورت یک کرکتر میره جلو (با دستور inc یک خونه به جلو حرکت میکنه). بعد میرسیم به بخش دوست داشتنی notequal ، توی این بخش اول Carry Flag که یک بیت از رجیستر Flag در پردازنده ماست، خالی میشه و تابع تموم میشه. در قسمت done هم این بیت پر میشه و تابع تموم میشه! دیدید؟ بسیار ساده تر از چیزی بود که فکرش رو میکردید! حالا بریم کارکرد دستورات رو بررسی کنیم :

کد   
mov si, buffer
 mov di, cmd_about
 call strcmp
 jc .about

خب این بخش برای همه دستورات یکیه، چی کار میکنه؟ خط اول buffer (رشته ای که کاربر وارد کرده) و خط دوم دستور (دستوری که توی اون بخش توسط db تعریف کردیم) وارد رجیستر های SI و BI میشن. بعد تابع strcmp میاد این دو رشته رو با هم مقایسه میکنه. اگر شرط درست باشه، به زیرتابع مورد نظر میریم. در غیر این صورت، زیرتابع badcommand که در قسمت سه و نیم معرفی شد، فراخوانی میشه. حالا بیایم ساختار about رو بررسی کنیم (توجه کنید about ساختارش با help یکیه پس یکیشون کافیه که بررسی شه) :

کد   
.about:
 mov si, msg_about
 call print_string
 jmp mainloop

خب تا حدود زیادی مثل badcommand عمل میکنه (تقریبا همونه با این تفاوت که یه شرط لازم داره برای اجرا شدن) ، اول رشته مورد نظرمون میره توی SI ، بعد print_string صدا زده میشه، و بعد میریم به حلقه اصلی و منتظر میمونیم تا کاربر دستور بعدی رو بده.

این زیرتابع ها، مشابهن. فقط تابع reboot یکم ممکنه اذیتتون کنه، ولی خب اون رو هم اینجا توضیح میدیم :

کد   
.reboot:
  int 0x19
  jmp mainloop

خب طبیعیه که jmp کارش پرش به حلقه اصلیه و برای این میذاریمش که اگر reboot رو کاربر نزنه ، چی بشه؟ هیچ اتفاقی نیفته و سیستم عامل کوچولومون همچنان منتظر باشه کاربر بهش دستور بده. اما وقفه ۱۹ هگزادسیمال یا 0x19 (که بعضی جاها ممکنه 19h هم نوشته شه) ، چیه؟ این وقفه یکی از وقفه های بایوسه که کارش ریبوت کردن (راه اندازی مجدد) سیستم عاملمونه.

تبریکات فراوان! شما الان یک سیستم عامل زیبا و کوچولو نوشتید، که سه تا دستور داره و اگر دستوری غیر از اینا بهش بدید، بهتون ارور میده. در واقع شما کاری رو پیش بردید که توسعه دهنده ها سالیان پیش انجام میدادن تا کامپیوترها بیشتر و بیشتر کاربرپسند بشن! و از این جهت شدیدا باید خوشحال باشید، چرا؟ چون کارهایی رو دوباره کردید که احتمال خیلی زیاد توی شرکتهای بزرگ کامپیوتری انجام میشده! و همچنین تشکرات فراوان بابت این که مطالب من رو خوندید و براش وقت گذاشتید. بزودی سری جدیدی از این مقالات شروع میشه که سیستم عامل کوچولومون رو میبریم توی مود حفاظت شده ( Protected Mode ) که یک مود ۳۲ بیتی هست و احتمال خیلی زیاد از بوت لودر GRUB برای بوت کردنش استفاده خواهیم کرد!

موفق باشید 🙂

Share

نوشتن یک سیستم عامل ساده – قسمت سه و نیم

این قسمت، حقیقتا ارزش این که به قسمت چهارم تبدیل بشه رو نداره. برای همین تصمیم گرفتم اسمش رو بذارم سه و نیم! توی قسمت قبلی prompt نوشتیم که دستورات رو از کاربر میخوند اما هیچ جوابی نمیداد. توی این قسمت قصدم اینه که صرفا یک ارور رو روی صفحه نمایش بدم. به این شکل :

error

بسیار خوب! در قسمتی که چندین db داشتیم برای تعریف دو پیام اول و بعد شکل prompt و بعدش بافر، این رو وارد کنید :

کد   
badcommand db 'Bad command entered', 0x0d, 0x0a, 0

و بعد قبل از اتمام mainloop یعنی قبل از آخرین پرشمون، این کد رو اضافه کنید :

کد   
mov si, badcommand
call print_string

خب بعد از اسمبل کردن، خواهید دید که هر کامندی (مثل فاصله، کرکتر های الکی و …) که وارد کنید این ارور به شما نمایش داده میشه! و دلیلش اینه که هنوز دستوری به سیستم عاملمون اضافه نشده. در قسمت های بعدی دستورات مورد نیازمون رو هم به سیستم عامل کوچولومون اضافه میکنیم!

ضمیمه : ساخت فایل ISO قابل بوت از سیستم عامل

از اونجایی که میدونستم این سوال ممکنه پیش بیاد که چطور باید این فایل رو به ISO تبدیل کنیم و بوتش کنیم، در این بخش توضیح میدم. اولا که img و حتی bin قابل بوت شدن هستن (اگر مجازی سازتون میذاره که floppy controller اضافه کنید) ولی خب اگر دلتون میخواد ISO درست کنید ، اول فایل bin که اسمبلر داده بهتون رو به img تبدیل کنید :

کد   
dd if=my16bitos.bin of=my16bitos.img

بعد یه فولدر به اسم cdiso بسازید و فایل img رو ببرید داخلش و بعد این دستور رو بزنید (برنامه genisoimage رو نصب کنید حتما!):

کد   
mkisofs -o my16bitos.iso -b my16bitos.img -no-emul-boot cdiso/

بعدش میتونید فایل ISO رو بدید به یه مجازی ساز مثل VirtualBox یا QEMU یا VMWare .

موفق باشید!

Share

نوشتن یک سیستم عامل ساده – قسمت سوم

در دو مقاله قبلی سعی کردیم یک سیستم عامل ساده بسازیم که توی مد حقیقی ۱۶ بیت کار میکنه و دو تا رشته هم نشونمون میده. بسیار خوب، اگر با سیستم عامل هایی مثل DOS کار کرده باشید قطعا با محیط متنی آشنایید. اگر هم مثل من لینوکسی باشید احتمالا بخش بزرگی از کارهاتون رو توی محیط ترمینال انجام میدید. حتی در ویندوز هم بعضی وقتا نیاز شدیدی به CMD یا همون Command Prompt پیدا میکنیم. پس نیاز داریم که یک محیطی بسازیم که دستورات رو از کاربر بگیره و بهشون پاسخ بده. ما در این قسمت، میایم و دستورات رو از کاربر میگیریم. در قسمت های بعدی دستورات مورد نظرمون رو هم اضافه میکنیم.

بعد از نوشتن prompt و قابلیت خوندن ورودی از کاربر، در واقع به این شکل میشه کدمون:

کد   
org 0x7c00
bits 16
 
mov ax, 0
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0x7c00
 
mov si, welcome 
call print_string 
 
mov si, about
call print_string
 
mov si, newline
call print_string
 
mainloop:
 mov si, prompt
 call print_string
 
 mov di, buffer
 call get_string
 
 mov si, buffer
 cmp byte [si], 0
 je mainloop
 
 jmp mainloop
 
welcome db  'Welcome to my OS', 0x0d, 0x0a, 0
about db  'Written in 16-bit real mode', 0x0d, 0x0a, 0
buffer times 64 db 0
prompt db '>> ', 0
newline db ' ', 0x0d, 0x0a, 0
 
print_string:
 lodsb
 or al, al
 jz .done 
 
 mov ah, 0x0e
 int 0x10
 
  jmp print_string
 
 
 .done:
   ret
 
get_string:
 xor cl, cl
 .loop:
   mov ah, 0
   int 0x16
 
   cmp al, 0x08
   je .backspace
 
   cmp al, 0x0D
   je .done
 
   cmp cl, 0x3F
   je .loop
 
   mov ah, 0x0e
   int 0x10
 
   stosb
   inc cl
   jmp .loop
 
   .backspace:
    cmp cl, 0
    je .loop
 
    dec di
    mov byte [di], 0
    dec cl
 
    mov ah, 0x0e
    mov al, 0x08
    int 0x10
 
    mov al, ' '
    int 0x10
 
    mov al, 0x08
    int 0x10
 
    jmp .loop
 
    .done:
      mov al,0
      stosb
 
      mov ah, 0x0e
      mov al, 0x0d
      int 0x10
      mov al, 0x0a
      int 0x10
 
      ret
 
times 510-($-$$) db 0
dw 0xaa55

تفاوتش با قبلی چیه؟ درسته یک تابع بلند و بالای get_string اضافه شده، متغیر buffer هم تعریف شده. یک حلقه اصلی هم به اسم mainloop تعریف کردیم. بیایم ببینیم این همه بخش، چه کارایی میکنن؟

بین بخش های اضافه شده، mainloop بخش ساده تریه. پس اول میریم اون رو بررسی کنیم :

کد   
mainloop:
 mov si, prompt
 call print_string
 
 mov di, buffer
 call get_string
 
 mov si, buffer
 cmp byte [si], 0
 je mainloop
 
 jmp mainloop

در بخش اول، یک اسم برای حلقه اصلی گذاشتیم. سپس متغیر prompt رو توی Source Index فرستادیم و تابع print_string رو صدا زدیم. مثل نوشتن اون چیزایی که قبلا نمایش دادیم (پیام خوشامد گویی و این حرفا!). بعدش هم buffer که الان ۶۴ تا صفره رو داخل Destination Index قرار دادیم و تابع get_string رو صدا زدیم. این تابع، در واقع داره یه چیزی رو از ورودی میخونه (چطوری؟ الان بررسیش میکنیم!) . بعد بافر رو به si میفرستیم و بایت به بایت رو با صفر مقایسه میکنیم. اگر همه بایت ها صفر بود(یعنی دستور خالی بود) ، بر میگردیم سر خونه اول. در آخر هم یک پرش میکنیم به حلقه اصلی. چه دستوری وارد شده باشه، چه نشده باشه! حالا بیایم ببینیم تابع get_string مون چطوری کار میکنه؟

کد   
get_string:
 xor cl, cl
 .loop:
   mov ah, 0
   int 0x16
 
   cmp al, 0x08
   je .backspace
 
   cmp al, 0x0D
   je .done
 
   cmp cl, 0x3F
   je .loop
 
   mov ah, 0x0e
   int 0x10
 
   stosb
   inc cl
   jmp .loop
 
   .backspace:
    cmp cl, 0
    je .loop
 
    dec di
    mov byte [di], 0
    dec cl
 
    mov ah, 0x0e
    mov al, 0x08
    int 0x10
 
    mov al, ' '
    int 0x10
 
    mov al, 0x08
    int 0x10
 
    jmp .loop
 
    .done:
      mov al,0
      stosb
 
      mov ah, 0x0e
      mov al, 0x0d
      int 0x10
      mov al, 0x0a
      int 0x10
 
      ret

خب اولین کاری که کردیم انجام یه xor روی cl بوده. در واقع هشت بیت پایینی CX رو با خودش XOR کردیم. این یک کلک مرسوم هست برای تولید عدد صفر، مواقعی که نمیخوایم رجیسترهامون صفر شن. بعدش یک حلقه تعریف کردیم. توی این حلقه، اومدیم چه کردیم؟ عدد صفر رو توی AH قرار دادیم سپس از وقفه ۱۶ هگزادسیمال استفاده کردیم. این وقفه منتظر میمونه تا یک کلید فشرده شه. بعدش عدد هگزادسیمال 08 رو وارد AL کردیم. این چی کار میکنه؟ این چک میکنه کلید backspace فشرده شده یا نه. سپس در صورت برابری، میره به زیرتابع backspace که تعریف کردیم. بعدش هم با قرار دادن 0D در AL چک میشه که آیا Enter فشرده شده یا نه؟ و اگر درست باشه، میره به زیرتابع done که باز هم تعریف شده و مشاهده میکنید. بعد اومدیم محتوای CL رو با 3F مقایسه کردیم ، این دستور چک میکنه آیا ۶۳ کرکتر وارد شده؟ و سپس فقط به Enter و Back Space اجازه میده که کار انجام بدن. در واقع نمیتونید کلید دیگری رو فشار بدید. بعدش هم 0E رو داخل AH گذاشتیم و از همون وقفه معروف بایوس استفاده کردیم. این پروسه به شما اجازه میده هر وقت کلیدی رو فشردید، بدون درنگ کرکتر مورد نظرتون رو روی صفحه مشاهده کنید. حالا نوبتی هم باشه، نوبت زیرتابع هایی هست که داریم. اولیش، backspace هست که به این شکله :

کد   
.backspace:
    cmp cl, 0
    je .loop
 
    dec di
    mov byte [di], 0
    dec cl
 
    mov ah, 0x0e
    mov al, 0x08
    int 0x10
 
    mov al, ' '
    int 0x10
 
    mov al, 0x08
    int 0x10
 
    jmp .loop

این زیرتابع، اول میاد CL رو با صفر مقایسه میکنه. اگر برابر بود میره دوباره توی حلقه اصلی زیرتابع که تعریف کردیم. اگر نبود DI رو یک واحد کم میکنه، بعد کرکتر رو پاک میکنه و همچنین یکی از CL کم میکنه، چرا؟ چون طول رشته ما توی CL ذخیره شده. بعد میایم عدد 0x0e رو وارد AH میکنیم (این تابع مربوط به چاپ کرکتر ها و رشته ها توی وقفه 0x10 بایوس هست) ، بعد 08 رو وارد AL میکنیم که پروسه فشرده شدن backspace رو کنترل میکنه بعد هم وقفه 0x10 رو اجرا میکنیم. بعدش میایم یک کرکتر خالی میریزیم توی AL و بعد باز وقفه اجرا میشه و بعدش هم کرکتر خالی رو پاک میکنیم. در آخر هم به Loop برمیگردیم. حالا بریم ببینیم done اینجا چیکار میکنه؟

کد   
.done:
      mov al,0
      stosb
 
      mov ah, 0x0e
      mov al, 0x0d
      int 0x10
      mov al, 0x0a
      int 0x10
 
      ret

حقیقتا این تابع برای اینه که وقتی یک رشته وارد کردیم و enter رو زدیم عمل کنه حالا ببینیم چطور کار میکنه؟ اول عدد صفر رو میذاریم داخل AL که نقش NULL terminator رو داره. بعدش دستور stosb رو میزنیم که رشته رو ذخیره میکنه. بعدش هم 0E رو وارد AH میکنیم (همون تابع معروف 😀 ) و بعدش 0D رو در AL میذاریم (اتمام رشته) و کارمون رو با وقفه تموم میکنیم. بعدش با قرار دادن 0x0a و اجرای وقفه معروف، میریم خط بعدی. ret هم که تابعمون رو تموم میکنه!

حالا میتونید با خیال راحت با سیستم عامل ۱۶ بیتی خودتون بازی کنید! برای این که ببینید چه اتفاقاتی پشت پرده داره میفته، میتونید ویدئوی من رو ببینید که سیستم عامل رو اسمبل کردم و در ویرچوال باکس اجراش کردم 🙂

توی ویدئو می بینید که با ورود نوشته ها، دستوری اجرا نمیشه. ولی در آینده چند تا دستور ساده برای سیستم عامل سادمون خواهیم نوشت.

موفق باشید 🙂

Share

نوشتن یک سیستم عامل ساده – قسمت دوم

در مقاله قبلی، در مورد نمایش یک حرف روی مانیتور صحبت شد. اما یک حرف کافی نیست. حتی نمیشه به صورت حرف به حرف کلمات و جملات رو نشون داد چون واقعا کار سختیه. ما میخوایم یک پیغام (مثل Hello World) رو موقع بوت شدن سیستم عاملمون شاهد باشیم. پس باید چه کنیم؟ یک راه حل اینه که از یک ویژگی ای در زبان مورد نظر (اینجا اسمبلی) استفاده کنیم که بتونه یک رشته رو چاپ کنه. طبیعتا اسمبلی به طور پیشفرض دستوری مثل cout نداره و ما مجبوریم که خودمون اون رو به cout بیاریم. در این قسمت از مقالات «نوشتن یک سیستم عامل ساده» به این میپردازیم که چطور سیستم عامل ۱۶ بیتی ما، یک یا چند جمله رو نشونمون بده! در این قسمت علاوه بر رجیستر AX از سایر رجیستر ها هم استفاده خواهیم کرد. ممکنه بپرسید چرا؟ جواب سوالتون رو توی متن میگیرید!

خب فایل my16bitos.asm رو باز کنید. کل محتواش رو پاک کنید و این رو جایگزینش کنید :

کد   
org 0x7c00
bits 16
 
mov ax, 0
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0x7c00
 
mov si, welcome 
call print_string 
 
mov si, about
call print_string
 
welcome db  'Welcome to my OS', 0x0d, 0x0a, 0
about db  'Written in 16-bit real mode', 0x0d, 0x0a, 0
 
print_string:
 lodsb
 or al, al
 jz .done 
 
 mov ah, 0x0e
 int 0x10
 
  jmp print_string
 
 
 .done:
   ret
 
times 510-($-$$) db 0
dw 0xaa55

دیدید ؟ کد خیلی طولانی تر شده نسبت به قبل. طبیعیه چون که ما یه تابع تعریف کردیم و از یه سری چیزای جدید هم استفاده کردیم. خب آماده اید؟ میریم که بخش به بخش سیستم عامل کوچولوی خودمون رو بررسی کنیم!

کد   
org 0x7c00
bits 16

این قسمت، برای اینه که اولا ، اسمبلر آدرس ها رو بفهمه، ثانیا بفهمه که کد چند بیتیه. در آینده کد ما ۳۲ بیت خواهد شد و این بخش هم تغییر خواهد کرد. ولی فعلا تا آموزشهای بعدی همین برنامه رو داریم.

کد   
mov ax, 0
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0x7c00

این قسمت از کدمون هم مقدار صفر رو توی رجیستر AX میذاره و سپس اون رو به Data Segment, Extra Segment و Stack Segment منتقل میکنه (توجه کنید مستقیما نمیتونیم مقداری رو درون این رجیستر ها بذاریم. پس اول مقدار رو میذاریم توی AX سپس با MOV یکی یکی منتقل میکنیم). در آخر هم مقدار 7C00 هگزا دسیمال رو توی Stack Pointer قرار میدیم (استک از این آدرس شروع میکنه و میاد پایین).  این بخش داره مقدمات اجرای سیستم عامل ما رو فراهم میکنه.

بعد از اونا میرسیم به این بخش :

کد   
mov si, welcome 
call print_string 
 
mov si, about
call print_string
 
welcome db  'Welcome to my OS', 0x0d, 0x0a, 0
about db  'Written in 16-bit real mode', 0x0d, 0x0a, 0

این قسمت تقریبا ساده ترین قسمت برنامست. اومدیم welcome و about که دو رشته هستند رو ریختیم توی Source Index و سپس تابع print_string که کارش چاپ رشته هست هم صدا زدیم. با دستور db هم گفتیم که چه رشته هایی رو مد نظر داریم که چاپ شن. اون اعداد هگزاسیمال بعد از متغیر ها هم معادل New Line هستند (مثلا مقدار n در دستورات بک اسلش در C ).

بعد از این جنگولک بازیا ( 😀 ) میرسیم به کار اصلیمون یعنی نوشتن تابع print_string . این تابع نسبتا سادس ولی خب نیاز به توضیح داره چون دستوراتی رو استفاده کردیم که توی مطلب قبلی نبودن :

کد   
print_string:
 lodsb
 or al, al
 jz .done 
 
 mov ah, 0x0e
 int 0x10
 
  jmp print_string
 
 
 .done:
   ret

خب اول اومدیم اسم تابع رو گذاشتیم print_string (شما میتونید هرچیزی دلتون میخواد بذارید، مثلا دوستی ممکنه بذاره cout که براش ملموس تره و …). بیایم ببینیم خط به خط تابع چه میکنه؟

اون lodsb یک بایت رو از SI میخونه ، بعد رجیستر AL با خودش از نظر منطقی OR میشه. در نهایت اگر نتیجه صفر شد میره به done که done هم همونطور که می بینید داره return میکنه و از تابع خارج میشه. اگر جواب صفر نشه، مقدار 0e هگزا دسیمال وارد AH میشه و سپس وقفه 10 هگزادسیمال که یکی از وقفه های بایوس هست اجرا میشه. در واقع 0e یکی از تابع های وقفه مورد نظر ماست. بعد از اون پرش رخ میده به print_string. در واقع ما یک حلقه نوشتیم که به تعداد کرکتر های رشتمون، تکرار میشه و رشته رو تکرار میکنه.

در نهایت هم باید به اسمبلر بفهمونیم که برناممون یک Boot Sector عه پس طبیعتا از این قطعه کد استفاده میکنیم که در مطلب قبلی توضیحش دادم :

کد   
times 510-($-$$) db 0
dw 0xaa55

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

کد   
nasm -f bin -o my16bitos.bin my16bitos.asm
dd if=my16bitos.bin of=my16bitos.img

بعد یک ماشین مجازی توی ویرچوال باکس ایجاد کنید، یک Floppy Controller بسازید و اولویت بوت رو بهش بدید. سپس img رو بدید به فلاپی کنترلر و سپس ماشین رو روشن کنید. باید چنین صحنه ای رو مشاهده کنید :

 

os

تبریک! شما تقریبا نصف بیشتر راه رو رفتید! در ادامه هم میرسیم به باقی ماجرا و نوشتن prompt و این چیزا!

موفق باشید 🙂

Share