c语言写的Java词法分析

[代码] [C/C++]代码
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#define FILENAME "e:/a.java"

enum type
{

blz,//保留字
bzf,//标识符
cs,//常数
zfcl,//字符常量
zfccl,//字符串常量
dzf,//单字符
szf//双字符
};

typedef struct output
{
int type;
union{

char *_strvalue;
char _charvalue;
int _intvalue;
float _floatvalue;
double _doublevalue;

}value;

struct output *pnext;
struct output *ppre;

} output;

int linenumber=0;

char getAChar(FILE *pfile);
char *getString(FILE *pfile);
char isDzf(char c);
output *createOuput(output *srcolutput);
char *getTypeChars(char c,FILE *pfile);
output *process(FILE *pfile);

char *constans_pool[]={
"package",
"class",
"int",
"double",
"float",
"byte",
"boolean",
"char",
"short",
"public",
"private",
"protocted",
"synchronized",
"instanceof",
"extends",
"implements",
"throw",
"throws",
"if",
"else",
"for",
"while",
"return",
"continue",
"break",
"switch",
"case","void","keyword"};

int main()
{



output *phead=NULL,*pcurt=NULL;
FILE *pfile=fopen(FILENAME,"r");
if(pfile)
phead=process(pfile);


if(phead)
{
pcurt=phead;
while(pcurt)
{

switch(pcurt->type)
{
case blz:

printf("<b>%s<b>\t",pcurt->value._strvalue);
break;
case bzf:
case zfccl:
case szf:
printf("%s\t",pcurt->value._strvalue);
break;
case zfcl:
case dzf:
printf("%c\t",pcurt->value._charvalue);
break;
case cs:
printf("%d\t",pcurt->value._intvalue);
break;


}

pcurt=pcurt->pnext;
}

}




return 0;
}

output *process(FILE *pfile)
{
char nowchar=0,prechar=0;
output *phead=NULL,*pcurt=NULL,*pnext=NULL,*ppre=NULL;
output tmp;
char *p=NULL;
char *pnowglz=NULL;
int i=0;


while(!feof(pfile))
{
prechar=nowchar;
nowchar=getAChar(pfile);



//如果是字幕
if(isalpha(nowchar))
{

p=getTypeChars(nowchar,pfile);

tmp.type=bzf;
while(strcmp(constans_pool[i],"keyword"))
{

if(strcmp(constans_pool[i],p))
{
tmp.type=blz;
break;
}
}
tmp.value._strvalue=p;

}
//如果是数字
else if(isdigit(nowchar))
{
p=getTypeChars(nowchar,pfile);
tmp.type=cs;
tmp.value._intvalue=atoi(p);

if(phead==NULL)
phead=pcurt;


}
else if(nowchar=='/')
{
nowchar=fgetc(pfile);
if(nowchar=='*')//表明是注释；
{

do
{
while(nowchar=getAChar(pfile)!='*'&&nowchar>0);
nowchar=fgetc(pfile);
}
while(nowchar!='/');

continue;
}
else if(nowchar=='/')//单行注释
{
while((nowchar=fgetc(pfile))!='\n'&&nowchar>0);
continue;
}
else
{
tmp.type=dzf;
tmp.value._charvalue='/';
ungetc(nowchar,pfile);
}
}
else if(nowchar=='=')
{
nowchar=getAChar(pfile);

if(nowchar=='=')
{

tmp.type=bzf;
*(tmp.value._strvalue)='=';
*(tmp.value._strvalue+1)='=';

}
else
{
ungetc(nowchar,pfile);
continue;
}

}
else if(nowchar=='\'')
{

nowchar=fgetc(pfile);
if(fgetc(pfile)!='\'')
printf("此处应该是单引号");
else
{
tmp.type=zfcl;
tmp.value._charvalue=nowchar;
}


}
else if(nowchar=='\"')
{
p=getString(pfile);
tmp.type=zfccl;
tmp.value._strvalue=p;

}


else if(isDzf(nowchar))
{
tmp.type=dzf;
tmp.value._charvalue=nowchar;
}
else if(nowchar<0)

// printf("end");
continue;



else
{
printf("\nerror%c\t%d\n",nowchar,linenumber);
continue;
}

phead=createOuput(&tmp);
}
return phead;

}
//判断是不是单字符
char isDzf(char c)
{
char dzfarr[]={'+','-','*','(',')','[',']','{','}',';','?','.','!','%'};

unsigned int i=0;
for(;i<sizeof(dzfarr)/sizeof(char);i++)
{
if(dzfarr[i]==c)
return dzfarr[i];

}
return 0;

}
//得到字符串常量
char *getString(FILE *pfile)
{

char nowchar[]={0,0};
char *p=NULL;
unsigned int size=4;

while((nowchar[0]=fgetc(pfile))>0&&nowchar[0]!='\"')
{

if(!p)
{
p=(char *)malloc(sizeof(char)*size);
*p=0;
}
strcat(p,nowchar);

if(strlen(p)>=size)
{
p=realloc(p,size*=2);
*(p+size/2)=0;

}

}
return p;

}

//读取同一个类型的字符加入到指针只到出现不同类型的字符
char *getTypeChars(char c,FILE *pfile)
{

char nowchar[]={c,'\0'};
char *p=NULL;
int (*pchartype)(int)=NULL;
unsigned int str_size=4;

if(isdigit(c))
pchartype=isdigit;
else if(isalnum(c))
pchartype=isalnum;

do
{
if(!p)
{
p=(char *)malloc(sizeof(char)*str_size);
*p=0;
}

strcat(p,nowchar);

if(strlen(p)>=str_size)
{
p=(char *)realloc(p,str_size*=2);
*(p+str_size/2)='\0';
}

nowchar[0]=fgetc(pfile);

}while(nowchar[0]>0&&pchartype(nowchar[0]));

ungetc(nowchar[0],pfile);
return p;

}
//创建output的链表
output *createOuput(output *srcolutput)
{

static output *pnext=NULL;
static output *ppre=NULL;
static output*phead=NULL;
output *pout=NULL;
pout=(output *)malloc(sizeof(output));
pout->pnext=NULL;
pout->type=srcolutput->type;
switch(srcolutput->type)
{

case blz:
case bzf:
case zfccl:
case szf:
pout->value._strvalue=(char *)malloc(sizeof(char)*strlen(srcolutput->value._strvalue));
*(pout->value._strvalue)=0;
strcpy(pout->value._strvalue,srcolutput->value._strvalue);
free(srcolutput->value._strvalue);
break;
case zfcl:
case dzf:
pout->value._charvalue=srcolutput->value._charvalue;
break;
case cs:
pout->value._intvalue=srcolutput->value._intvalue;
break;

}

if(!phead)
phead=pout;
if(ppre)
ppre->pnext=pout;

ppre=pout;

return phead;

}
{[url=http://www.huiyi8.com/java/]jave语言[/url]}
//返回一个字符
//这个字符不为空字符。
char getAChar(FILE *pfile)
{
char c=0;

if(!pfile)
return EOF;

while((c=fgetc(pfile))=='\t'||c=='\0'||c==' '||c=='\n')
{
if(c=='\n')
linenumber++;
}

return c;
}