سؤال : كيف يمكن كتابة برنامج بدون المكتبات القياسية ؟

[The Hidden Ghost 69]

السلام عليكم ورحمة الله تعالى وبركاته ،،،

أظن أن سؤالي واضح كوضوح الشمس في عزة الظهيرة ، هل يمكننا فعل هذا فعلا .

لقد مللت من إضافة

 #include

في كل مرة أفتح فيها برنامج الديف السي

بلس بلس . أنا متأكد بأن هناك طريقة ما لفعل هذا لأن الدالة printf الموجودة في مكتبة

stdio.h هي نفسها تحول إلى كود أسمبلي ، فالحل هو أن نعرف هذا الكود ثم نصنع

دالتنا الخاصة بنا . أعرف أنني يمكنني فعل هذا في ال 16 بت باللجوء إلى هذه الطريقة :

void MyPrettyPrintf(char text[])
{
asm mov ah,0x09
asm mov dx,offset text
asm int 21h
}
void main()
{
MyPrettyPrintf("je Suis Hamza");
asm
{
mov ax,0x0000
int 16h
}
}

لكنني أريد فعل هذا في ال32 بت ، أرجو المساعدة و شكرا لكم على حسن الضيافة

تم تعديل 15 Sep 2012 بواسطه Hamza+C+ASM

[ahmed.o.mohamed 931]

السلام عليكم

لم أفهم السؤال جيداً !

هل المطلوب هو تحويل كود الأسمبلي إلى ما يُكافئه في معالجات 32 بت ؟ :)

[The Hidden Ghost 69]

لا أخي أحمد ،،، ، أنا أريد أن أبرمج برنامجا بلغة السي مثلا بدون أن اعتمد على المكتبات القياسية التي توفرها اللغة مثلا ، سأصنع دالة خاصة بي للطباعة ثم استخدمها في برنامجي

خذ هذا كمثال :

void myprinf(char text[100])
{

// كيف تحول الدالة printf إلى كود أسمبلي لتطبع النصوص

}

void main()
{
myprintf("Down America !!!");
}

هل فهمت قصدي ؟ ، لقد استغنيت عن المكتبة stdio.h

[The Hidden Ghost 69]

أعوذ بالله من الشيطان الرجيم ، إياكم و أن تفكروا في هذا الأمر مرة أخرى

لقد بحثت و وجدت أنه لكي تبرمج printf خاصة بك يجب عليك أن تكتب هذا الكود :

Page 58,132
Title PRINTF.ASM Generic Printf Module
;******************************************************************************
;
; Name: PRINTF.ASM Generic Printf Module
;
; Revision: 1.00
;
; Date: November 30, 1988
;
; Author: Randy Spurlock
;
;******************************************************************************
;
; Module Functional Description:
;
; Printf - Prints a formatted string of arguments to
; the requested handle.
;
; Calling Sequence:
;
; mov al,HANDLE ; Get the desired handle to print on
; lea bx,ds:[args] ; Get a pointer to the arguments
; lea si,ds:[format] ; Get a pointer to the format string
; call printf ; Call the printf routine
;
; The conversion characters are as follows:
;
; %% - Print percent sign to handle
; %c - Output the next argument as a character
; %s - Output the next argument as a string
; %x - Output the next argument as a hex number using abcdef
; %X - Output the next argument as a hex number using ABCDEF
; %h - Output the next argument as a hex number using abcdef
; %H - Output the next argument as a hex number using ABCDEF
; %d - Output the next argument as a decimal number (Signed)
; %u - Output the next argument as a decimal number (Unsigned)
; %o - Output the next argument as a octal number
; %b - Output the next argument as a binary number
; %f - Output the next argument as a fractional number (Signed)
;
; Other format specifiers may precede the conversion character:
;
; - - Left justify the field
; + - Set signed field
; n - Specify the field width/precision
; t - Specify short value
; l - Specify long value
; # - Specify far argument pointer
; & - Specify indirect argument pointer
; $ - Specify immediate argument value
; * - Variable precision/width value (From argument list)
;
; All arguments must be pointers to the actual values.
;
; The following escape sequences are also handled:
;
; \\ - Backslash
; \n - Newline
; \t - Horizontal Tab
; \v - Vertical Tab
; \b - Backspace
; \r - Carriage Return
; \f - Form Feed
; \ddd - ASCII Character (Octal Notation)
; \xdd - ASCII Character (Hexadecimal Notation)
;
;******************************************************************************
;
; Changes:
;
; DATE REVISION DESCRIPTION
; -------- -------- -------------------------------------------------------
; 11/30/88 1.00 Original Randy Spurlock
;
;******************************************************************************
Page
;
; Public Declarations
;
Public Printf ; Generic Printf routine
;
; Define the Local Equates
;
FORMAT_CHAR Equ "%" ; Format specification character
ESCAPE_CHAR Equ "\" ; Escape sequence character
BASE_HEX Equ 16 ; Base 16 - Hexadecimal
BASE_DECIMAL Equ 10 ; Base 10 - Decimal
BASE_OCTAL Equ 8 ; Base 8 - Octal
BASE_BINARY Equ 2 ; Base 2 - Binary
FORMAT_LENGTH Equ 5 ; Maximum format number width
ESCAPE_LENGTH Equ 3 ; Escape sequence number width (Decimal)
HEX_LENGTH Equ 2 ; Escape sequence number width (Hex)
MAX_WORD Equ 0FFFFh ; Maximum 16-bit count value
MAX_BYTE Equ 0FFh ; Maximum 8-bit count value
SPACE_PAD Equ " " ; Space pad character
ZERO_PAD Equ "0" ; Zero pad character
LEFT_JUST Equ 8000h ; Left justification flag
SHORT_SPEC Equ 4000h ; Short specification flag
LONG_SPEC Equ 2000h ; Long specification flag
UPPER_CASE Equ 1000h ; Upper case hexadecimal flag
SIGNED_CONV Equ 0800h ; Signed conversion flag
SIGNED_TYPE Equ 0400h ; Signed type flag
SIGNED_VAL Equ 0200h ; Signed value flag
PRE_PAD Equ 0100h ; Pre-pad sign character flag
FAR_SPEC Equ 0080h ; Far argument specification flag
OVER_FLOW Equ 0040h ; Field overflow flag
FRACTIONAL Equ 0020h ; Fractional integer flag
VAR_WIDTH Equ 0010h ; Variable width flag
VAR_PRE Equ 0008h ; Variable precision flag
PAD_CHAR Equ 0004h ; Pad character flag (0=Space, 1=Zero)
INDIRECT Equ 0002h ; Indirection flag (1 = Indirect)
IMMEDIATE Equ 0001h ; Immediate flag (1 = Immediate)
SIGNED Equ 8000h ; Sign flag test mask
DECIMAL_ADJUST Equ 30h ; ASCII decimal to binary adjust value
HEX_ADJUST Equ 07h ; ASCII hex to binary adjust value
UPPER_MASK Equ 0DFh ; Lower to upper case mask value
FAR_SIZE Equ 4h ; Far argument pointer size (4 bytes)
NEAR_SIZE Equ 2h ; Near argument pointer size (2 bytes)
LONG_SIZE Equ 4h ; Long numeric argument size (4 bytes)
NORMAL_SIZE Equ 2h ; Normal numeric argument size(2 bytes)
SHORT_SIZE Equ 1h ; Short numeric argument size (1 bytes)
BUFF_SIZE Equ 64 ; Numeric build buffer size
DIGIT_MAX Equ 39h ; Maximum ASCII digit value
DOS_FUNCTION Equ 21h ; MS-DOS function request interrupt
WRITE_FILE Equ 40h ; Write file function code
;
; Define any ASCII characters needed
;
PLUS Equ "+" ; Plus sign character
MINUS Equ "-" ; Minus sign character
EQUAL Equ "=" ; Equal sign character
ASTERISK Equ "*" ; Asterisk character
POINT Equ "." ; Decimal point character
NULL Equ 00h ; ASCII code for null
BS Equ 08h ; ASCII code for backspace
HT Equ 09h ; ASCII code for horizontal tab
LF Equ 0Ah ; ASCII code for line feed
VT Equ 0Bh ; ASCII code for vertical tab
FF Equ 0Ch ; ASCII code for form feed
CR Equ 0Dh ; ASCII code for carriage return
;
; Define any Macros needed
;
Page
;******************************************************************************
;
; Save(Regs)
;
; While there are registers in the list (Left to right)
; Push this register onto the stack
; Endwhile
;
;******************************************************************************
Save Macro a,b,c,d,e,f,g,h,i,j,k,l,m,n,o
Irp x,<a,b,c,d,e,f,g,h,i,j,k,l,m,n,o>
Ifnb <x>
push x
Endif
Endm
Endm
Page
;******************************************************************************
;
; Restore(Regs)
;
; While there are registers in the list (Right to left)
; Pop this register from the stack
; Endwhile
;
;******************************************************************************
Restore Macro a,b,c,d,e,f,g,h,i,j,k,l,m,n,o
Irp x,<o,n,m,l,k,j,i,h,g,f,e,d,c,b,a>
Ifnb <x>
pop x
Endif
Endm
Endm
Page
;
; Define the standard code segment
;
Code Segment Word Public 'CODE' ; Define the standard code segment
Assume cs:Code, ds:Nothing, es:Nothing
Page
;******************************************************************************
;
; Routine Functional Description
;
; Printf(Format_String, Arguments, Handle)
;
; Save the required registers
; While next character from Format_String <> 0
; If next character is a format character (percent sign)
; Get the next character from Format_String
; If a format specifier (+,-,n,l,#,&,$,*)
; Set the appropriate specifier flag
; Else not a format specifier
; If a conversion character (c,s,x,d,o,b)
; Print argument using conversion
; Increment argument pointer
; Else not a conversion character
; Ignore this format
; Endif
; Endif
; Else the character is not a format character
; If character is a escape character (backslash)
; Get next character from Format_String
; If a valid escape sequence
; Handle the escape sequence
; Else an invalid escape sequence
; Print the character to Handle
; Endif
; Else the character is not an escape character
; Print the character to Handle
; Endif
; Endif
; Endwhile
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AL - File Handle to Print on
; DS:BX - Pointer to Argument List
; DS:SI - Pointer to Format String
;
; Registers on Exit:
;
; FL - DR flag is cleared (Move forward)
;
;******************************************************************************
Printf Proc Near ; Generic printf procedure
Save ax,bx,cx,dx,si,di,bp,ds,es
mov ah,al ; Save print handle in AH
cld ; Clear the direction flag (Forward)
;
; Get a character from format string and decide what to do with it
;
Get_Char:
call Clear_Flags ; Clear all of the specifier flags
lodsb ; Get a character from format string
cmp al,FORMAT_CHAR ; Check for a format character (%)
je Do_Format ; Jump if a format character
cmp al,ESCAPE_CHAR ; Check for an escape character (\)
je Do_Escape ; Jump if a escape character
or al,al ; Check for end of the format string
jnz Normal_Output ; Jump if a normal character to output
jmp Printf_Exit ; Jump if end of the format string
;
; It is a escape character, get the next character and check it
;
Do_Escape:
lodsb ; Get next character from format string
push cs ; Put copy of CS onto the stack
pop es ; Put copy of current CS into ES
lea di,cs:[Escape_Table] ; Setup the escape character table
mov cx,ESCAPE_SIZE ; Get the escape character table size
repne scasb ; Scan the escape table for a match
je Go_Escape ; Jump if an there was a table match
mov ch,BASE_OCTAL ; Set the current base value to OCTAL
mov cl,ESCAPE_LENGTH ; Set the escape maximum number count
call Check_Digit ; Check for numeric digit (Character)
jc Normal_Output ; Jump if an unknown escape character
Get_Code:
dec si ; Backup to the start of the number
push dx ; Save the field width/precision
call Get_Number ; Call routine to get the number
mov al,dl ; Put the character number into AL
pop dx ; Restore the field width/precision
jmp Short Normal_Output ; Go get next format string character
Go_Escape:
mov di,ESCAPE_SIZE ; Get the escape table size
sub di,cx ; Compute the matching entry number
dec di ; Convert number to zero based
shl di,1 ; Make number into jump table index
call cs:[di+Escape_Jump] ; Call the correct routine
jmp Short Get_Char ; Go get the next character
Normal_Output:
call Output ; Not a special character, output it
jmp Short Get_Char ; Go get next format string character
;
; Not a valid format specifier, check for a conversion character
;
Do_Convert:
lea di,cs:[Convert_Table] ; Setup the convert character table
mov cx,CONVERT_SIZE ; Get the convert character table size
repne scasb ; Scan the convert table for a match
jne Get_Char ; Jump if an unknown convert character
mov di,CONVERT_SIZE ; Get the convert table size
sub di,cx ; Compute the matching entry number
dec di ; Convert number to zero based
shl di,1 ; Make number into jump table index
call cs:[di+Convert_Jump] ; Call the correct routine
jmp Short Get_Char ; Go get the next character
;
; It is a format character, get the next character and check it
;
Do_Format:
lodsb ; Get next character from format string
push cs ; Put copy of CS onto the stack
pop es ; Put copy of current CS into ES
lea di,cs:[Format_Table] ; Setup the format character table
mov cx,FORMAT_SIZE ; Get the format character table size
repne scasb ; Scan the format table for a match
je Go_Format ; Jump if an there was a table match
mov ch,BASE_DECIMAL ; Set the current base value to DECIMAL
mov cl,FORMAT_LENGTH ; Set the format maximum number count
cmp al,POINT ; Check for a decimal point
jne Chk_Var ; Jump if no decimal point found
dec si ; Correct pointer for no width value
xor dh,dh ; Setup a width value of zero
jmp Short Chk_Pre ; Go check for a precision value
Chk_Var:
cmp al,ASTERISK ; Check for variable width field
jne Do_Width ; Jump if not a variable width field
or bp,VAR_WIDTH ; Set variable width flag bit
mov dh,MAX_BYTE ; Set width value as already set
jmp Short Chk_Pre ; Go check for a precision value
Do_Width:
call Check_Digit ; Check for numeric digit (Field width)
jc Do_Convert ; Jump if an unknown format character
dec si ; Backup to the start of the number
or al,al ; Check for a leading zero
jnz Get_Width ; Jump if first digit not a zero
or bp,PAD_CHAR ; First digit zero, use zero pad
or bp,PRE_PAD ; Set pre-pad sign character flag
Get_Width:
call Get_Number ; Call routine to get the field width
mov dh,dl ; Save the field width in DH
cmp Byte Ptr ds:[si],ASTERISK
jne Chk_Pre ; Jump if not a variable width field
inc si ; Increment past variable character
or bp,VAR_WIDTH ; Set variable width flag bit
mov dh,MAX_BYTE ; Set width value as already set
Chk_Pre:
xor dl,dl ; Setup a precision of zero
cmp Byte Ptr ds:[si],POINT ; Check for a decimal point
jne Do_Format ; Jump if no precision given
or bp,FRACTIONAL ; Set the fractional conversion flag
dec dl ; Set precision as already set
inc si ; Increment past the decimal point
cmp Byte Ptr ds:[si],ASTERISK
jne Get_Pre ; Jump if not a variable precision
inc si ; Increment past variable character
or bp,VAR_PRE ; Set variable precision flag bit
jmp Short Do_Format ; Go check for more format characters
Get_Pre:
call Get_Number ; Call routine to get the precision
adc dl,0 ; Setup correct precision value
jmp Short Do_Format ; Go check for more format characters
Go_Format:
mov di,FORMAT_SIZE ; Get the format table size
sub di,cx ; Compute the matching entry number
dec di ; Convert number to zero based
shl di,1 ; Make number into jump table index
call cs:[di+Format_Jump] ; Call the correct routine
jmp Short Do_Format ; Go check for more format characters
;
; Restore the registers and return to the caller
;
Printf_Exit:
Restore ax,bx,cx,dx,si,di,bp,ds,es
ret ; Return to the caller
Page
;
; Define the format specifier character and jump tables
;
Format_Table Label Byte
Db '-' ; Left justify format specifier
Db '+' ; Set signed specifier
Db 't' ; Short format specifier
Db 'T' ; Short format specifier
Db 'l' ; Long format specifier
Db 'L' ; Long format specifier
Db '#' ; Far format specifier
Db '&' ; Indirect format specifier
Db '$' ; Immediate format specifier
FORMAT_SIZE Equ This Byte - Format_Table
Format_Jump Label Word
Dw Left_Justify
Dw Set_Signed
Dw Short_Specify
Dw Short_Specify
Dw Long_Specify
Dw Long_Specify
Dw Far_Specify
Dw Set_Indirect
Dw Set_Immediate
;
; Define the escape character and jump tables
;
Escape_Table Label Byte
Db 'n' ; Newline escape character
Db 't' ; Horizontal tab escape character
Db 'v' ; Vertical tab escape character
Db 'b' ; Backspace escape character
Db 'r' ; Carriage return escape character
Db 'f' ; Form feed escape character
Db 'x' ; Output character (Hex representation)
ESCAPE_SIZE Equ This Byte - Escape_Table
Escape_Jump Label Word
Dw New_Line
Dw Horz_Tab
Dw Vert_Tab
Dw Back_Space
Dw Carr_Ret
Dw Form_Feed
Dw Out_Hex
;
; Define the convert character and jump tables
;
Convert_Table Label Byte
Db '%' ; Print the percent sign
Db 'c' ; Print next argument as a character
Db 'C' ; Print next argument as a character
Db 's' ; Print next argument as a string
Db 'S' ; Print next argument as a string
Db 'x' ; Print next argument as HEX (abcdef)
Db 'X' ; Print next argument as HEX (ABCDEF)
Db 'h' ; Print next argument as HEX (abcdef)
Db 'H' ; Print next argument as HEX (ABCDEF)
Db 'd' ; Print next argument as DECIMAL (+/-)
Db 'D' ; Print next argument as DECIMAL (+/-)
Db 'u' ; Print next argument as UNSIGNED
Db 'U' ; Print next argument as UNSIGNED
Db 'o' ; Print next argument as OCTAL
Db 'O' ; Print next argument as OCTAL
Db 'b' ; Print next argument as BINARY
Db 'B' ; Print next argument as BINARY
Db 'f' ; Print next argument as FRACTIONAL
Db 'F' ; Print next argument as FRACTIONAL
CONVERT_SIZE Equ This Byte - Convert_Table
Convert_Jump Label Word
Dw Print_Format ; Print format routine
Dw Do_Char ; Print character routine
Dw Do_Char ; Print character routine
Dw Do_String ; Print string routine
Dw Do_String ; Print string routine
Dw Do_Hex_Lower ; Print lowercase hexadecimal routine
Dw Do_Hex_Upper ; Print uppercase hexadecimal routine
Dw Do_Hex_Lower ; Print lowercase hexadecimal routine
Dw Do_Hex_Upper ; Print uppercase hexadecimal routine
Dw Do_Decimal ; Print signed decimal routine
Dw Do_Decimal ; Print signed decimal routine
Dw Do_Unsigned ; Print unsigned decimal routine
Dw Do_Unsigned ; Print unsigned decimal routine
Dw Do_Octal ; Print octal routine
Dw Do_Octal ; Print octal routine
Dw Do_Binary ; Print binary routine
Dw Do_Binary ; Print binary routine
Dw Do_Fractional ; Print decimal fractional routine
Dw Do_Fractional ; Print decimal fractional routine
;
; Define the end of the printf procedure
;
Printf Endp ; End of the Printf procedure
Page
;******************************************************************************
;
; Format Specificer Routines
;
;
; These routines handle the following format specifiers:
;
;
; Specifier Action Taken
; --------- ------------
;
; - The following field will be left justified.
;
; + The following field will be have a sign (+/-)
; if it is a signed type field (d).
;
; t The following field is a short value.
;
; T The following field is a short value.
;
; l The following field is a long value.
;
; L The following field is a long value.
;
; # The following argument has a far address.
;
; & The following argument has an indirect address.
;
; $ The following argument is an immediate value.
;
; These routines simply set or reset flags which are
; used later during actual conversion to perform the special
; formatting options.
;
;******************************************************************************
Page
;******************************************************************************
;
; Routine Functional Description
;
; Left_Justify()
;
; Set the left justification flag
; Return to the caller
;
; Registers on Entry:
;
; None
;
; Registers on Exit:
;
; BP - Left justification flag set
;
;******************************************************************************
Left_Justify Proc Near ; Left justify procedure
or bp,LEFT_JUST ; Set the left justification flag
ret ; Return to the caller
Left_Justify Endp ; End of the Left_Justify procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Set_Signed()
;
; Set the signed flag
; If the field width is non-zero
; Set the pre-pad sign flag
; Endif
; Return to the caller
;
; Registers on Entry:
;
; DH - Field width (Not given if zero)
;
; Registers on Exit:
;
; BP - Signed flag set
;
;******************************************************************************
Set_Signed Proc Near ; Set signed procedure
or bp,SIGNED_CONV ; Set the signed conversion flag
or dh,dh ; Check the field width
jz Sign_Ret ; Jump if field width not set
or bp,PRE_PAD ; Set the pre-pad sign flag
Sign_Ret:
ret ; Return to the caller
Set_Signed Endp ; End of the Set_Signed procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Short_Specify()
;
; Set the short specification flag
; Return to the caller
;
; Registers on Entry:
;
; None
;
; Registers on Exit:
;
; BP - Short specification flag set
;
;******************************************************************************
Short_Specify Proc Near ; Short specify procedure
or bp,SHORT_SPEC ; Set the short specification flag
ret ; Return to the caller
Short_Specify Endp ; End of the Short_Specify procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Long_Specify()
;
; Set the long specification flag
; Return to the caller
;
; Registers on Entry:
;
; None
;
; Registers on Exit:
;
; BP - Long specification flag set
;
;******************************************************************************
Long_Specify Proc Near ; Long specify procedure
or bp,LONG_SPEC ; Set the long specification flag
ret ; Return to the caller
Long_Specify Endp ; End of the Long_Specify procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Far_Specify()
;
; Set the far specification flag
; Return to the caller
;
; Registers on Entry:
;
; None
;
; Registers on Exit:
;
; BP - Far specification flag set
;
;******************************************************************************
Far_Specify Proc Near ; Far specify procedure
or bp,FAR_SPEC ; Set the far specification flag
ret ; Return to the caller
Far_Specify Endp ; End of the Far_Specify procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Set_Indirect()
;
; Set the indirect flag
; Return to the caller
;
; Registers on Entry:
;
; None
;
; Registers on Exit:
;
; BP - Indirection flag set
;
;******************************************************************************
Set_Indirect Proc Near ; Set indirect procedure
or bp,INDIRECT ; Set the indirection flag
ret ; Return to the caller
Set_Indirect Endp ; End of the Set_Indirect procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Set_Immediate()
;
; Set the immediate flag
; Return to the caller
;
; Registers on Entry:
;
; None
;
; Registers on Exit:
;
; BP - Immediate flag set
;
;******************************************************************************
Set_Immediate Proc Near ; Set immediate procedure
or bp,IMMEDIATE ; Set the immediate flag
ret ; Return to the caller
Set_Immediate Endp ; End of the Set_Immediate procedure
Page
;******************************************************************************
;
; Escape Sequence Routines
;
;
; These routines handle the following escape sequences:
;
;
; Character Escape Sequence
; --------- ---------------
;
; n Newline is output to requested handle
;
; t Horizontal tab is output to requested handle
;
; v Vertical tab is output to requested handle
;
; b Backspace is output to requested handle
;
; r Carriage return is output to requested handle
;
; f Form feed is output to requested handle
;
; x Character is output to requested handle (Hex code)
;
;
; All of these routines except for the "x" escape
; sequence simply send the desired character(s) out to the
; requested handle. The "x" routine get the hexadecimal
; number given and outputs the corresponding character to
; the requested handle.
;
;******************************************************************************
Page
;******************************************************************************
;
; Routine Functional Description
;
; New_Line(Handle)
;
; Output carriage return to handle
; Output line feed to handle
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
;
; Registers on Exit:
;
; AL - Destroyed
;
;******************************************************************************
New_Line Proc Near ; Output new line procedure
mov al,CR ; Get carriage return ASCII character
call Output ; Output the carriage return to handle
mov al,LF ; Get a line feed ASCII character
call Output ; Output the line feed to handle
ret ; Return to the caller
New_Line Endp ; End of the New_Line procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Horz_Tab(Handle)
;
; Output horizontal tab to handle
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
;
; Registers on Exit:
;
; AL - Destroyed
;
;******************************************************************************
Horz_Tab Proc Near ; Output horizontal tab procedure
mov al,HT ; Get horizontal tab ASCII character
call Output ; Output the horizontal tab to handle
ret ; Return to the caller
Horz_Tab Endp ; End of the Horz_Tab procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Vert_Tab(Handle)
;
; Output vertical tab to handle
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
;
; Registers on Exit:
;
; AL - Destroyed
;
;******************************************************************************
Vert_Tab Proc Near ; Output vertical tab procedure
mov al,VT ; Get vertical tab ASCII character
call Output ; Output the vertical tab to handle
ret ; Return to the caller
Vert_Tab Endp ; End of the Vert_Tab procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Back_Space(Handle)
;
; Output backspace to handle
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
;
; Registers on Exit:
;
; AL - Destroyed
;
;******************************************************************************
Back_Space Proc Near ; Output backspace procedure
mov al,BS ; Get backspace ASCII character
call Output ; Output the backspace to handle
ret ; Return to the caller
Back_Space Endp ; End of the Back_Space procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Carr_Ret(Handle)
;
; Output carriage return to handle
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
;
; Registers on Exit:
;
; AL - Destroyed
;
;******************************************************************************
Carr_Ret Proc Near ; Output carriage return procedure
mov al,CR ; Get carriage return ASCII character
call Output ; Output the carriage return to handle
ret ; Return to the caller
Carr_Ret Endp ; End of the Carr_Ret procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Form_Feed(Handle)
;
; Output form feed to handle
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
;
; Registers on Exit:
;
; AL - Destroyed
;
;******************************************************************************
Form_Feed Proc Near ; Output form feed procedure
mov al,FF ; Get form feed ASCII character
call Output ; Output the form feed to handle
ret ; Return to the caller
Form_Feed Endp ; End of the Form_Feed procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Out_Hex(String, Handle)
;
; Set number base to hexadecimal
; Set maximum number length
; Call routine to get the number
; Output the number (Character) to handle
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
; DS:SI - Pointer to number
;
; Registers on Exit:
;
; AL - Destroyed
; CX - Destroyed
; DL - Destroyed
; DS:SI - Pointer set to first character past number
;
;******************************************************************************
Out_Hex Proc Near ; Output hex character procedure
mov ch,BASE_HEX ; Set number base to hexadecimal
mov cl,HEX_LENGTH ; Set maximum hex digit length
call Get_Number ; Call routine to get the number
jc Out_Exit ; Jump if no number present
mov al,dl ; Move the number value into AL
call Output ; Output the corresponding character
Out_Exit:
ret ; Return to the caller
Out_Hex Endp ; End of the Out_Hex procedure
Page
;******************************************************************************
;
; Conversion Formatting Routines
;
;
; These routines handle the following conversion types:
;
;
; Character Conversion Done
; --------- ---------------
;
; c Convert next argument as a character
;
; s Convert next argument as a string
;
; x Convert next argument as a hex number using abcdef
;
; X Convert next argument as a hex number using ABCDEF
;
; d Convert next argument as a decimal number (Signed)
;
; u Convert next argument as a decimal number (Unsigned)
;
; o Convert next argument as a octal number
;
; b Convert next argument as a binary number
;
;
; These routines format the arguments passed to them.
; Numeric arguments can be either word or double word (long)
; values and for the decimal option it can be formatted as
; signed or unsigned. All arguments are passed as pointers,
; either near or far, to the actual argument value.
;
;******************************************************************************
Page
;******************************************************************************
;
; Routine Functional Description
;
; Do_Char(Argument, Handle, Flags)
;
; Save the required registers
; Call routine to check for variable width/precision
; Call routine to get the character address
; If field width is not set (Zero)
; Set field width to character value (1)
; Endif
; If character length (1) > field width
; Set the field overflow flag
; Set character length to field width
; Endif
; Set pad character to a space
; Call routine to calculate pad counts
; Call routine to output pre-string pad characters
; Get character to output
; Call routine to output character to handle
; Call routine to output post-string pad characters
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
; DS:BX - Pointer to argument
; DH - Current field width
; BP - Formatting flags
;
; Registers on Exit:
;
; AL - Destroyed
; BX - Points to next argument
; CX - Destroyed
; DL - Destroyed
; DI - Destroyed
; ES - Destroyed
;
;******************************************************************************
Do_Char Proc Near ; Character formatting procedure
Save si,ds ; Save the required registers
call Variable ; Call routine to check width/precision
call Get_Address ; Call routine to get argument address
mov cl,1 ; Set actual width to character value
or dh,dh ; Check the current field width
jnz Width_Chk ; Jump if field width specified
mov dh,1 ; Set field width to character length
Width_Chk:
cmp cl,dh ; Compare actual width to given width
jbe Send_Pre ; Jump if string fits in field width
or bp,OVER_FLOW ; Set the field overflow flag
mov cl,dh ; Clip string to the field width
Send_Pre:
mov al,cl ; Save the actual string length
and bp,Not PAD_CHAR ; Set current pad character to a space
call Calculate ; Call routine to calculate pad values
call Pad ; Call routine to send pad characters
Send_Char:
lodsb ; Get the character to output
call Output ; Call routine to output the character
Send_Post:
mov cl,ch ; Get the calculated pad counts
call Pad ; Call routine to send pad characters
Restore si,ds ; Restore the required registers
ret ; Return to the caller
Do_Char Endp ; End of the Do_Char routine
Page
;******************************************************************************
;
; Routine Functional Description
;
; Do_String(Argument, Handle, Width, Flags)
;
; Save the required registers
; Call routine to check for variable width/precision
; Call routine to get the string address
; Call routine to compute string length
; If field width is not set (Zero)
; Set field width to string length
; Endif
; If string length > field width
; Set the field overflow flag
; Set string length to field width
; Endif
; Set pad character to a space
; Call routine to calculate pad counts
; Call routine to output pre-string pad characters
; Output the string characters
; Call routine to output post-string pad characters
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
; DS:BX - Pointer to argument
; DH - Current field width
; BP - Formatting flags
;
; Registers on Exit:
;
; AL - Destroyed
; BX - Points to next argument
; CX - Destroyed
; DL - Destroyed
; DI - Destroyed
; ES - Destroyed
;
;******************************************************************************
Do_String Proc Near ; String formatting procedure
Save si,ds ; Save the required registers
call Variable ; Call routine to check width/precision
call Get_Address ; Call routine to get argument address
call Get_Length ; Call routine to get string length
jz String_Exit ; Jump if nothing to output
or dh,dh ; Check the current field width
jnz Chk_Width ; Jump if field width specified
mov dh,cl ; Set field width to string length
Chk_Width:
cmp cl,dh ; Compare actual width to given width
jbe Do_Pre ; Jump if string fits in field width
or bp,OVER_FLOW ; Set the field overflow flag
mov cl,dh ; Clip string to the field width
Do_Pre:
mov al,cl ; Save the actual string length
and bp,Not PAD_CHAR ; Set current pad character to a space
call Calculate ; Call routine to calculate pad values
mov dl,al ; Setup the string output length
call Pad ; Call routine to send pad characters
Send_String:
Save ax,bx,cx,dx ; Save the required registers
mov cl,dl ; Get the computed string length
xor ch,ch ; Convert string length to a full word
mov dx,si ; Get pointer to the character string
mov bl,ah ; Get the file handle value
xor bh,bh ; Convert file handle to a full word
mov ah,WRITE_FILE ; Get write file function code
int DOS_FUNCTION ; Try to write the string to the file
Restore ax,bx,cx,dx ; Restore the required registers
Do_Post:
mov cl,ch ; Get the calculated pad counts
call Pad ; Call routine to send pad characters
String_Exit:
Restore si,ds ; Restore the required registers
ret ; Return to the caller
Do_String Endp ; End of the Do_String routine
Page
;******************************************************************************
;
; Routine Functional Description
;
; Do_Hex(Argument, Handle, Width, Precision, Flags, Type)
;
; Save the required registers
; If type is uppercase
; Set the uppercase format flag
; Endif
; Call routine to check for variable width/precision
; Set current number base to hexadecimal
; Call routine to get the argument address
; Call routine to output the numeric string
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
; DS:BX - Pointer to argument
; DH - Current field width
; DL - Current field precision
; BP - Formatting flags
;
; Registers on Exit:
;
; BX - Points to next argument
;
;******************************************************************************
Do_Hex Proc Near ; Hexadecimal formatting procedure
Do_Hex_Upper Label Near ; Do_Hex_Upper entry point (ABCDEF)
or bp,UPPER_CASE ; Set uppercase formatting flag
Do_Hex_Lower Label Near ; Do_Hex_Lower entry point (abcdef)
Save si,ds ; Save the required registers
call Variable ; Call routine to check width/precision
mov ch,BASE_HEX ; Set the current number base to hex
call Get_Address ; Call routine to get argument address
call Compute ; Call routine to output number
Restore si,ds ; Restore the required registers
ret ; Return to the caller
Do_Hex Endp ; End of the Do_Hex routine
Page
;******************************************************************************
;
; Routine Functional Description
;
; Do_Decimal(Argument, Handle, Width, Precision, Flags)
;
; Save the required registers
; Call routine to check for variable width/precision
; Set the signed type formatting flag
; Set current number base to decimal
; Call routine to get the argument address
; Call routine to output the numeric string
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
; DS:BX - Pointer to argument
; DH - Current field width
; DL - Current field precision
; BP - Formatting flags
;
; Registers on Exit:
;
; BX - Points to next argument
;
;******************************************************************************
Do_Decimal Proc Near ; Decimal formatting procedure
Save si,ds ; Save the required registers
call Variable ; Call routine to check width/precision
or bp,SIGNED_TYPE ; Set signed type formatting flag
mov ch,BASE_DECIMAL ; Set current number base to decimal
call Get_Address ; Call routine to get argument address
call Compute ; Call routine to output number
Restore si,ds ; Restore the required registers
ret ; Return to the caller
Do_Decimal Endp ; End of the Do_Decimal routine
Page
;******************************************************************************
;
; Routine Functional Description
;
; Do_Unsigned(Argument, Handle, Width, Precision, Flags)
;
; Save the required registers
; Call routine to check for variable width/precision
; Set current number base to decimal
; Call routine to get the argument address
; Call routine to output the numeric string
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
; DS:BX - Pointer to argument
; DH - Current field width
; DL - Current field precision
; BP - Formatting flags
;
; Registers on Exit:
;
; BX - Points to next argument
;
;******************************************************************************
Do_Unsigned Proc Near ; Unsigned decimal formatting procedure
Save si,ds ; Save the required registers
call Variable ; Call routine to check width/precision
mov ch,BASE_DECIMAL ; Set current number base to decimal
call Get_Address ; Call routine to get argument address
call Compute ; Call routine to output number
Restore si,ds ; Restore the required registers
ret ; Return to the caller
Do_Unsigned Endp ; End of the Do_Unsigned routine
Page
;******************************************************************************
;
; Routine Functional Description
;
; Do_Octal(Argument, Handle, Width, Precision, Flags)
;
; Save the required registers
; Call routine to check for variable width/precision
; Set current number base to octal
; Call routine to get the argument address
; Call routine to output the numeric string
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
; DS:BX - Pointer to argument
; DH - Current field width
; DL - Current field precision
; BP - Formatting flags
;
; Registers on Exit:
;
; BX - Points to next argument
;
;******************************************************************************
Do_Octal Proc Near ; Octal formatting procedure
Save si,ds ; Save the required registers
call Variable ; Call routine to check width/precision
mov ch,BASE_OCTAL ; Set current number base to octal
call Get_Address ; Call routine to get argument address
call Compute ; Call routine to output number
Restore si,ds ; Restore the required registers
ret ; Return to the caller
Do_Octal Endp ; End of the Do_Octal routine
Page
;******************************************************************************
;
; Routine Functional Description
;
; Do_Binary(Argument, Handle, Width, Precision, Flags)
;
; Save the required registers
; Call routine to check for variable width/precision
; Set current number base to binary
; Call routine to get the argument address
; Call routine to output the numeric string
; Retore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
; DS:BX - Pointer to argument
; DH - Current field width
; DL - Current field precision
; BP - Formatting flags
;
; Registers on Exit:
;
; BX - Points to next argument
;
;******************************************************************************
Do_Binary Proc Near ; Binary formatting procedure
Save si,ds ; Save the required registers
call Variable ; Call routine to check width/precision
mov ch,BASE_BINARY ; Set current number base to binary
call Get_Address ; Call routine to get argument address
call Compute ; Call routine to output number
Restore si,ds ; Restore the required registers
ret ; Return to the caller
Do_Binary Endp ; End of the Do_Binary routine
Page
;******************************************************************************
;
; Routine Functional Description
;
; Do_Fractional(Argument, Handle, Width, Precision, Flags)
;
; Save the required registers
; Call routine to check for variable width/precision
; Set the signed type formatting flag
; Set current number base to decimal
; Call routine to get the argument address
; Call routine to output the numeric string
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
; DS:BX - Pointer to argument
; DH - Current field width
; DL - Current field precision
; BP - Formatting flags
;
; Registers on Exit:
;
; BX - Points to next argument
;
;******************************************************************************
Do_Fractional Proc Near ; Fractional formatting procedure
Save si,ds ; Save the required registers
call Variable ; Call routine to check width/precision
or bp,SIGNED_TYPE ; Set signed type formatting flag
or bp,FRACTIONAL ; Set the fractional formatting flag
mov ch,BASE_DECIMAL ; Set current number base to decimal
call Get_Address ; Call routine to get argument address
call Compute ; Call routine to output number
Restore si,ds ; Restore the required registers
ret ; Return to the caller
Do_Fractional Endp ; End of the Do_Fractional routine
Page
;******************************************************************************
;
; Routine Functional Description
;
; Get_Address(Argument, Flags)
;
; Save the required registers
; If immediate specifier has been set
; Set DS:SI to current value of DS:BX
; Increment BX to next argument (1,2,4)
; Else no immediate specifier
; If far format specifier has been set
; Set DS:SI to far pointer at DS:BX
; If indirect format specifier has been set
; Set DS:SI to far pointer at DS:SI
; Endif
; Increment BX to next argument (4)
; Else no far specifier
; Set SI to near pointer at DS:BX
; If indirect format specifier has been set
; Set SI to near pointer at DS:SI
; Endif
; Increment BX to next argument (2)
; Endif
; Endif
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; DS:BX - Pointer to argument list
; BP - Formatting flags
;
; Registers on Exit:
;
; DS:SI - New address pointer (Character or string)
; BX - Points to the next argument
;
;******************************************************************************
Get_Address Proc Near ; Get address procedure
Save ax ; Save the required registers
test bp,IMMEDIATE ; Check for immediate specifier set
jz Check_Specifier ; Jump if no immediate specifier
mov si,bx ; Setup the address into DS:SI
mov ax,NORMAL_SIZE ; Default to normal size argument
Check_Short:
test bp,SHORT_SPEC ; Check for a short immediate argument
jz Check_Long ; Jump if not a short argument
mov ax,SHORT_SIZE ; Setup to short size argument
jmp Short Immediate_Fixup ; Go perform the address fixup
Check_Long:
test bp,LONG_SPEC ; Check for a long immeidate argument
jz Immediate_Fixup ; Jump if not a long argument
mov ax,LONG_SIZE ; Setup to long size argument
Immediate_Fixup:
add bx,ax ; Update the argument pointer value
jmp Short Get_Exit ; Go return control to the caller
Check_Specifier:
test bp,FAR_SPEC ; Check for far specifier set
jz Near_Addr ; Jump if a normal near address
Far_Addr:
lds si,Dword Ptr ds:[bx] ; Load the far address into DS:SI
test bp,INDIRECT ; Check for indirect address
jz Far_Fixup ; Jump if no indirection specified
lds si,Dword Ptr ds:[si] ; Get the indirect far address
Far_Fixup:
add bx,FAR_SIZE ; Update the argument pointer value
jmp Short Get_Exit ; Go return to the caller
Near_Addr:
mov si,Word Ptr ds:[bx] ; Load the near address into SI
test bp,INDIRECT ; Check for indirect address
jz Near_Fixup ; Jump if no indirection specified
mov si,Word Ptr ds:[si] ; Get the indirect near address
Near_Fixup:
add bx,NEAR_SIZE ; Update the argument pointer value
Get_Exit:
Restore ax ; Restore the required registers
ret ; Return to the caller
Get_Address Endp ; End of the Get_Address procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Variable(Width, Precision, Flags)
;
; Save the required registers
; If variable width specified
; Get the actual width value (Byte)
; Endif
; If variable precision specified
; Get the actual precision value (Byte)
; Endif
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; DS:BX - Pointer to argument list
; BP - Formatting flags
;
; Registers on Exit:
;
; DH - Actual width value
; DL - Actual precision value
; BX - Points to the next argument
;
;******************************************************************************
Variable Proc Near ; Get variable width/precision procedure
Save si ; Save the required registers
test bp,VAR_WIDTH ; Check for a variable width value
jz Pre_Chk ; Jump if no variable width
mov si,Word Ptr ds:[bx] ; Load the near address into SI
add bx,NEAR_SIZE ; Update the argument pointer value
mov dh,Byte Ptr ds:[si] ; Get the actual field width value
Pre_Chk:
test bp,VAR_PRE ; Check for a variable precision value
jz Var_Exit ; Jump if no variable precision
mov si,Word Ptr ds:[bx] ; Load the near address into SI
add bx,NEAR_SIZE ; Update the argument pointer value
mov dl,Byte Ptr ds:[si] ; Get the actual precision value
Var_Exit:
Restore si ; Restore the required registers
ret ; Return to the caller
Variable Endp ; End of the Variable procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Get_Length(String)
;
; Calculate the length of the string (Null terminator)
; Return to the caller
;
; Registers on Entry:
;
; DS:SI - Pointer to string
;
; Registers on Exit:
;
; AL - Destroyed
; CX - String length
; DI - Destroyed
; ES - Destroyed
; ZR - Zero set if zero length
;
;******************************************************************************
Get_Length Proc Near ; Get string length procedure
push ds ; Put a copy of DS onto the stack
pop es ; Set ES to the current DS value
mov di,si ; Set DI to the current SI value
mov al,NULL ; Setup to scan for null terminator
mov cx,MAX_WORD ; Setup to scan for maximum length
repne scasb ; Scan for the string terminator
not cx ; Correct the count value
dec cx ; Adjust to get actual string length
ret ; Return to the caller
Get_Length Endp ; End of the Get_Length routine
Page
;******************************************************************************
;
; Routine Functional Description
;
; Calculate(Width, Length)
;
; Save the required registers
; Calculate total pad length
; If total pad length > 0
; If left justification is not requested
; Set pre pad count to total
; Zero post pad count
; Else left justification requested
; Set post pad count to total
; Zero pre pad count
; Endif
; Else total pad length < 0
; Set pre pad count to zero
; Set post pad count to zero
; Endif
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; CL - Length of the string
; DH - Field width
; BP - Formatting flags
;
; Registers on Exit:
;
; CH - Post string pad count
; CL - Pre string pad count
;
;******************************************************************************
Calculate Proc Near ; Calculate pad length procedure
Save ax ; Save the required registers
mov al,dh ; Get the current field width
mov ah,cl ; Get the length of the output string
xor cx,cx ; Default pre/post pad counts to zero
sub al,ah ; Compute the total pad count
jbe Calc_Exit ; Jump if no pad necessary
mov cl,al ; Default to right justification
test bp,LEFT_JUST ; Check if left justify was specified
jz Calc_Exit ; Jump if no left justification
mov ch,cl ; Make post pad count the total count
xor cl,cl ; Zero the pre pad count value
Calc_Exit:
Restore ax ; Restore the required registers
ret ; Return to the caller
Calculate Endp ; End of the Calculate procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Pad(Handle, Pad, Count)
;
; Save the required registers
; While count > 0
; Output the current pad character
; Decrement the count
; Endwhile
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
; CL - Pad count
;
; Registers on Exit:
;
; CL - Destroyed
;
;******************************************************************************
Pad Proc Near ; Pad character procedure
Save ax ; Save the required registers
or cl,cl ; Check for no padding required
jz Pad_Exit ; Jump if no padding is required
mov al,SPACE_PAD ; Default to a space pad character
test bp,PAD_CHAR ; Check for a zero pad character
jz Pad_Loop ; Jump if using a space pad character
mov al,ZERO_PAD ; Setup to use a zero pad character
Pad_Loop:
call Output ; Call routine to output pad character
dec cl ; Decrement the pad count
jnz Pad_Loop ; Jump if more pad characters to send
Pad_Exit:
Restore ax ; Restore the required registers
ret ; Return to the caller
Pad Endp ; End of the Pad procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Clear_Flags(Flags)
;
; Clear the formatting flags
; Default to space padding
; Zero the current field width
; Clear direction flag (All string operations forward)
; Return to the caller
;
; Registers on Entry:
;
; None
;
; Registers on Exit:
;
; BP - Destroyed (BP contains the flags and is zeroed)
; DH - Set to zero (Current field width)
; DL - Set to zero (Current field precision)
;
;******************************************************************************
Clear_Flags Proc Near ; Clear formatting flags procedure
xor bp,bp ; Clear all of the formatting flags
xor dh,dh ; Zero the current field width
xor dl,dl ; Zero the current field precision
cld ; Clear the direction flag
ret ; Return to the caller
Clear_Flags Endp ; End of the Clear_Flags procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Print_Format(Handle)
;
; Save the required registers
; Output format specification character to handle
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
;
; Registers on Exit:
;
; AL - Destroyed
;
;******************************************************************************
Print_Format Proc Near ; Output format specifier procedure
mov al,FORMAT_CHAR ; Get format specifier character
call Output ; Output the format specifier to handle
ret ; Return to the caller
Print_Format Endp ; End of the Print_Format procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Check_Digit(Base, Character)
;
; Save the required registers
; Call routine to convert character to binary
; If the character can be converted
; If value is greater than base
; Set carry flag (Character not a digit)
; Endif
; Else character cannot be converted
; Set carry flag (Character not a digit)
; Endif
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AL - Digit to check (ASCII)
; CH - Number system base
;
; Registers on Exit:
;
; AL - Binary value of digit (If it is a digit)
; FL - CY set if character is not a digit in current base
;
;******************************************************************************
Check_Digit Proc Near ; Check digit procedure
Save bx ; Save the required registers
Save ax ; Save the original digit value
call Convert ; Call routine to convert character
mov bl,al ; Save converted value in BL
Restore ax ; Restore the original digit value
jc Check_Exit ; Jump if could not be converted
cmp bl,ch ; Check against current number base
cmc ; Set correct carry flag state
jc Check_Exit ; Jump if not valid for this base
mov al,bl ; Digit is valid, save binary value
Check_Exit:
Restore bx ; Restore the required registers
ret ; Return to the caller
Check_Digit Endp ; End of the Check_Digit procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Convert(Character)
;
; If character is a decimal digit (0 to 9)
; Convert ASCII digit to binary (Subtract 30h)
; Clear the carry flag (Character could be converted)
; Else character is not a decimal digit
; Convert character to uppercase
; If character is a hex digit (A to F)
; Convert ASCII digit to binary (Subtract 37h)
; Clear carry flag (Character could be converted)
; Else character is not a hex digit
; Set carry flag (Could not be converted)
; Endif
; Endif
; Return to the caller
;
; Registers on Entry:
;
; AL - Digit to check (ASCII)
; CH - Number system base
;
; Registers on Exit:
;
; AL - Binary value of digit (If it is a digit)
; FL - CY set if character is not a digit in current base
;
;******************************************************************************
Convert Proc Near ; Convert character procedure
sub al,DECIMAL_ADJUST ; Adjust character for ASCII decimal
jc Convert_Exit ; Jump if below decimal limit
cmp al,BASE_DECIMAL ; Check for a valid decimal character
cmc ; Set carry flag to correct state
jnc Convert_Exit ; Jump if there is a valid digit
and al,UPPER_MASK ; Convert anything else to uppercase
sub al,HEX_ADJUST ; Adjust character for ASCII hexadecimal
cmp al,BASE_DECIMAL ; Check for a valid hex character
jc Convert_Exit ; Jump if below hexadecimal limit
cmp al,BASE_HEX ; Check against upper hex limit
cmc ; Set carry flag to correct state
Convert_Exit:
ret ; Return to caller with value and flag
Convert Endp ; End of the Convert routine
Page
;******************************************************************************
;
; Routine Functional Description
;
; Output(Character, Handle)
;
; Save the required registers
; Output the character to requested handle
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AL - Character to output
; AH - Handle (For output)
;
; Registers on Exit:
;
; None
;
;******************************************************************************
Output Proc Near ; Output character procedure
Save bx,cx,dx,ds ; Save the required registers
push ss ; Put a copy of SS onto the stack
pop ds ; Setup DS to the current SS value
Save ax ; Save the character and handle values
mov dx,sp ; Setup buffer pointer into stack
xchg al,ah ; Put requested handle into AL
cbw ; Convert handle to full word
mov bx,ax ; Move handle number to BX
mov cx,1 ; Setup to write one character
mov ah,WRITE_FILE ; Get the write file function code
int DOS_FUNCTION ; Attempt to write the character
Restore ax ; Restore the character/handle values
Restore bx,cx,dx,ds ; Restore required registers
ret ; Return to the caller
Output Endp ; End of the Output procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Get_Number(String, Base, Length)
;
; Save the required registers
; While length > 0
; Decrement the length
; Get the next character from string
; Call routine to check for a valid digit
; If character is a valid digit
; Add new value into total
; Endif
; Endwhile
; Decrement pointer back to last character
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; CH - Number Base
; CL - Maximum number length
; DS:SI - Current string pointer
;
; Registers on Exit:
;
; CL - Destroyed
; DL - Number retrieved (Zero if none)
; DS:SI - Pointer to character following number
; FL - CY set if no number was found
; ZR set if zero number found
;
;******************************************************************************
Get_Number Proc Near ; Get number procedure
Save ax,bx ; Save the required registers
mov dl,MAX_BYTE ; Get maximum value for a byte
xor ax,ax ; Initialize the current total
Get_Loop:
mov bx,ax ; Save current total in BX register
lodsb ; Get the next string character
call Check_Digit ; Call routine to check for digit
jc Number_Done ; Jump if this is not a valid digit
inc dl ; Increment no number present flag
cbw ; Convert binary value into full word
xchg ax,bx ; Move total to AX, digit value in BX
mul ch ; Multiply current total by number base
add ax,bx ; Add in the new digit to current total
dec cl ; Decrement the number length count
jnz Get_Loop ; Jump if more digits are allowed
mov bx,ax ; Move the current total into BX
inc si ; Increment to next character
Number_Done:
dec si ; Decrement back to non-digit character
add dl,1 ; Set carry to indicate presence
jc Number_Exit ; Jump if no number was present
mov dl,bl ; Save the computed number in DL
or dl,dl ; Set zero flag for zero result
Number_Exit:
Restore ax,bx ; Restore the required registers
ret ; Return to the caller
Get_Number Endp ; End of the Get_Number procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Compute(Argument, Handle, Width, Precision, Base, Flags)
;
; Save the required registers
; Allocate buffer space on the stack
; If argument value is long
; Get the long numeric value (4 bytes)
; Else if argument value is short
; Get the short numeric value (1 byte)
; Convert short to long value
; Else argument value is normal
; Get the normal numeric value (2 bytes)
; Convert normal to long value
; Endif
; If signed type is specified
; If the value is signed
; Set the signed value flag
; Take the twos complement of the value
; Endif
; Endif
; Zero the fraction value (Integer default)
; If fractional type conversion
; Separate number into integer and fraction
; Endif
; Convert integer to ASCII string in buffer
; If fractional type conversion
; Convert fraction to ASCII string in buffer
; Endif
; Calculate the numeric string length
; Default to no sign character
; If signed type conversion
; If numeric value was signed (Negative)
; Setup minus sign as sign character
; Increment the string length (For sign character)
; Else numeric value was not signed
; If signed conversion was specified
; Setup plus sign as sign character
; Increment the string length
; Endif
; Endif
; Endif
; If field width is not set (Zero)
; Set field width to string length
; Endif
; If string length > field width
; Set the field overflow flag
; Set string length to field width - 1
; Endif
; Call routine to calculate pad counts
; If sign character is present
; If pre-pad sign character
; Output sign character to handle
; Call routine to output pre-string pad characters
; Else post-pad sign character
; Call routine to output pre-string pad characters
; Output sign character to handle
; Endif
; Else sign character is not present
; Call routine to output pre-string pad characters
; Endif
; While length > 0
; Get next character of string
; Call routine to output character to handle
; Decrement the length
; Endwhile
; Set current pad character to a space
; Call routine to output post-string pad characters
; If the field overflow flag is set
; Output the overflow character
; Endif
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AH - Handle
; DS:SI - Pointer to argument
; CH - Current number base
; DH - Current field width
; DL - Current field precision
; BP - Formatting flags
;
; Registers on Exit:
;
; FL - DR flag is cleared (Move Forward)
;
;******************************************************************************
Compute Proc Near ; Output numeric string procedure
Save bx,si,ds ; Save the required registers
;
; Allocate the buffer area on the current stack
;
sub sp,BUFF_SIZE ; Allocate buffer space on the stack
mov di,sp ; Setup the buffer pointer
add di,BUFF_SIZE/2 ; Set the starting buffer position
push ax ; Save the output handle value
push dx ; Save the field width/precision
xor dh,dh ; Convert precision to a full word
push dx ; Save the field precision
mov cl,ch ; Move current base value into CL
xor ch,ch ; Make current base value into a word
xor ax,ax ; Default to an unsigned
xor dx,dx ; non-long value
test bp,SHORT_SPEC ; Check for short value specified
jnz Get_Short ; Jump if short value specified
test bp,LONG_SPEC ; Check for long value specified
jnz Get_Long ; Jump if long value specified
mov ax,ds:[si] ; Get the normal value (2 Bytes)
test bp,SIGNED_TYPE ; Check for a signed conversion
jz Chk_Frac ; Jump if not a signed conversion
cwd ; Signed conversion, do sign extension
jmp Short Chk_Sign ; Go check for signed argument
Get_Short:
mov al,ds:[si] ; Get the short value (1 Byte)
test bp,SIGNED_TYPE ; Check for a signed conversion
jz Chk_Frac ; Jump if not a signed conversion
cbw ; Signed conversion,
cwd ; do sign extension
jmp Short Chk_Sign ; Go check for signed argument
Get_Long:
mov ax,ds:[si] ; Get the
mov dx,ds:[si + 2] ; long value (4 Bytes)
;
; If a signed type and a signed number, take the twos complement
;
Chk_Sign:
test bp,SIGNED_TYPE ; Check for a signed type
jz Chk_Frac ; Jump if not signed
test dx,SIGNED ; Check the number for signed
jz Chk_Frac ; Jump if number is not signed
or bp,SIGNED_VAL ; Set the signed value flag
not ax ; Ones complement of the LSW
not dx ; Ones complement of the MSW
add ax,1 ; Twos complement of the LSW
adc dx,0 ; Twos complement of the MSW
;
; If a fractional type, separate the integer and the fraction
;
Chk_Frac:
mov si,ss ; Get the current stack segment
mov ds,si ; Setup DS to current stack segment
mov es,si ; Setup ES to current stack segment
xor bx,bx ; Zero fraction value (Integer default)
test bp,FRACTIONAL ; Check for fractional conversion
jz Do_Integer ; Jump if standard integer conversion
test bp,SHORT_SPEC ; Check for short value specified
jnz Do_Short ; Jump if a short fractional value
test bp,LONG_SPEC ; Check for long value specified
jnz Do_Long ; Jump if a long fractional value
mov bh,al ; Move fraction value to MSB (BH)
xor bl,bl ; Zero the lower LSB of fraction (BL)
mov al,ah ; Move integer value to LSB (AL)
xor ah,ah ; Zero the upper MSB of integer (AH)
xor dx,dx ; Zero the upper MSW of integer (DX)
jmp Short Do_Integer ; Go convert the integer portion
Do_Long:
mov bx,ax ; Move fraction value to BX
mov ax,dx ; Move integer value to LSW (AX)
xor dx,dx ; Zero the upper MSW of integer (DX)
jmp Short Do_Integer ; Go convert the integer portion
Do_Short:
mov bh,al ; Move fraction value to MSB (BH)
xor bl,bl ; Zero the lower LSB of fraction (BL)
xor ax,ax ; Zero the lower LSW of integer (AX)
xor dx,dx ; Zero the upper MSW of integer (DX)
;
; Convert the integer to ASCII and store in the buffer
;
Do_Integer:
push di ; Save the starting position
cld ; Clear direction flag (Move forward)
Integer_Loop:
mov si,ax ; Save LSW of value in SI register
mov ax,dx ; Move MSW of value into AX
xor dx,dx ; Setup to do the first divide
div cx ; Divide the MSW by the current base
xchg ax,si ; Setup for the second division
div cx ; Divide the result by the current base
xchg ax,dx ; Put the remainder into AX
call Digit ; Call routine to convert it to a digit
stosb ; Store the ASCII digit into buffer
xchg ax,dx ; Restore quotient of second division
mov dx,si ; Restore quotient of first division
or si,ax ; Check for a zero result
jnz Integer_Loop ; Jump if more digits to get
;
; Convert the fraction (If any) to ASCII and store in the buffer
;
Do_Fraction:
pop dx ; Restore the starting position
pop si ; Restore the field precision
mov ax,bx ; Get the fraction value into AX
mov bx,di ; Save the final position in BX
mov di,dx ; Get the starting position
test bp,FRACTIONAL ; Check for fractional conversion
jz Calc_Length ; Jump if standard integer conversion
pop dx ; Restore the field width/precision
push dx ; Save the field width/precision
or dh,dh ; Check for a zero field width value
jnz Set_Position ; Jump if field width was given
mov dx,bx ; Get the final position value
sub dx,di ; Compute the actual string length
dec dx ; Check for a single digit
jnz Set_Position ; Jump if more than a single digit
cmp Byte Ptr es:[di],ZERO_PAD
jne Set_Position ; Jump if single digit is NOT a zero
test bp,PAD_CHAR ; Check for zero character pad
jz Set_Direction ; Jump if a blank character pad
Set_Position:
dec di ; Decrement to get new start position
Set_Direction:
std ; Set direction flag (Move Backward)
mov Byte Ptr es:[di],POINT ; Put a decimal point into buffer
or si,si ; Check for zero precision
jz Calc_Length ; Jump if no digits to compute
dec di ; Update pointer for decimal point
Fraction_Loop:
mul cx ; Multiply by the current base
xchg ax,dx ; Put the MSW of result into AX
call Digit ; Call routine to convert it to a digit
stosb ; Store the ASCII digit into buffer
xchg ax,dx ; Restore fraction from multiply
dec si ; Decrement the precision count
jnz Fraction_Loop ; Jump if more digits left to do
inc di ; Correct for length calculation
Do_Round:
mul cx ; Compute the next actual digit
shl dx,1 ; Multiply digit value by two
cmp dx,cx ; Compare value to current base
jb Calc_Length ; Jump if below current base value
push di ; Save the current position
mov ch,cl ; Move current base to CH
Round_Loop:
mov al,es:[di] ; Get the digit to round
call Convert ; Convert the ASCII to binary
inc al ; Round the digit up
mov ah,al ; Save the rounded value in AH
call Digit ; Convert the binary digit to ASCII
cmp ah,ch ; Check the value against current base
jb Round_Done ; Jump if rounding is complete
xor al,al ; Zero the AL register value
call Digit ; Convert to an ASCII zero value
mov es:[di],al ; Zero the current digit value
inc di ; Increment to the next digit position
cmp di,bx ; Check against final position
jbe Round_Loop ; Jump if more digits to round with
mov bx,di ; Update the new final position
xor al,al ; Zero the AL register value
inc al ; Increment AL to a one value
call Digit ; Convert the one value to ASCII
Round_Done:
mov es:[di],al ; Save the last rounded digit
pop di ; Restore the current position
;
; Calculate the length of the numeric ASCII string
;
Calc_Length:
pop dx ; Restore field width/precision
pop ax ; Restore the file handle
mov cx,bx ; Get the final buffer pointer
sub cx,di ; Compute the numeric string length
;
; Determine whether or not a sign character is needed for the value
;
xor al,al ; Default to no sign character
test bp,SIGNED_TYPE ; Check for signed type
jz Do_Check ; Jump if not a signed type
test bp,SIGNED_VAL ; Check for a signed value
jz Chk_Conv ; Jump if not a signed value
mov al,MINUS ; Setup minus as sign character
inc cx ; Increment the string length
jmp Short Do_Check ; Go check the field width
Chk_Conv:
test bp,SIGNED_CONV ; Check for a signed conversion
jz Do_Check ; Jump if not a signed type
mov al,PLUS ; Setup plus as sign character
inc cx ; Increment the string length
;
; Setup the correct field width based on string length
;
Do_Check:
or dh,dh ; Check the current field width
jnz Width_Check ; Jump if field width specified
mov dh,cl ; Set field width to string length
Width_Check:
cmp cl,dh ; Check actual width to field width
jbe Do_Calc ; Jump if string fits in the field
or bp,OVER_FLOW ; Set the field overflow flag
mov cl,dh ; Set string width to field width
dec cl ; Adjust for the overflow character
jz Compute_Exit ; Jump if no more room in the field
;
; Calculate the pad counts and handle outputting a sign if necessary
;
Do_Calc:
push ax ; Save the sign character (If any)
mov al,cl ; Save the actual string length
call Calculate ; Call routine to calculate pad values
mov dl,al ; Setup the string output length
pop ax ; Restore the sign character (If any)
test bp,PRE_PAD ; Check for pre pad sign character
jz Do_Pad ; Jump if not pre pad sign character
or al,al ; Check for a sign needed
jz Do_Pad ; Jump if no sign is needed
call Output ; Call routine to output sign character
dec dl ; Decrement the output count
jz Compute_Exit ; Jump if no more room in field
Do_Pad:
call Pad ; Call routine to output pad characters
test bp,PRE_PAD ; Check for post pad sign character
jnz Do_Setup ; Jump if not post pad sign character
or al,al ; Check for a sign needed
jz Do_Setup ; Jump if no sign character needed
call Output ; Call routine to output the sign
dec dl ; Decrement the output count
jz Compute_Exit ; Jump if no more room in field
Do_Setup:
mov si,bx ; Setup the source pointer to buffer
dec si ; Point back to first character
std ; Set direction flag (Reverse order)
;
; Send the string characters to the output handle
;
Send_Loop:
lodsb ; Get the next character to output
call Output ; Call routine to output character
dec dl ; Decrement the output count
jnz Send_Loop ; Jump if more characters to output
mov cl,ch ; Get the calculated pad counts
;
; Change pad character, output pad characters and deallocate buffer
;
and bp,Not PAD_CHAR ; Set pad character to a space
call Pad ; Call routine to send pad characters
;
; Restore the registers and return to the caller
;
Compute_Exit:
test bp,OVER_FLOW ; Check for field overflow
jz Compute_Done ; Jump if no field overflow
mov al,ASTERISK ; Get the field overflow character (*)
call Output ; Output the field overflow character
Compute_Done:
add sp,BUFF_SIZE ; Deallocate the buffer area
Restore bx,si,ds ; Restore the required registers
cld ; Clear the direction flag
ret ; Return to the caller
Compute Endp ; End of the Compute procedure
Page
;******************************************************************************
;
; Routine Functional Description
;
; Digit(Value, Flags)
;
; Save the required registers
; Translate character to ASCII value
; If uppercase flag is set
; If ASCII value is not a digit (abcdef)
; Convert to uppercase (ABCDEF)
; Endif
; Endif
; Restore the required registers
; Return to the caller
;
; Registers on Entry:
;
; AL - Binary value (0 - 15)
;
; Registers on Exit:
;
; AL - ASCII character
;
;******************************************************************************
Digit Proc Near ; Convert to ASCII digit procedure
Save bx ; Save the required registers
lea bx,cs:[Digit_Table] ; Get pointer to digit translate table
xlat byte ptr cs:[bx] ; Translate to ASCII digit
test bp,UPPER_CASE ; Check for uppercase flag
jz Digit_Exit ; Jump if no uppercase flag set
cmp al,DIGIT_MAX ; Check for uppercase adjust needed
jbe Digit_Exit ; Jump if adjustment not needed
and al,UPPER_MASK ; Convert character to uppercase
Digit_Exit:
Restore bx ; Restore the required registers
ret ; Return to the caller
Digit Endp ; End of the Digit procedure
;
; Define the ASCII digit translation table
;
Digit_Table Label Byte ; Digit translation table
Db "0123456789abcdef"
;
; Define the end of the standard code segment
;
Code Ends ; End of the standard code segment
End ; End of the Printf module

أنا أنسحب انسحاب المخذول عن هذه الفكرة ، لقد صنع الحاسوب لنستفيد منه لا ليستفيد منا

أتعجب لصاحب هذا العقل وهو يبرمج الدالة printf

[Khaled Alshaya 825]

هناك أمران, الأمر الأول نعم يمكن أن تستغني عن المكتبات القياسية بسهولة, أما مكتبات الدعم وقت التشغيل فهي أمر آخر. بمعنى أن برنامجك أصبح لا يعتمد على أي شيء إطلاقاً كأنه skeleton exe. طرحت الموضوع منذ فترة و كانت تجربة لإنتاج ملفات تنفيذية بأصغر حجم ممكن.

[ahmed.o.mohamed 931]

أخي حمزه, أرجو أن لا تسحب السؤال حتى لا تُفسد علينا كعكعة العشر نقاط :D

عموما, أرى أن الهدف من سؤلك متعب بعض الشيئ لأن كل لغة تكمن قوتها في مكتباتها الرئيسية و إذا قررنا الإستغناء عن هذه الأخيرة فسنحتاج إلى كتابة دوال المكتبات القياسية من جديد و أظن أن هذا الأمر سيكون مُزعجا جداً ( أو على الأقل بالنسبة لي :happy: )

[khatibe_30 64]

لا تريد استعمال المكتبات؟ يعني يا حمزة ارجع برمج بـ asm16 و خلاص :lol:

و كأنك اشتريت شاحنة حتى تروح بيها للمدرسة :blink: , اشتري دراجة تكفي :happy:

[The Hidden Ghost 69]

لن يغلق الموضوع حتى نجد إجابة شافية ، و إن كان الحل هو الرجوع إلى عصور ما قبل

التاريخ (أسمبلي16 بت) فسنبني آلة للرجوع إلى ذلك الزمن المغري جدا

[Mr.B 667]

البرنامج الذي وضعته لو جردته من كل شيء سيبدو :

Output          Proc    Near            ; Output character procedure
        Save    bx,cx,dx,ds             ; Save the required registers
        push    ss                      ; Put a copy of SS onto the stack
        pop     ds                      ; Setup DS to the current SS value
        Save    ax                      ; Save the character and handle values
        mov     dx,sp                   ; Setup buffer pointer into stack
        xchg    al,ah                   ; Put requested handle into AL
        cbw                             ; Convert handle to full word
        mov     bx,ax                   ; Move handle number to BX
        mov     cx,1                    ; Setup to write one character
        mov     ah,WRITE_FILE           ; Get the write file function code
        int     DOS_FUNCTION            ; Attempt to write the character        ; DOS_FUNCTION    Equ     21h  ; MS-DOS function request interrupt
        Restore ax                      ; Restore the character/handle values
        Restore bx,cx,dx,ds             ; Restore required registers
        ret                             ; Return to the caller
Output          Endp                    ; End of the Output procedure
        Page

كما ترى يستدعي المُقاطعة 0x21 والباقي وظيفتة معالجة تنسيق الطباعة مثل :

%d, %s, %.8x, %u

الأسمبلي ليست شيء خارق, فأكثر من 95% من الأشياء التي تستطيع عملها بالأسمبلي تستطيع عملها بالـC/C++.

المكتبة القياسية لاتقوم بشيء بنفسها بل "تُغلف" الدوال التي يُوفرها النظام , سواء كان ويندوز أو لينكس أو غيره, لتنتج دوال تأخذ نفس المُدخلات وتعيد نفس المخرجات على كل الأنظمة :

Windows:
void standard_function(void)
{
    windows_function();
}

Linux:
void standard_function(void)
{
    linux_function();
}

في الأنظمة الحديثة هناك طبقتين في النظام , طبقة المستخدم وطبقة النواة ولايُمكن للمُستخدم القيام بشيء إلا عن طريق قنوات تُوفرها النواة تُسمى "خدمات, مقاطعات, إستدعاءات نظام , وكل يعطي إسم" :

+------------------+
|   طبقة المُستخدم  |
+------------------+
      | <-- قنوات بينهما
+------------------+
|    طبقة النواة   |
+------------------+
       |
+------------------+
|     العتاد       |
+------------------+

لأسباب أمنية ولفرض سيطرت النواة , لو أراد المستخدم مثلاً قراءة ملف لمسخدم آخر لم يسمح له فستمنعه النواة. ولايُمكنك عمل شيء بغير تلك القنوات, فلايوجد طريق جانبي.

في لينكس, تلك القنواة تُسمى إستدعات النظام وعددها يُقارب الـ200 إستدعاء وتقوم بوظائف عامة : طباعة نص, فتح ملف, الكتابة في ملف. مثلاً puts ستبدو مثل (الأمور أكثر تعقيد في الواقع) :

#include <sys/syscall.h>
#include <string.h>

unsigned int my_print(char *buffer)

int main(int argc, char **argv)
{
    my_print("Hello there!\n");
    return 0;
}

unsigned int my_print(char *buffer)
{
    return (unsigned int) syscall(SYS_write, 1, buffer, strlen(buffer));   /* 1 = stdout */
}

ويندوز كثير من تفاصيلة الداخلية غير موثقة وأقرب طبقة موثقة هي واجهة ويندوز البرمجية Windows API, ودوال المكتبة القياسية تُغلف تلك الدوال. يُمكنك الإستغناء عنها وإستخدام دوال النظام مباشرة :

#include <windows.h>
#include <string.h>

unsigned int my_print(char *buffer);

int main(int argc, char **argv)
{
    my_print("Hello there!\n");
    return 0;
}

unsigned int my_print(char *buffer)
{
    HANDLE stdout;
    DWORD dwNumberOfBytesWritten;

    stdout = GetStdHandle(STD_OUTPUT_HANDLE);

    if( stdout == NULL || stdout == INVALID_HANDLE_VALUE )
        return 0;

    WriteFile(stdout, (void *)buffer, strlen(buffer), &dwNumberOfBytesWritten, NULL);

    return (unsigned int) dwNumberOfBytesWritten;
}

[The Hidden Ghost 69]

لكنك اعتمدت على مكتبة الويندوز أخي ، windows.h

[مصطفى 36a2 639]

رغم أن الموضوع قديم .. ولكنه من أجمل المواضيع في القسم ورد الأخ Mr.B من أكثر الردود روعة ..

هناك حل طالما أنك منزعج فقط من #include فالمصرّف gcc يملك كل المكتبة القياسية بداخله Built in

يعني بإمكانك استخدام الدوال كلّها (القياسية) دون #include واحدة :)