عاجل جدا وضروري للمبرمجين

اخي تالا إن فكرة عمل الكمبايلر الشائعة لأي لغة برمجة مكونة من 7 مراحل كل مرحلة لها خصائصها وميزاتها ووظيفتها في الكمبايلر اما في هذه المرحاة فهي المرحلة الأولى وهي اسهل مرحلة تقريبا والمراحل الأخرى هي

lexical analysis

syntactical analysis

semantical analysis

intermedat cod

optmization intermediat code

generation of machine code

optmization of machine code

اما المرحلة الاولى فهي مختصة في المرحلة الأولى من فلترة الحروف

والمدخلات لهذه المرحلة هو عبارة عن مجموعة او مصفوفة من الحروف والمخرج لهذه المرحلة هو مجموعة من التوكنس المدخل في هذه المرحلة يتم فحصه من خلال هذه المرحلة لكي يتم تصنيف هذه المجموعة من الحروف على اساس انها كلمات تكون محجوزة في لغة البرمجة المراد عملها مثلا لو كان لديك الجملة التالية

if a< sum then sum :=x+1.2

فتفصل هذه الجملة كالتالي

if key word if

a identifire

< rel op lt

يعني تصنف كل جزءمن الجملة على حدا وتصنف بمعناها

ومن الوظائف الأساسية لهذه المرحلة هي

تصنيف الحروف على انها مجموعة من التوكنس

وضع المتغيرات في جدول يسمى symbol table

اعضاء الأخطاء لانها مسؤوله عن التصنيف ولو كان هنا خطا في احدى الكلمات يعطي الخطأ .

يعطى خطأ عندما تدمج اكثر من توكن واحدة مع بعضها البعض

واعطاء الخطأ عندما يكون هنا كخطأ بالمتغير مثلا انك تعطي اسم المغتير في بدايته رقم

هذا ما لدي الآن اذا فهمت الذي اعطيتك ياه واكتفيت فيعطيك العافية واذا لم تكتفي سو اشرح لك بالتفصيل الممل وبالمناسبة لدي كود كمبايلر معمول بالباسكال وليس 100 % كاملا لكن يمكنني إعطائك ياه واعطائك كود اخر بلغة الدلفي .

انظر

/index.php?showtopic=44594

/index.php?showtopic=40937

/index.php?showtopic=41514

/index.php?showtopic=40492

شكرا لكم اخواني والله ما قصرتوا إن شاء الله بشوف links

وارد عليكم بعد ما اطلع عليها

السلام عليكم

حبيت اسجل اعجابي بشرح الاخ الكريم teremanator1 ياسلام وليه ماتكمل ترى مواضيع المترجمات من الدروس الرائعة والحمدلله خلصت مادة في الجامعة وباقيلي وحدة وان شاء الله نخلصها .

بالنسبة للاخت يمكن ان اساعدكي فقط اعطيني الكلمات المحجوزة للغة التي تكتبين والتوكن لكل كلمة واكتب لك المحلل المفراتي. بس بشرط الوقت يسعفني

مع السلامه.

التوكن هي:

keyword: if, else, then

identefire

number

ومشكورين على المساعدة

بالاضافة للتوكن اللي ذكرتها بعد في:

relation operation(relop)

يعني التوكن تصير:

keyword: if, else, then

identefire

number

relop

الاخ teremanator1

شكرا على المساعدة واستفدت من الشرح

لكن المطلوب في البرنامج هو استخدام مخططات الانتقالtransmision graph

TG

والدكتور اعطانا اكواد مساعدة ممكن ارفقها..

بالنسبة للكود اللي بلغة الباسكال فانا ما عندي اي خلفية عن هذي اللغة وحتى لغة الدلفي...

هل من الممكن التوضيح اكثر عن transmision graph ممكن انا بفهمها بشكل اخر.

السلام عليكم اخوي terminator

الTG هي عبارة عن الة شبيهة ب FINITE ATOUMITA

لكن مدخلاتها تكون STRING وليست حروف

حتى انا مو متمكنة منها لكن الدكتور شارطها بالحل

السلام عليكم

هذا كودبعض منه وليس كله فقط به المحلل المفرداتي وبعض الدوال المهمه حاولي الاستفاده منه فهو شبيه الى حد ما بما تريدينه واذا من مشاكل ممكن ارد عليكيولكن بعد يوم الاربعاء لانيمشغول.

للامانة العلمية المحلل المفرداتي كتبه الدكتور عندما كنا ندرس مادة الcompiler .

#include <stdio.h>
#include <string.h>
#include <ctype.h>


//ÈÑäÇãÌ ÇáãÊÑÌã


//ÇáÇÚáÇä Úä ÇáßáãÇÊ  ááÛÉ ÇáãÕÏÑ æÇáÊæßä ÇáÎÇÕ ÈåÇ

#define NUM  256  // ÇáÇÚÏÇÏ æÇáÊæßä ÇáÎÇÕ ÈåÇå
#define DIV  257  // ÇáÇÓãÇÁ  æÇáÊæßä ÇáÎÇÕ ÈåÇ
#define MOD  258  // äåÇíÉ ÇáãáÝ æÇáÊæßä ÇáÎÇÕ ÈåÇ
#define ID  259  // ÇáßáãÉ ÇáãÍÌæÒÉ div æÇáÊæßä ÇáÎÇÕ ÈåÇ
#define DONE 260  // ÇáßáãÉ ÇáãÍÌæÒÉ mod æÇáÊæßä ÇáÎÇÕ ÈåÇ

#define SYMMAX 100  // ÚÏÏ ÇáÑããæÒ Çáããßä Ãä ÊÍÊæí ÚáíåÇ ãÕÝæÝÉ ÇáÑãæÒ
#define STRMAX 999  // ÇáÍÏ ÇáÃÞÕì áãÕÝæÝÉ ÇáÍÑæÝ lexemes[]

#define BSIZE 128   
#define NONE  -1
#define EOS '\0'    // äåÇíÉ ÇáÓáÓáÉ ÇáÍÑÝíÉ


int lastentery = 0; // ãÊÛíÑ íÍÊæí Úáì ÑÞã ÃÎÑ ÚäÕÑ Êã ÇÖÇÝÊå áãÕÝæÝÉ ÇáÑãæÒ
int lineno = 1; 	 // ãÊÛíÑ íÍÊæí Úáì ÑÞã ÇáÓØÑ ÇáÐí äÞÑÃå ãä ÇáãáÝ
int tokenval = NONE;  // ãÊÛíÑ íÍÊæí Úáì ÞíãÉ ÇáÚÏÏ Ãæ Ïáíá ãÕÝæÝÉ ÇáÑãæÒ
int lastchar = -1;  // ãÊÛíÑ íÍÊæí Úáì ÑÞã ÇáÍÑÝ ÇáÐí äÞÑÃå ãä ãÕÝæÝÉ ÇáÍÑæÝ lexemes[]

char lexemes[STRMAX];   // ãÕÝæÝÉ ÇáÍÑæÝ
char lexbuf[BSIZE];     // ãÕÝæÝÉ ãÄÞÊÉ ÊÓÊÎÏã ÏÇÎá ÏÇáÉ ÇáãÍáá ÇáãÝÑÏÇÊí


/* ÇáÇÚáÇä Úä ÇáÓÌá ÇáÎÇÕ ÈÇáßáãÇÊ ÇáãÍÌæÒÉ */

struct entry
{
	char * lexptr; //ãÄÔÑ  Åáì ÇáäÕ ÇáÐí äÞÑÃå ãä ÇáãÓÊÎÏã
	int token;     // ÇáÊæßä ÇáÎÇÕ Èßá ßáãÉ äÞÑÃåÇ
};

struct entry Symtable[SYMMAX];  // ÇáÇÚáä Úä ãÕÝæÝÉ ÇáÑãæÒ


// ÇáÇÚáÇä Úä ãÕÝæÝÉ ÇáßáãÇÊ ÇáãÍÌæÒÉ ááÛÉ ÇáãÕÏÑ
struct entry keyword[] = 
{
	"div",DIV,
	"mod",MOD,
	0,0
};


/********************* ÇáÇÚáÇä Úä ÇáÏæÇá ÇáãÓÊÎÏãÉ Ýí ÇáÈÑäÇãÌ************/


// ÏÇáÉ ÇáÈÍË Úä  ÇáßáãÉ åá åí ãæÌæÏÉ Ýí ãÕÝæÝÉ ÇáÑãæÒ
int Lookup( char * S );

//ÏÇáÉ ÇáÇÖÇÝÉ ÇáßáãÉ Ýí ãÕÝæÝÉ ÇáÑãæÒ
int Insert( char * S, int tok );

//ÏÇáÉ ØÈÇÚÉ ÑÓÇáÉ Úä ÇáÎØÃ
void error(char * M);

// ÏÇáÉ ÇáãÍáá ÇáãÝÑÏÇÊí
int lexen();

//ÏÇáÉ ÇÏÎÇá ÇáßáãÇÊ ÇáãÍÌæÒÉ Ýí ãÕÝæÝÉ ÇáÑãæÒ
void init();

/***********************************************************************/




int main()
{

	init();


	return 0;
}


// ÏÇáÉ ÇáÈÍË Úä  ÇáßáãÉ åá åí ãæÌæÏÉ Ýí ãÕÝæÝÉ ÇáÑãæÒ

int Lookup( char * S )
{
	int i;

	for( i=lastentery; i>0; i-- )
	{
  if( strcmp( Symtable.lexptr,S ) == 0 )
 	 return i;
	}

	return 0;
}


//ÏÇáÉ ÇáÇÖÇÝÉ ÇáßáãÉ Ýí ãÕÝæÝÉ ÇáÑãæÒ
int Insert( char * S, int tok )
{
	int len;

	len = strlen(S);

	if( lastentery >= SYMMAX )
  error("Symbol table Full");

	if( lastchar >= STRMAX )
  error("Lexems Array Full");

	lastentery ++;

	Symtable[lastentery].token = tok;

	Symtable[lastentery].lexptr = & lexemes[lastchar++];

	lastchar = lastchar + len + 1;


	//Þã ÈäÓÎ ãÍÊæíÇÊ ÇáÓáÓÉ S Çáì ãÕÝæÝÉ ÇáÍÑæÝ lexemes[]
	strcpy(Symtable[lastentery].lexptr,S);   // strcpy(lexemes[lastchar],S);

	return  lastentery;

}


//ÏÇáÉ ØÈÇÚÉ ÑÓÇáÉ Úä ÇáÎØÃ
void error(char * M)
{
	printf("%s",M);
}


// ÏÇáÉ ÇáãÍáá ÇáãÝÑÏÇÊí
int lexen()
{
	int  t;

	while(1)
	{
  t = getchar();
  
  if( t == ' ' || t == '\t' );  /*if( t == 32 || t == '\t' );*/ 
  else if( t == '\n' )
 	 lineno++;
  else if( isdigit(t) )
  {
 	 //ÊÊã ÞÑÇÁÉ æÍÏÉ ÚÏÏ åäÇ
 	 ungetc(t,stdin);
 	 scanf("%d",&tokenval);
 	 return  NUM;
  }
  else if( isalpha(t) )
  {
 	 //ÊÊã ÞÑÇÁÉ æÍÏÉ äÕ ÊÔãá ÃÍÑÝ æà ÚÏÇÏ
 	 int p,b=0;
 	 while( isalnum(t) )
 	 {
    lexbuf = t;
    t = getchar();
    b ++;

    if( b>= BSIZE )
   	 error("error: Lexbuf is Full");
    
 	 }

 	 lexbuf = EOS;

 	 if( t != EOF )
    ungetc(t,stdin);

 	 p = Lookup(lexbuf);

 	 if( p == 0 )
    p = Insert(lexbuf,ID);
 	 
 	 tokenval = p;

 	 return  Symtable[p].token;

  }
  else if( t == EOF )
 	 return  DONE;
  else
  {
 	 tokenval = NONE;
 	 return  t;
  }
	}

}


//ÏÇáÉ ÇÏÎÇá ÇáßáãÇÊ ÇáãÍÌæÒÉ Ýí ãÕÝæÝÉ ÇáÑãæÒ
void init()
{
	struct entry * p;

	for( p = keyword; p->token != 0; p-- )
  Insert( p->lexptr,p->token );

}

ذي البرنامج بدون التعليقات وادرسيه جيدا صدقيني ينفعكي ان شاء الله.

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

اختي كنت قد كتبت هذا البرنامج عندما كانت مقررة على مادة compilar بالجامعة .. فتشت عنه بين برامجي .. وها هو بين يديك .. اتمني ان تستفيدي منه ..

وهو يعتمد TG لبناءة ..ولكنه مكتوب بلغة ال C اترك لكي مهمة التحويل ..

انشئي ملفين أحدهما سميه symbol.txt وهنا سيعمل هذا الملف عمل ال Symbol table

كما عليكي انشاء ملف أخر سميه prog.txt وهنا تقومين بكتابة البرنامج الذي تريدين من ال lexecal ان يقوم بفلترته ..

واليك الكود الخاص ببرنامج ال lexecal

#include<stdio.h>
#include<string.h>
 const size=50;
 typedef char* Token;
 typedef struct Symbol_Struct
 {   int   ref;
     char *lexeme;
     char *token;
     char *attribute;
 }symbol_struct;
 typedef struct x
 {
     char lexeme[10];
 }x;
  x st[20];
 FILE *prog_file;
 FILE *symbol_file;
 char buffer[2*50];   // the size if buffer must be 1024 but i put this small size to test the program
 char stmt[200];
 char current_lexeme[10];
 int lexeme_beginning =0,forward =0;
 int start=0,state=0;
 int loc;
 int ref=4;
 int token_ref=0;
 int fst,snd,ptr=0;

/////////////////////   To check if the file is found  //////////////////////
 int check_file(FILE *file)
{
    if (file==NULL)
    {
       printf("\n---------------------------------------------------");
       printf("\n\n     file not found \n");
       printf("\n  Press any key to continue : ");
       getch();
       printf("\n---------------------------------------------------");

       fclose(file);
       return(0);  //means that the file is not found
    }
    fclose(file);
    return(1); //means that the file is found
}


//////////////////       Input data to file  ////////////////////////////
void Input(FILE *file)
{
    int n;
    char ch;


    file = fopen("a:\prog.txt","w");
    printf("\n\n\n\n---------------------------------------------------");
    printf("\n Enter the if statment  and put '$' at hte end\n ");
    printf("\n The statement : \n");
    ch=getchar();
    for(n=0;ch!='$';n++)
    {
       stmt[n] = ch;
       ch=getchar();
    }
    printf("\n---------------------------------------------------");
    stmt[n]='\0'; // the end of the statement in the buffer
    fprintf(file,"%s",stmt);
    fclose(file);
}


/////////////////////////////////////////////////////////////////////////////
//                          two pair buffer
/////////////////////////////////////////////////////////////////////////////
void reload_1st_buffer()
{
     fst=1;
     snd=0;
}
/////////////////////////////////////////////////////////////////////////////
void reload_2nd_buffer()
{    fst=0;
     snd=1;
}
/////////////////////////////////////////////////////////////////////////////
void check_buffer()
{
    if(forward+1==size)
    {
       reload_2nd_buffer();
       forward=forward+1;
    }
    else if (forward+1==(2*size))
    {
       reload_1st_buffer();
       forward=0;
    }
    else
       forward=forward+1;
}
/////////////////////////////////////////////////////////////////////////////
//                         read acontent of existing file
/////////////////////////////////////////////////////////////////////////////
void content(FILE *file)
{   char ch;
    int i=0;
    file= fopen("a:\prog.txt","r");
    rewind(file);     // to put the carsor at the beggining of the file
    fscanf(file,"%c",&ch);
    while(!feof(file))
    {
       //	printf("%c",ch);
	stmt=ch;
	fscanf(file,"%c",&ch);
	i++;
    }
    stmt='\0';
    fclose(file);
}
/////////////////////////////////////////////////////////////////////////////
//                             read to buffer
/////////////////////////////////////////////////////////////////////////////
void read()
{    int e;
    int end=forward,begin=lexeme_beginning;
    ptr=0;
    while(end+1!=begin && stmt[ptr]!='\0')
    {
       buffer[end]=stmt[ptr];
       ptr++;
       check_buffer();
       end=forward;

    }
    /*if((end+1)==(2*size))
       e=0;

    if((stmt[ptr]=='\0')&&(e!=lexeme_beginning))
       buffer1[end]='\0';   */

}
/////////////////////////////////////////////////////////////////////////////
//                   search for existing token
/////////////////////////////////////////////////////////////////////////////
int search(char* lexeme)
{
    int i=0,n=loc,cmp,found=0;

    if(loc==0)
    {  found=0;
       return(found);
    }
    else
    {
       for(i=0;i<n;i++)
       {
   cmp=strcmp(st.lexeme,lexeme);
   if(cmp==0)
    {   found=1;
        token_ref=i+5;
        break;
    }
       }
    }
       return(found);
}
/////////////////////////////////////////////////////////////////////////////
//                                  error masseges
/////////////////////////////////////////////////////////////////////////////
void error()
{
    printf("\n\n\n---------------------------------------------------");
    if (buffer[forward]=='\0')
       printf("\n  The Lexical analyser reached end of file  ");
    else
       printf("\n  Error in this token ");

    printf("\n Lexecal will terminate  ");

    getch();
    exit();
}
/////////////////////////////////////////////////////////////////////////////
//                          next char function
/////////////////////////////////////////////////////////////////////////////
char nextchar()
{
    char next_char;

    next_char = buffer[forward];
    check_buffer();
    return(next_char);
}
/////////////////////////////////////////////////////////////////////////////
//                           is letter function
/////////////////////////////////////////////////////////////////////////////
int isletter(char ch)
{
    if (isalpha(ch))
       return(1);
    else
       return(0);
}
/////////////////////////////////////////////////////////////////////////////
//                             is digit function
/////////////////////////////////////////////////////////////////////////////
int Isdigit(char ch)
{
    if(isdigit(ch))
       return(1);
    else
       return(0);
}
/////////////////////////////////////////////////////////////////////////////
//                          get token function
/////////////////////////////////////////////////////////////////////////////
Token gettoken()
{
    int n,temp=lexeme_beginning;

    for(n=0;(temp)!=forward;n++)
    {
       current_lexeme[n]=buffer[temp];
       ++temp;
    }
    current_lexeme[n]='\0';
    return current_lexeme;
}
/////////////////////////////////////////////////////////////////////////////
//                            retract function
/////////////////////////////////////////////////////////////////////////////
void retract(int n)
{
    if (forward==0 && lexeme_beginning!=0)
       forward=2*size;
    else
       forward = forward-n;
}
/////////////////////////////////////////////////////////////////////////////
//                             recover
/////////////////////////////////////////////////////////////////////////////
void recover()
{
       error();
}
/////////////////////////////////////////////////////////////////////////////
//                          fail function
/////////////////////////////////////////////////////////////////////////////
int fail()
{
    forward =lexeme_beginning;
    switch(start)
    {
       case 0  : start=9;
   break;
       case 9  : start=12;
   break;
       case 12 : start=20;
   break;
       case 20 : start=25;
   break;
       case 25 : start=28;
   break;
       case 28 : recover();
   break;
    }
    return start;
}
/////////////////////////////////////////////////////////////////////////////
//                            assign_value
/////////////////////////////////////////////////////////////////////////////
void assign_value(char *lexeme)
{    char x[20];

    strcpy(x,lexeme);
    strcpy(st[loc].lexeme,x);
    loc++;
}
/////////////////////////////////////////////////////////////////////////////
//                          is colom
/////////////////////////////////////////////////////////////////////////////
int is_colom(char ch)
{
    if(ch==':')
       return(1);
    else
       return(0);
}
/////////////////////////////////////////////////////////////////////////////
//                          is EQ "="
/////////////////////////////////////////////////////////////////////////////
int isEQ(char ch)
{
    if (ch=='=')
       return(1);
    else
       return(0);
}
/////////////////////////////////////////////////////////////////////////////
//                          install assnment
/////////////////////////////////////////////////////////////////////////////
void install_Asnmt()
{   Token Ass;
    int exist;

    symbol_struct symbol;
    Ass=gettoken();

    symbol_file=fopen("a:\symbol.txt","a");
    symbol.lexeme=Ass;
    symbol.token="ASNMT";
    symbol.attribute="";

    exist=search(Ass);
    if(!exist)
    {   ref++;
	symbol.ref=ref;
	fprintf(symbol_file," %d %12s    %23s    %20s\n",symbol.ref,symbol.lexeme,symbol.token,symbol.attribute);
	printf("\n\n-------------------------------------------------------------");
	printf("\n  Current Token: <  %s , %s >",symbol.lexeme,symbol.token);
	printf("\n-------------------------------------------------------------");
	assign_value(Ass);
    }
    else
    {
       printf("\n\n-------------------------------------------------------------");
       printf("\n  Current Token: <  %s , %s >",symbol.lexeme,symbol.token);
       printf("\n-------------------------------------------------------------");
    }
       fclose(symbol_file);

}
/////////////////////////////////////////////////////////////////////////////
//                       install id to symbol table
/////////////////////////////////////////////////////////////////////////////
void install_id()
{
    Token id;
    int EQ_If,EQ_Then,EQ_Else;
    int exist;
    symbol_struct symbol;
    id = gettoken();

    symbol_file= fopen("a:\symbol.txt","a");
    EQ_If=strcmp(id,"if");
    EQ_Then=strcmp(id,"then");
    EQ_Else=strcmp(id,"else");
    if((EQ_If==0) || (EQ_Then==0) || (EQ_Else==0))
    {
       printf("\n\n-------------------------------------------------------------");
       printf("\n  Current Token: < %s , - >",id);
       printf("\n-------------------------------------------------------------");
    }
    else
    {
       symbol.lexeme=id;
       symbol.token="ID";
       symbol.attribute="";
       exist=search(id);
       if(!exist)
      {
     ref++;
     symbol.ref=ref;
     fprintf(symbol_file," %d %12s    %23s    %20s\n",symbol.ref,symbol.lexeme,symbol.token,symbol.attribute);
     printf("\n\n-------------------------------------------------------------");
     printf("\n  Current Token: <  %s , %d >",symbol.token,symbol.ref);
     printf("\n-------------------------------------------------------------");
     assign_value(id);
       }
       else
       {
     printf("\n\n-------------------------------------------------------------");
     printf("\n  Current Token: < %s , %d >",symbol.token,token_ref);
     printf("\n-------------------------------------------------------------");
       }

    }
    fclose(symbol_file);

}
/////////////////////////////////////////////////////////////////////////////
//                       install num to symbol table
/////////////////////////////////////////////////////////////////////////////
void install_num()
{
    Token num;
    symbol_struct symbol;
    int exist;
    num=gettoken();
    symbol_file=fopen("a:\symbol.txt","a");
    symbol.lexeme=num;
    symbol.token="NUM";
    symbol.attribute="";
    flushall();
    exist=search(num);
    if(!exist)
    {
       ref++;
       symbol.ref=ref;
       fprintf(symbol_file," %d  %12s    %20s    %20s\n",symbol.ref,symbol.lexeme,symbol.token,symbol.attribute);
       printf("\n\n-------------------------------------------------------------");
       printf("\n  Current Token: < %s , %s >",symbol.token,symbol.lexeme);
       printf("\n-------------------------------------------------------------");
       assign_value(num);
    }
    else
    {
       printf("\n\n-------------------------------------------------------------");
       printf("\n  Current Token: < %s , %s  >",symbol.token,symbol.lexeme);
       printf("\n-------------------------------------------------------------");
    }

    fclose(symbol_file);
}
/////////////////////////////////////////////////////////////////////////////
//                       install relop to symbol table
/////////////////////////////////////////////////////////////////////////////
void install_Relop(Token token)
{
    Token relop;
    symbol_struct symbol;
    int exist;
    relop=gettoken();

    symbol_file = fopen("a:\symbol.txt","a");
    symbol.lexeme=relop;
    symbol.token="RELOP";
    symbol.attribute=token;
    exist=search(relop);
    if(!exist)
    {  ref++;
       symbol.ref=ref;
       fprintf(symbol_file," %d  %12s    %20s    %20s\n",symbol.ref,symbol.lexeme,symbol.token,symbol.attribute);
       printf("\n\n-------------------------------------------------------------");
       printf("\n  Current Token: < %s , %s >",symbol.token,symbol.attribute);
       printf("\n-------------------------------------------------------------");
       assign_value(relop);
    }
    else
    {
       printf("\n\n-------------------------------------------------------------");
       printf("\n  Current Token: < %s , %s >",symbol.token,symbol.attribute);
       printf("\n-------------------------------------------------------------");
    }

    fclose(symbol_file);

}
/////////////////////////////////////////////////////////////////////////////
//                               next token
/////////////////////////////////////////////////////////////////////////////
Token nexttoken()
{
    char ch,
  blank =' ',
  tab='\t',
  newline='\n';

    while(1)
    {
       switch(state)
       {
    case 0 : ch = nextchar();
      if (ch==blank || ch==tab || ch==newline)
      {   state = 0;
  	lexeme_beginning++;
      }
      else if (ch=='<')
  	state = 1;
      else if (ch=='=')
  	state = 5;
      else if (ch=='>')
  	state = 6;
      else
  	state = fail();
      break;

    case 1 : ch = nextchar();
      if(ch=='=')
         state = 2;
      else if(ch=='>')
         state = 3;
      else
         state = 4;
      break;

    case 2 : install_Relop("LE");
      return("LE");

    case 3 : install_Relop("NE");
      return("NE");

    case 4 : retract(1);
      install_Relop("LT");
      return("LT");

    case 5 : install_Relop("EQ");
      return("EQ");

    case 6 : ch = nextchar();
      if(ch=='=')
         state = 7;
      else
         state = 8;
      break;

    case 7 : install_Relop("GE");
      return("GE");

    case 8 : retract(1);
      install_Relop("GT");
      return("GT");
    case 9 : ch = nextchar();
      if(isletter(ch))
         state = 10;
      else
         state = fail();
      break;

    case 10: ch = nextchar();
      if(isletter(ch))
         state = 10;
      else if(Isdigit(ch))
         state = 10;
      else
         state = 11;
      break;

    case 11: retract(1);
      install_id();
      return(gettoken());

    case 12: ch = nextchar();
      if(Isdigit(ch))
         state = 13;
      else
         state = fail();
      break;

    case 13: ch = nextchar();
      if(Isdigit(ch))
         state = 13;
      else if(ch=='.')
         state = 14;
      else if((ch=='E') || (ch=='e'))
         state = 16;
      else
         state = fail();
      break;

    case 14: ch = nextchar();
      if(Isdigit(ch))
         state = 15;
      else
         state = fail();
      break;

    case 15: ch = nextchar();
      if(Isdigit(ch))
         state = 15;
      else if((ch=='E') ||(ch=='e'))
         state = 16;
      else
         state = fail();
      break;

    case 16: ch = nextchar();
      if((ch=='+') || (ch=='-'))
         state = 17;
      else if(Isdigit(ch))
         state = 18;
      else state = fail();
      break;

    case 17: ch = nextchar();
      if(Isdigit(ch))
         state =	18;
      else
         state = fail();
      break;

    case 18: ch = nextchar();
      if(Isdigit(ch))
         state =	18;
      else
         state = 19;
      break;

    case 19: retract(1);
      install_num();
      return("NUM");

    case 20: ch = nextchar();
      if(Isdigit(ch))
         state =	21;
      else
         state = fail();
      break;

    case 21: ch = nextchar();
      if(Isdigit(ch))
         state = 21;
      else if(ch=='.')
         state = 22;
      else
         state = fail();
      break;

    case 22: ch = nextchar();
      if(Isdigit(ch))
         state = 23;
      else
         state = fail();
      break;

    case 23: ch = nextchar();
      if(Isdigit(ch))
         state = 23;
      else
         state =	24;
      break;

    case 24: retract(1);
      install_num();
      return("NUM");

    case 25: ch = nextchar();
      if(Isdigit(ch))
         state = 26;
      else
      {  state = fail();
      }
      break;

    case 26: ch = nextchar();
      if(Isdigit(ch))
         state =26;
      else
         state = 27;
      break;
    case 27: retract(1);
      install_num();
      return("NUM");

    case 28: ch = nextchar();
      if(is_colom(ch))
         state = 29;
      else
      {
         fail();
         return("");
      }
    case 29: ch = nextchar();
      if(isEQ(ch))
      {
         install_Asnmt();
         return("Asnmt");
      }
      else
         return("");
    }
    }
}
/////////////////////////////////////////////////////////////////////////////
//                              main
/////////////////////////////////////////////////////////////////////////////

void main()
{   char choice;
    Token token;
    clrscr();
    loc=0;
    symbol_file=fopen("a:\symbol.txt","r");
    if(check_file(symbol_file)!=NULL)
    {
       symbol_file=fopen("a:\symbol.txt","w");
       fprintf(symbol_file,"\n ref      lexeme             token                     attribute");
       fprintf(symbol_file,"\n ==        ====              ====                      =======");
       fprintf(symbol_file,"\n 1           ws ");
       fprintf(symbol_file,"\n 2           if                       IF ");
       fprintf(symbol_file,"\n 3          then                 THEN ");
       fprintf(symbol_file,"\n 4          else                 ELSE \n");
       fclose(symbol_file);
    }
    prog_file = fopen("a:\prog.txt","r");
    if (check_file(prog_file) != NULL)
    {
       Input(prog_file);
       read();
       forward=lexeme_beginning=0;
       //display(f);
       choice='1';
       printf("\n\n\n   lexical analysis started... \n");
       do
       {
    printf("\n1 ---> get the next token");
    printf("\n2 ---> exit");
    printf("\nEnter your choice:");
    flushall();
    choice=getchar();
    switch(choice)
    {
  case '1' : token=nexttoken();
      lexeme_beginning=forward;
      if(stmt[ptr]!= '\0')
         read();
      start=state=0;
      break;
  case '2' : fcloseall();
      printf(" \n\n Analysis terminated ...");
      getch();
      exit();
      printf("%s",token);
      break;
    }
       }while(choice!='2');

    }
}

كما ستلاحظين من الكود على الملفين prog.txt وملف symbol.txt ان يكونا على floppy او غيري مسارهما حسب ما ترينه مناسبا لك ..

مشكورين اخواني السهم الناري وفلسطينية

ان باقرأ الاكواد واعرضها على زميلاتي بس باين عليها بتحل مشكلتنا

راح ارد عليكم إن شاء الله

مشكورين اخواني السهم الناري وفلسطينية

والله ما قصرتوا بادرس الاكواد وارد عليكم

معليش الكودشكله مو واضح الذي كتبته بس الاخت مبرمجة فلسطينيةعطتكيكودجيد سأحاوا اقراه واستفيد منه

بس المهم ان تكون لغة المصدر الذي تريدين الترجمة منها الى اللغة الهدف هي نفسها والا فقط ستستفيدن من الامثلة .

بالتوفيق وأن شاء الله اضع الكود كاملا في ملف للتحميل ولكن ابحث عنه اولا.

إنتهينا هذا الأسبوع من عمل Lexical Analyzer في مادة الكومبايلر.

وهو يعمل بشكل ممتاز وهو شبيه ببرنامج (فلسطينية) تقريباً.

سأحاول وضع الـ TG المستخدم والبرنامج غداً إن شاء الله.

اتوجه بالشكر الكبير لكل من ساهم وشارك معي في هذا الموضوع واخص بالشكر الاخت

فلسطينية لان بصراحة برنامجها كان الاقرب للفهم

عجبتني فكرة الفايل لكن استخدامها في برنامجنا يمكن مو مهم.

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

اخ termenator1 شرحك افادني كثير وما قصرت

الاخ compuM4n مساعدتك شكلها يتفيدني ومشكور مع اني تقريبا انتهينا من كتابة الكود .

عموما حنا انتهينا من مرحلة lexical وباقي المراحل الثانية واكيد ما بتقصرون...

البرنامج الذي عطيتك جزء بسيط من برنامج كبير .

الفكرة ان اللغة المصدر عندنا هي لغة infeix أب بالصورة

1 +5*3/8;

ونترجمها الى لغة هدف وهي postifex أي بالصورة

1 + 5;
تتحول الى

1 5 +

وهكذا

لكن ماهي اللغة المصدر لكم وماهي اللغة الهدف والكود الذي وضعت قريبة بشكل كبير الى كود الاخت مبرمجة فلسطينية

سؤالي للاخت مبرمجة فلسطينية

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

دالة feil في برنامج للانتقال من TG الى بداية اخر لكن كيف تعدين الحروف المقروأه.

ارجو الاجابة.

السلام عليكم

أخي السهم الناري ، اعتقد أنك تقصد الاخت (فلسطينية) بالسؤال فهي من وضعت الكود هنا ـ ربما التبس عليك الأمر ...

معليش أسفجدا أختي مبرمجة فلسطينية اكيد التبس علي الامرواقصدا فعلا صاحبة الكود فلسطينية وشكر على التوضيح

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

بس انتظر الجواب .

اخوي السهم الناري

بصراحة الدكتور ماشرحلنا بالتوضيح فكرة اللغة المصدر واللغة الهدف

كل اللي طلبه هو المحلل الاملائي فقط

البرنامج يشيك عالاخطاء الاملائية فقط

حنا تونا في البداية....

يعني حتى المخرجات حددها

يعني ياخذ التوكن ويطبع على الشاشة نوعه

فقط هذا المطلوب!!!

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

الاخ السهم الناري ..

أولا بالنسبه للغة المصدر والهدف .. فانا بالبرنامج الذي ارفقته استخدم جمل من لغة السي ليتم عمل فلتره للـمفردات جمل لغة السي التي تحتوي على

if,then,else,white space,identefire,number,"<" , "<=" , ">" , ">=" , "=" , "<>"

وتبدأ بفلتره هذة المفردات لكي تصنفها اما ضمن الـ identefire او Keywords أو relop

أو nummber ...

اقتباس

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

أولا أخي لاحظ انه عند عمل install لاي مفرد فانه يعمل retrack رجوع للخلف بقيمه 1

للمتغير forword والسبب ان المحلل يكتشف نهايه المفرد عندما ينتقل لحرف ليس ضمن هذا المفرد كأن يقرأ رقم digit بعد الرمز <

وسأوضح اماكن الرجوع بالـ TG التالي

أما ان اكتشف الخطأ بعد قراءة عدة حروف فعليك ملاحظة اننا لدينا متغيرين

الأول lexeme_beginner والذي يكون ببداية المفرد والمتغير الثاني forword وهو الذي اتقدم به لقراءة الحروف .. ( كما عليك ان تلاحظ انهم بالبدايه يكونان متساويان ويؤشران على بدايه المفردات)

وهو يعود لوضعه الاول اي الى أول المفرد عند استدعاء دالة fail ربما لم تلحظ ذلك ..

int fail()
{
   forward =lexeme_beginning;
   switch(start)
   {
      case 0  : start=9;

وبالتالي يعود لبدايه المفرد الذي كان قد سلك طريقا خطأ لتحليله ومن ثم توجهه داله fail الى طريق أخر لتجربته ..

وكما ستلاحظ عندما يتم بشكل فعلي عمل insert للمفرد ..وعمل تحليل لمفرد جديد عندها يكون forward يقف عند اخر حرف لهذا المفرد .. ويكون lexeme_beginning يقف عند بداية المفرد ..

وما ان يطلب المستخدم تحليل المفرد التالي فان البرنامج يجعل قيمة lexeme_beginning

تساوي forward .. وبالتالي نعود لتكرار العمليه كما بدأناها ..

ويتم المساواه بين القيمتين بدالة الـ main

   lexeme_beginning=forward;

اتمني ان اكون استطعت ايضاح الفكرة.. واى استفسار انا جاهزة ..