پروژه گاه‌شمار

خب، من در گروه های تلگرامی این پیام رو میذاشتم :

دوستی مدتی پیش (که خیلی هم ازش نگذشته ) یک چالش رو بعنوان تمرین برنامه نویسی پیشنهاد داد، و اون هم نوشتن یک API بود برای دریافت ساعت و تاریخ.
من هم وارد این چالش شدم و یک API با روبی و سیناترا نوشتم، روی گیتهاب هم قرارش دادم ولی الان دپلویش کردم که اگر شما هم خواستید بتونید ازش استفاده کنید :
https://gahshomar-api.herokuapp.com/

خب، این هم پروژه ای بود که محسن بعنوان تمرین خواست که ما یه API بنویسیم، من هم این رو با Sinatra نوشتم و الان دپلوی شده و در دسترسه! امیدوارم ازش لذت ببرید 🙂

Share

ساخت یک کامپیوتر ساده در Logisim – قسمت اول

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

۱. دونستن کمی مدار منطقی (که قبلا در وبلاگ راجع بهش حسابی صحبت کردم)

۲. بلد بودن کار با Logisim (که میشه گفت مثل نقاشی کشیدن میمونه و همین پست ها رو دنبال کنید یاد میگیرید.).

راه اندازی محیط کار

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

چالش های پیش رو

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

کامپیوتر ما باید چه عملیاتی انجام بده؟

یک کامپیوتر ساده که بتونه به راحتی قابل درک هم باشه، هم باید Word Size کوچیکی داشته باشه (توی آموزش ها با ۸ بیت میریم جلو) و هم Instruction Setش باید کوچیک باشه. یک سری دستور پایه هست که هر کامپیوتری میتونه انجامش بده، ما کامپیوترمون رو اینطور طراحی مکنیم که AND, OR, NOT رو بتونه انجام بده، علاوه بر اون بتونه جمع و تفریق هم بکنه. پس باید :

  1. مداری طراحی کنیم که بتونه ۸ بیت رو NOT کنه
  2. مداری طراحی کنیم که بتونه ۸ بیت رو OR کنه
  3. مداری طراحی کنیم که بتونه ۸ بیت رو AND کنه
  4. و مدار(ها)ی طراحی کنیم که بتونن ۸ بیت رو جمع و تفریق کنن.

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

در پست های بعدی، زیرمدارهای کامپیوتر خودمون رو میسازیم. در این پست صرفا با کامپیوتر ساده و کوچیکمون آشنا شدیم 🙂

Share

نوشتن اسمبلی ۳۲ بیت

در گذشته، پست هایی که در مورد اسمبلی قرار دادم، همه در مورد اسمبلی ۱۶ بیت بودن اما حالا میخوایم بریم سراغ اسمبلی ۳۲ بیت. خب فرق ۱۶ با ۳۲ بیت در چیه؟!

اولین نکته، سایز ثبات هاست! در ۱۶ بیت در هر ثبات میتونستیم حداکثر یک مقدار ۴ رقمی هگزادسیمال ذخیره کنیم ولی در ۳۲ بیت این مقدار به ۸ رقم میرسه! حالا خیلی مسائل دیگه مثل دیتاباس و کنترل باس و … که بماند (چون اینجا داریم برنامه نویسی میکنیم و بیشتر با ثبات ها کار داریم).

اینجا، قضیه یه فرقای کوچولویی داره، مثلا اسمبلر nasm قراره استفاده بشه (گرچه قبلا در ساخت اون سیستم عامل کوچک ازش استفاده کردیم) و همچنین وقفه ها و system call هایی که استفاده میکنیم شماره و مقدارشون و مکانشون متفاوته.

بیاید این برنامه رو در نظر بگیریم :

کد   
section .text
	global_start
 
_start:
	mov edx, len
	mov ecx, msg
	mov eax, 0x04
	int 0x80
 
	mov eax, 0x01
	int 0x80
 
section .data
	msg db 'Hello, World!', 0xa
	len equ $ - msg

 

خب در بخش اول، تابعی که نیاز داریم فراخوانی کنیم رو تعریف کردیم. بعدش اومدیم start رو نوشتیم. حالا بیاید این بخش رو بررسی کنیم :

کد   
mov edx, len
mov ecx, msg
mov eax, 0x04
int 0x80

اینجا، مقدار طول رشته ای که خواستیم چاپ کنیم رو توی EDX یا رجیستر داده قرار دادیم. بعدش اومدیم پیامی که میخوایم چاپ بشه رو قرار دادیم درو نECX .

بعدش سیستم کال ۴ یا sys_write رو توی eax قرار دادیم و وقفه ۸۰ رو صدا زدیم. حالا وقفه ۸۰ با مقدار ۴ که توی eax ذخیره شده، میگرده دنبال رشته ای که توی ecx هست و بعدش چاپش میکنه.

حالا بخش دوم کد سگمنت رو بررسی میکنیم :

کد   
mov eax, 0x01
int 0x80

اینجا هم مقدار ۰۱ یا sys_exit رو وارد eax کردیم، تا برنامه پس از اجرا، خارج شه. بعد از این هم باز وقفه ۸۰ رو صدا زدیم.

بخش دیتا هم، مثل همه برنامه های قبلی، تمام داده های مورد نیاز رو با Directive ها تعریف کردیم که بتونیم به راحتی توی کد سگمنت ازشون استفاده کنیم و چون قبلا توضیح داده شده، دیگه دوباره کاری نمی کنم. فقط این پست رو نوشتم تا فرقهای اسمبلی ۳۲ و ۱۶ بیت رو ببینیم. که درآینده بسطش خواهم داد به ۶۴ بیت.

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

موفق و موید باشید!

Share

زبان ماشین، رمزگشای دستور العمل

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

یک دستور در ماشین چطور خونده میشه؟

این خیلی مهمه که بدونیم یک دستور به چه شکلی خونده میشه. بسیار خوب، دستور زیر رو در نظر بگیرید :

کد   
MOV AX, 0

 

این دستور ماشین کد به این شکل داره :

کد   
B8 0000

 

که البته این ماشین کد، یک ماشین کد هگزادسیمال هست. اون چهار صفری که داریم که مقداری هست که خواستیم توی AX قرار بدیم و باهاش کاری نداریم، ولی B8 ما ، همون دستوریه که لازمه رمزگشایی شه و به صورت دو دویی به این شکل در میاد :

کد   
1011 1000

 

خب ما یک «دیکدر» (که یک مدار متشکل از n ورودی و دو به توان n خروجی هست) داریم، که این اعداد رو به ترتیب روشن و خاموش میکنه، و به این شکله که ما به  دستور میرسیم. در واقع مدارات مربوط به دستور رو خواهیم داشت.

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

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

زبان ماشین، اول به صورت اسمبلی نوشته میشه که به زبون انسان خیلی خیلی نزدیکه. یعنی هرکس کمی انگلیسی بدونه میدونه که کلمه ای مثل ADD یعنی جمع کردن. اما، حالا مشکلی که هست اینه که وقتی «اسمبلی» به «آبجکت کد» یا همون کد هگزادسیمال تبدیل میشه رو هرکسی نمیتونه بخونه. پس راه حل چیه؟

اول باید ببینیم که یک خط آبجکت کد از چیا تشکیل میشه! بیاید این مثال رو در نظر بگیریم باز :

کد   
MOV AX, 0 ;B8 0000

 

خب اینجا من آبجکت کد رو به صورت کامنت در آوردم. دو بخش داریم، یکیش چهارتا صفر، که بهش عملوند یا Operand میگیم و دیگری «کد عملیات» یا Operation Code هست. مثلا برای انتقال به AX همیشه از B8 استفاده میشه. چرا؟ چون اینتل اینطور خواسته 😀 . بعد از این، این کد هگزادسیمال به یک کد باینری تبدیل میشه که CPU میتونه اون رو برای ما اجرا کنه.

از کجا آبجکت کد رو بخونیم؟

همه اسمبلر های موجود میتونن فایلی تولید کنن که آبجکت کد، سمبلهای به کار رفته و … رو شامل شه، و در اسمبلر MASM این فایل با پسوند LST ساخته میشه. شما میتونید با باز کردن این فایل با یک ویرایشگر متنی و خوندنش، ببینید که هر دستوری چه کدی رو داره.

یک برنامه نمونه

خب، من یک برنامه اسمبلی خیلی ساده نوشتم که اجرا کردنش هیچ خروجی ای نداره (:D ) ولی خب آبجکت کد ها تولید شده و اسمبل بدون مشکل صورت گرفته. این برنامه با آبجکت کدهاش به صورت کامنت به این شکله (بررسی دستور MOV در ۱۲ حالت مختلف) :

کد   
.MODEL SMALL
.8086
.STACK 
.DATA
.CODE
MOV AX, 0 ;B8 0000
MOV BX, 0 ;BB 0000
MOV CX, 0 ;B9 0000
MOV DX, 0 ;BA 0000
MOV AH, 0 ;B4 00
MOV BH, 0 ;B7 00
MOV CH, 0 ;B5 00
MOV DH, 0 ;B6 00
MOV AL, 0 ;B0 00
MOV BL, 0 ;B3 00
MOV CL, 0 ;B1 00
MOV DL, 0 ;B2 00
END

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

تا پست های بعدی، و اسمبلی بیشتر، موفق و موید و آزاد و شاد باشید! 🙂

Share

دیدار با 8086 + کد روشن و خاموش کردن LED

نرم افزارهای زیادی برای کار با مدارات، تراشه ها و سایر دیوایس های الکترونیکی ساخته شده، ولی دو روزی هست که با Proteus دارم کار میکنم و میتونم بگم در این زمینه، از بهترین هاست. یکی از خوبی هاش داشتن تراشه های متعدد، با قابلیت اجرای برنامست. یکی از معروف ترین ریزپردازنده هایی که در این نرم افزار به کار رفته، پردازنده 8086 از اینتل هست. من این رو با این پردازنده ساختم (البته اصلا و ابدا مطمئن نیستم که مدارم درست باشه! ولی خود برنامه ایرادی ازش نگرفت) :

8086led

 

خب این مدار قراره چه کنه؟! قراره به کمک 8086 و یک مدار مجتمع 8255 ، چند تا LED رو به ترتیب خاموش و روشن کنه. یکی از ویژگی های پرتئوس اینه که تراشه هایی که داخلش هستند، همه برنامه پذیرند. البته شما باید برنامه هاتون رو بنویسید بعد اسمبل (یا کامپایل، بسته به نوع برنامه) کنید و بعد فایل اجراییتون رو به خورد تراشه بدید. بسیار خوب، برنامه ای که برای روشن و خاموش کردن LED نوشتم اینه :

کد   
.MODEL SMALL
.8086
.STACK
.CODE
MOV AL, 80
MOV DX, 0FF36h
OUT DX, AL
BEGIN: MOV AL,00
MOV DX, 0FF30h
OUT DX, AL 
CALL DELAY
MOV AL, 0FFh
OUT DX, AL 
CALL DELAY 
JMP BEGIN 
DELAY: MOV CX, 0FFFFh
P0 : DEC CX 
JNE P0 
RET
.DATA
END

خب، این برنامه رو باید با masm32 اسمبل کنید، که مراحلش به این شکله (مراحل اسمبل و لینک کردن در سیستم عامل ویندوز اینطوره، برای لینوکس هم سعی میکنم راه حلش رو پیدا کنم) :

کد   
ml /c /Zi /Zd LED.asm
link16 /CODEVIEW LED.obj,LED.exe,,, nul.def

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

OpCode

این هم از آپکد های این برنامه.

حواستون باشه مداری که کشیده شده ممکنه درست نباشه، در صورتی که برنامه درست اجرا میشه (برنامه تست شده و از این بابت مطمئنم).

امیدوارم شما هم با 8086 لحظات شادی رو تجربه کنید، درسته که یه پردازشگر قدیمیه، ولی کار باهاش شدیدا فانه!

موفق باشید 🙂

Share

ساخت یک کامپیوتر ۴ بیتی ساده با استفاده از مدارات منطقی

یک زمانی، حتی فکر کردن به این که بتونیم با چندتا مدار ساده یک کامپیوتر (حتی ۴ بیتی) هم داشته باشیم، احمقانه و ناممکن به نظر میرسید. چرا که هزینه شبیه سازی خیلی از مدارها و تستشون بسیار بالا بود. اما توی این دوره، شما با خوندن چند تا داکیومنت و نصب چند نرم افزار ساده، میتونید کامپیوتر خودتون رو بسازید. بسیار خوب، منبع این پست ، این مقالست که یک ویدئوی خوب هم داره. توی این مقاله به جای استفاده مستقیم از مدارات منطقی، اومدن و از ترانزیستور استفاده کردن، اما باز هم استفاده از ترانزیستور منطقی به نظر نمیرسه، چرا که مدارهای منطقی کوچک ترن و فهمشون هم راحت تره.

مدارهای منطقی چی هستن؟

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

برای پردازنده کوچکمون چی نیازه؟

اول از همه، نیاز داریم که یک مدار Adder بسازیم. مدارهای Adder معمولا از چند تا Full Adder یک بیتی تشکیل میشن، و هر فول ادر یک بیتی هم از دو تا Half-adder .

برای ساخت Half-adder کافیه که یک بار ورودی A رو NOT کنیم و با B اون رو AND کنیم، سپس B رو NOT کنیم و با A اون رو AND کنیم. آخر هم نتیجه دو تا AND رو با هم OR کنیم. برای بدست آوردن رقم نقلی هم کافیه که A و B رو مستقیما با هم AND کنیم.half-adder2

مدار Half Adder نهاییمون به این شکل میشه. اما استفاده مدوام از NOT و AND و OR باعث سخت شدن توسعه ماشین میشه، پس از مجموعه ای که برای ساخت Half Adder استفاده کردیم میتونیم صرف نظر کنیم و از مدار XOR استفاده کنیم. البته همچنان برای رقم نقلیمون به AND نیاز خواهیم داشت.

بسیار خوب، برای Full Adder نیاز داریم که از پیش تعیین کنیم رقم نقلی ای وجود داره؟ یا نه! و برای این کار غیر از A و B یک ورودی به اسم Carry In یا «رقم نقلی ورودی» خواهیم داشت. و سپس، رقم نقلی ورودی رو باید به عنوان ورودی به یک Half-Adder دیگه بدیم. سپس، نتیجه AND شدن A و B رو با نتیجه AND شدن اولین Half-Adder و Carry In رو با هم OR کنیم تا رقم نقلی کلی بدست بیاد. پس مدار ما به این شکل خواهد شد :

full adderخب، این دو مدار رو الان ساختیم. قدم بعدی، ساختن کامپیوترمونه!

برای ساختن یک Adder چهار بیتی، باید به این شکل فول ادر ها رو کنار هم بچینیم :

Slide11همونطور که دیدید، این روش چیدن Adder ها پشت هم، مدل Ripple Carry نامیده میشه. خب، این کامپیوتر کوچک، میتونه اعداد ۰ تا ۱۶ (در دنیای بدون علامت و با در نظر گرفتن رقم نقلی) و -۱۶ تا ۱۵ (در دنیای علامت دار و بدون در نظر گرفتن رقم نقلی) رو به ما نمایش بده. با خاموش و روشن کردن به موقع مدارها عملیات جمع و تفریق رو میتونید انجام بدید.

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

4-bit computer simulation

برای شبیه سازی چه نرم افزاری نیازه؟

من برای کشیدن نقشه Half Adder و Full Adder از تخته وایت برد اتاقم (بله! تخته وایت برد توی اتاقا الزامیه!) و نرم افزار Logisim (موجود در مخازن اوبونتو) استفاده کردم. برای شبیه سازی کلی ماشین هم از Logic.ly که آزمایشگاه آنلاین داره استفاده کردم. البته هر نرم افزار دیگه ای میتونه بهتون در شبیه سازی کمک کنه. حتی میتونید با VHDL هم بنویسیدش و تستش کنید!

امیدوارم که این پست هم براتون مفید واقع شده باشه!

موفق باشید.

Share

توسعه سیستم عامل – طراحی 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