编译原理源代码文件

❶ 易语言如何编译

问题一：易语言怎么编译 最上面有个编译

问题二：请问有了易语言源慎前码怎样编译成软件exe？ bak是易语言备份文件，把bak后缀改成e就可以用易语言打开，
打开易语言时他会提示载入模块，根据操作加载ec模块文件
生成win32程序，可以用易语言编译（如图下）
易语言下载：180.97.83.171:443/...461879

问题三：易语言程序写好了要怎么编译才最好 选择静态编译最好。
如果是正常编译，那么其他没有易语言支持库的电脑就无法运行程序（除非支持库在程序的运行目录下）。
而静态编译就不会出现这种问题，它将支持库一并写入了程序内，使其兼容性增强。并且静态编译对杀软的误报率有所降低（除了360这样的）。
但是静态编译的坏处在于每个支持库文件都需要有对应的静态编译支持库，并且连接器出错就无法编译（那时需要修复了）。
希望能帮到你，不懂的地方请追问！

问题四：易语言怎么独立编译 能够独立编译的易语言程序都可以独立编译，版本较高的易语言程序的独立编译被改成了静态编译。不支持独立编译可能和程序本身有关系。

问题五：为什么易语言不能编译 1 .找到打开易语言安装目录下的 tools\link.ini 的配置文本，找到linker=C:\full\path\link.exe 这句，然后修改，如果你的易语言是安装在E盘下核樱面，而你如果使用的安装易语言的文件夹名称是默认名 e 的话，就修改linker=E:\e\vc98linker\bin\link.exe 。如果你把易语言安装在F盘下面的123文件夹里，那你就把linker=C:\full\path\link.exe修改为，linker=F:\123\e\vc98linker\bin\link.exe )，反正你必须易语言安装的填绝对路径。
还有不知你有没有下载易语言静态编译所需要的VC6链接器，静态编译必须要VC6链接器，如果没有可到下面的网址下载：下载后直接放到易语言根目录里就可以了。
bbs.eyuyan/read.php?tid=202913
2. 你把易语言破解补丁解压到你安装的易语言文件夹里，然后打开patch.exe，它就会把原来不能编译的e.exe替换为可以编译的e.exe，就这么简单。如果你的易语言破解补丁不能用，那可以把电子邮件写上，我给你发过来。
如果还不明白可以和我在线交谈。
请采纳。

问题六：请教易语言模块如何编译成程序？ *.e文件是易语言的源代码文件，该文件中保存了易语言所设计的程序的所有源代码。无论是*.ec的模块文件还是*.exe的可执行文件都是通过*.e文件编译而来的.
如果编译源代码文件（也就是*.e的文件）后，生成的是*.ec的文件，那么说明这份源代码是一个易语言模块的源代码，它只能被编译为*.ec的易语言模块文件。
要生成exe的可执行文件，需要在新建易语言程序项目时选择“Windows窗口程序”类型，该类型的项目可以编译为exe文件。
另：如何建立“Windows窗口程序”项目？启动易语言后在弹出的“新建...”窗口中选择即可。

问题七：易语言编译成软件的可执行文件怎么生成啊？？？跪求 是怎么编译?
需要官方正版或破解版才可以，如果是学习版则只能调试
静态改孝丛编译……
[菜单]=>[编译]=>[静态编译](shift+f7)
如果提示错误，需要在易语言vc98linker(默认是这样的)目录下运行link.e，或者直接改变tools目录中的link.ini的linker配置项
如果只是给其他拥有易语言的朋友或者自己使用的，可以直接编译
还有一种是黑月编译，需要黑月编译支持库(这个时候就不能可视编辑窗口了)……

问题八：用易语言怎么编译生成安装软件啊 先把源码保存，然后再生成安装文件。
生成安装文件时，就一步一步地按照它说的去填写。（最好保存出一个模板出来）建议生成后加个壳，或者静态编译出来加壳后用其他的软件去包装。全手打望采纳！

问题九：易语言怎么制作编译器 这需要学习一定的汇编语言或其它编程语言
--------------------------------------------
将对应命令翻译为机器可直接运行的机器指令
如果觉得太难可以将易语言源码翻译为其它编程语言源码由其编译进行编译
或参考网上开源的其它编程语言的编译（如C#/C++），参考其编译原理和对应指令

问题十：易语言5.3怎么静态编译 版本跨度较大，应用程序理论上是需要重编译的并进行运行测试的。\r\nOracle的数据库要根据具体版本去查询官方的认证情况，看看是否可以支持Aix 6.1，有可能需要升级Oracle数据库版本或者安装相应补丁

❷ 用VS编译和C++源文件的时候，源文件和库文件是如何链接到源文件的具体细节

因为我是学习计算机软件专业的，故可以给你讲一下大概意思，我也不敢保证我讲得都是正确的。个人讲解仅供参考。这个是需要学习《计算机编译原理》这门课程的。而且《计算机编译原理》这门课程在软件专业中几乎是最抽象的、难于理解的。
首先关于 Visual Studio编译器（或者是别的 C/C++编译器）是如何将用户亲自编写的源程序经过若干步骤之后，最终变成计算机可执行的二进制代码程序？这里面经过了如下步骤：
（1）、词法分析/语法分析。也就是说当编译器对用户编写的源程序进行编译时，首先检查你的词法（或者是语法）是否正确，这是第一步（这里以 C 语言为例，假如将定义一个整型变量 n 的语句 int n ; 误写成了：intt n ; 属于语法错误）。如果这一步都没有通过编译器的检查的话，那么绝对不会进入第二步。继续返回编辑状态进行语法检查。这种错误是最容易检查的。
（2）、语义分析。这类错误就要比（1）困难得多。这类错误举例如下（这类错误编译器只是会给出一个警告信息，但是编译器是会放过这类错误的。故需要编程人员具有较丰富的编程经验）
void main( )
{
int num ; /* 定义一个整型变量 num */
scanf("%d", &num ) ; /* 从键盘上输入一个整数 */
if( num == 10 ) /* 在这个语句中，如果将逻辑判断等于号 ==，误写为数值等于 =（即：if( num = 10 )），那么该程序的执行结果始终输出：Correct。因为该逻辑表达式 if( 10 ) 的真值始终为 1。 */
printf( "Correct !\n" ) ; /* 实际上程序的本意是：如果输入的数值等于 10，则输出：Correct ! */
else /* 如果输入的数值不等于 10 的话，则输出：Error ! */
printf( "Error !\n" ) ;
}
（3）、在（1）和（2）的基础上进行中间代码生成（例如：在Linux 系统下面生成的 *.o 文件、或者是在 WINDOWS 系统下面生成的 *.obj 文件），这类文件还不是最终的可执行文件。
在此过程中，会应用到各种符号表，以便处理用户程序中使用的各种常量、变量、以及各种函数，等等。
（4）、在前三个阶段的基础上，最终 VS 编译器再将中间代码（*.obj 文件）和其本身提供的库文件（*.LIB）进行链接，最终产生可执行程序（Linux 系统使用的编译器是：gcc，Linux 系统下面的可执行文件名可以任意，WINDOWS 系统下面的可执行文件名为：*.EXE 文件）。
到此为止，一个用户编写的源程序，经过上面若干步骤之后，最终产生了可执行程序，此时就可以在机器上的相应的操作系统上执行了。

❸ 编译原理第三版清华大学

“编译原理”是计算机专业非常重要的一门专业课，在计算机教学中有着举足轻重的地位。

编译原理中编译系统是整个计算机系统中极其重要的系统软件，它的作用是把计算机高级语言最终翻译成等价的计算机指令，从而保证高级程序设计语言顺利运行。所以，“编译原理”是计算机科学中基本研究内容之一。

编译器：编译器是计算机程序中应用比较多的工具,在对编译器进行前端设计时，一定要充分考虑影响因素，还要对词法、语法、语义进行分析。

过程分析：将高级程序设吾言，如C、C++、Java等，翻译成计算机可以执行的机器指令代码流的过程，即是编译的过程。编译过程一般分为6个步骤，即词法分析、语法分析、语义分析、中间代码生成、中间代码优化、目标代码生成。

❹ 编译原理

编译原理是计算机科学中的一慎昌门重要课程，主要研究如段配何将高级程序语言转化为机器语言宽燃扒的过程。它涉及到多个领域，如语言学、数学、计算机硬件和操作系统等。编译器是实现这一过程的关键工具，它可以将程序源代码转化为可执行的机器代码。

❺ 编译原理

这个是1型语言

❻ 急求:编译原理判断文法类型的C语言源代码!!!!!!

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

/**//*全局变量定义*/
char inputString[10]; /**//*用来存储用户输入的字符串，最长为20个字符*/
char stack[10]; /**//*用来进行语法分析的栈结构*/
int base=0; /**//*栈底指针*/
int top=1; /**//*栈顶指针*/
char VT[4]={'a','d','b','e'}; /**//*用来存放5个终结符*/
char chanShengShi[10]; /**//*用来存放预测分析表M[A,a]中的一条产生式*/
int firstCharIntex=0; /**//*如果a匹配产生式，则每次firstCharIntex 自增 1 */
/**//*firstCharIntex用来存放用户输入串的第一个元素的下标*/

/**//*自定义函数声明*/
char pop() ; /**//*弹出栈顶元素*/

int push(char) ; /**//*向栈内添加一个元素，成功返回1，若栈已满则返回0*/

int search(char temp) ; /**//*查找非终结符集合VT中是否存在变量temp，存在返回1，不存在返回0*/

int M(char A, char a) ; /**//* 若预测分析表M[A,a]中存在产生式，
则将该产生式赋给字符数组chanShengShi[10]，并返回 1，
若M[A,a]中无定义产生式则返回 0
*/

void init() ; /**//*初始化数组inputString[10] 、栈 stack[10] 和 chanShengShi[10]*/

int yuCeFenXi() ; /**//* 进行输入串的预测分析的主功能函数，
若输入串满足文法则返回 1，不满足则返回0
*/
void printStack(); /**//*打印栈内元素 */
void printinputString(); /**//*打印用户输入串 */

/**//*进入主函数*/
void main()
{
system("cls");
yuCeFenXi(); /**//*调用语法预测分析函数*/
system("pause");
}

/**//*函数的定义*/

int yuCeFenXi()
{
char X; /**//*X变量存储每次弹出的栈顶元素*/
char a; /**//*a变量存储用户输入串的第一个元素*/
int i;
int counter=1; /**//*该变量记录语法分析的步骤数*/

init(); /**//*初始化数组*/
printf("wen fa : \n"); /**//*输出文法做为提示*/
printf("S -> aH \n");
printf("H -> aMd | d \n");
printf("M -> Ab | \n");
printf("A -> aM | e \n");

printf("\ninput string ,'#' is a end sign !!(aaabd#) \n"); /**//*提示用户输入将要测试的字符串*/
scanf("%s",inputString);

push('#');
push('S');

printf("\nCounter-----Stack---------------Input string \n"); /**//*输出结果提示语句*/

while(1) /**//*while循环为语法分析主功能语句块*/
{
printf(" ");
printf(" %d",counter); /**//*输出分析步骤数*/
printf(" "); /**//*输出格式控制语句*/
printStack(); /**//*输出当前栈内所有元素*/
X=pop(); /**//*弹出栈顶元素赋给变量X*/
printinputString(); /**//*输出当前用户输入的字符串*/

if( search(X)==0 ) /**//*在终结符集合VT中查找变量X的值，存在返回 1，否则返回 0*/
{
if(X == '#') /**//*栈已经弹空，语法分析结果正确，返回 1*/
{
printf("success \n"); /**//*语法分析结束，输入字符串符合文法定义*/
return 1;
}
else
{
a = inputString[firstCharIntex];
if( M(X,a)==1 ) /**//*查看预测分析表M[A,a]是否存在产生式，存在返回1，不存在返回0*/
{
for(i=0;i<10;i++) /**//* '$'为产生式的结束符,for循环找出该产生式的最后一个元素的下标*/
{
if( chanShengShi[i]=='$' ) break;
}
i-- ; /**//*因为 '$' 不是产生式，只是一个产生式的结束标志，所以i自减1*/

while(i>=0)
{
push( chanShengShi[i] ); /**//*将当前产生式逆序压入栈内*/
i-- ;
}
}
else
{
printf(" error(1) !!\n"); /**//*若预测分析表M[A,a]不存在产生式，说明语法错误*/
return 0;
}
}
}
else /**//*说明X为终结符*/
{
if( X==inputString[firstCharIntex] ) /**//*如果X等于a,说明a匹配*/
{
firstCharIntex++; /**//*输入串的第一个元素被约去，下一个元素成为新的头元素*/
}
else
{
printf(" error(2) !! \n");
return 0;
}
}
counter++;
}
}

void init()
{
int i;
for(i=0;i<10;i++)
{
inputString[i]=NULL; /**//*初始化数组inputString[10] */
stack[i]=NULL; /**//*初始化栈stack[10] */
chanShengShi[i]=NULL; /**//*初始化数组chanShengShi[10]*/
}
}

int M(char A, char a) /**//*文法定义因实际情况而定，该文法为课本例题的文法*/
{ /**//*该函数模拟预测分析表中的二维数组 */
if( A=='S'&& a=='a' ) { strcpy(&chanShengShi[0],"aH$"); return 1; }
if( A=='H'&& a=='a' ) { strcpy(&chanShengShi[0],"aMd$"); return 1; }
if( A=='H'&& a=='d' ) { strcpy(&chanShengShi[0],"d$"); return 1; }
if( A=='M'&& a=='a' ) { strcpy(&chanShengShi[0],"Ab$"); return 1; }
if( A=='M'&& a=='d' ) { strcpy(&chanShengShi[0],"$"); return 1; }
if( A=='M'&& a=='b' ) { strcpy(&chanShengShi[0],"$"); return 1; }
if( A=='M'&& a=='e' ) { strcpy(&chanShengShi[0],"Ab$"); return 1; }
if( A=='A'&& a=='a' ) { strcpy(&chanShengShi[0],"aM$"); return 1; }
if( A=='A'&& a=='e' ) { strcpy(&chanShengShi[0],"e$"); return 1; }
else return 0; /**//*没有定义产生式则返回0*/
}

char pop() /**//*弹出栈顶元素，用topChar返回*/
{
char topChar;
topChar=stack[--top];
return topChar;
}

int push(char ch)
{
if( top>9 )
{
printf(" error : stack overflow "); /**//*栈空间溢出*/
return 0;
}
else
{
stack[top]=ch; /**//*给栈顶空间赋值*/
top++;
return 1;
}
}

int search(char temp)
{
int i,flag=0; /**//*flag变量做为标志，若找到temp则赋1，否则赋0*/
for(i=0;i<4;i++)
{
if( temp==VT[i] ) /**//*终结符集合中存在temp*/
{
flag=1;
break;
}
}

if(flag==1) return 1; /**//*flag==1说明已找到等于temp的元素*/
else return 0;

}

void printStack() /**//*输出栈内内容*/
{
int temp;
for(temp=1;temp<top;temp++)
{
printf("%c",stack[temp]);
}
}

void printinputString() /**//*输出用户输入的字符串*/
{
int temp=firstCharIntex ;
printf(" "); /**//*该句控制输出格式*/
do{
printf("%c",inputString[temp]);
temp++;
}while(inputString[temp-1]!='#');
printf(" \n");
}

❼ 什么是编译原理

问题一：什么是编译原理 编译：就是将程序语言进行翻译，生成可供用户直接执行的二进制代码，即可执行文件。
任务是个比较模糊的概念，指的是操作系统中正在进行的工作，既可以指进程，也可以指程序春坦灶。
程序指的是可以连续执行，并能够完成一定任务的一条条指令的 *** 。
进程是程序在一个数据 *** 上运行的过程,它是传统操作系统进行资源分配和调度的一个独立单位。
线程是一个指令执行序列，是操作系统调度的最小单位。一个或多个线程构成进程，构成一个进激的线程之间共享资源。进程和线程之间的最大区别就是线程不能独立拥有资源，进程拥有自己的资源。

问题二：编译原理中V*是什么意思 V是一个符号 *** ，假设V指的是三个符号a, b, c的 *** ，记为 V = {a, b, c }
V* 读作“V的闭包”，它的数学定义是V自身的任意多次自身连接（乘法）运算的积，也是一个 *** 。
也就是说，用V中的任意符号进行意多次（包括0次）连接，得到的符号串，都是V*这个 *** 中的元素。
0次连接的结果是不含任何符号的空串，记为 ε
1次连接就是只有一个符号的符号串，比如，a，b， c
2次连接是两个符号构成的符号串，比如，aa, ab, ac, ba, bb, bc,等等
……
n次连接是一个长度为n、由a、b、c三个符号构成的符号串，比如abaacbbac……
因此，V*包含一切由a,b,c三个符号连接而成的、任意长度的符号串（以及空串ε）

问题三：编译原理 V+什么意思，例如下面的例子。。。 v表示终结符和非终结符 *** 。
+表示 *** 中的一个或多个元素构成的串的 *** 。
所以v+表示由一个或多个终结符或非终结符构成的串的 *** 。比如如果a∈VT，A∈VN，那么a，A，aA，Aa，aAA，AaA等都是v+中的元素。

问题四：谁能够解释下编译原理中什么是FIRSTVT,和LASTVT，尽量浅显易懂点谢谢 Firstvt和Lastvt是为了画算符优先关系表的（就是表里面填优先大于小于等于的那个）。
然后要注意他们可都是终结符的 *** 。
Firstvt
找Firstvt的三条规则：如果要找A的Firstvt，A的候选式中出现：
A->a.......，即以终结符开头，该终结符入Firstvt
A->B.......，即以非终结符开头，该非终结符的Firstvt入A的Firstvt
攻 A->Ba.....，即先以非终结符开头，紧跟终结符，则终结符入Firstvt
Lastvt
找Lastvt的三条规则：如果要找A的Lastvt，A的候选式中出现：
A->.......a，即以终结符结尾，该终结符入Lastvt
A->.......B，即以非终结符结尾，该非终结符的Lastvt入A的Lastvt
A->.....aB，即先以非终结符结尾，前面是终结符，则终结符入Firstvt

问题五：编译原理 什么是语义分析 在编译原理中，语法规则和词法规则不同之处在于：规则主要识别单词,而语法主要识别多个单词组成的句子。词法分析信孝和词法分析程序：词法分析阶段是编译过程的第一个阶段。这个阶段的任务是从左到右一个字符一个字符地读入源程序，即对构成源程序的字符流进行扫描然后根据构词规则识别单词(也称单词符号或符号)。词法分析程序实现这个任务。词法分析程序可以使用lex等工具自动生成。语法分析（Syntax *** ysis或Parsing）和语法分析程序（Parser） 语法分析是编译过程的一个逻辑阶段。语法分析的任务是在词法分析的基础上将单词序列组合成各类语法短语，如“程序”，“语句”，“表达式”等等.语法分扒扮析程序判断源程序在结构上是否正确.源程序的结构由上下文无关文法描述.语义分析（Syntax *** ysis） 语义分析是编译过程的一个逻辑阶段. 语义分析的任务是对结构上正确的源程序进行上下文有关性质的审查, 进行类型审查.语义分析将审查类型并报告错误:不能在表达式中使用一个数组变量,赋值语句的右端和左端的类型不匹配.

问题六：编译原理中，（E）是什么意思？ E→(E)? 10分 就是 字符本身 意思是F产生（ E ） 或者 i 比如If语句的开头 就是 带括号的 必须是 if(表达式)这样的形式 丢了任何即括号就是其 终结符 “(” 和 “)”.

问题七：大家觉得对编译器及编译原理需要掌握到一个什么程度 我跟你说，编译原理太有用了。
我是做手机游戏的，现在做一个游戏引擎。既然是引擎，就需要提供抽象的东西给上层使用。这里，我引入了脚本系统。
这个脚本系统包括一堆我根据实际需求自行设计的指令集，包括基本的输入输出，四则运算，系统功能调用，函数声明，调用等等（其实你要是用过lua或者其他游戏脚本你就知道了。）整个结构包括指令集、编译器、虚拟机等部分。这样，引擎提供一些基础服务，比如绘图，计算位置等，脚本就可以非常简单控制游戏。甚至快速构建新游戏。你应该知道QUAKE引擎吧？
这里提供给你一个计算器的小程序，应用了EBNF理论，支持表达式，比如(2+3*6)*4+4，你自己体验一下它的简洁和强大。
/*
simple integer arithmetic calculator according to the EBNF
-> {}
->+|-
->{}
-> *
-> ( )| Number
Input a line of text from stdin
Outputs Error or the result.
*/
#include
#include
#include
char token;/*global token variable*/
/*function prototypes for recursive calls*/
int exp(void);
int term(void);
int factor(void);
void error(void)
{
fprintf(stderr,Error\n);
exit(1);
}
void match(char expectedToken)
{
if(token==expectedToken)token=getchar();
else error();
}
main()
{
int result;
token = getchar();/*load token with first character for lookahead*/
result = exp();
if(token=='\n')/*check for end of line */
printf(Result = %d\n,result);
else error();/*extraneous cahrs on line*/
return 0;
}
int exp(void)
{
int temp = term();
while((token=='+')||(token=='-'))
switch(token)
{
case '+':
match('+');
temp+=term......>>

问题八：编译原理中,自动机究竟是什么. 形式语言
形式语言 是一个字母表上的某些有限长字串的 *** 。一个形式语言可以包含无限多个字串。
语言的形式定义
字母表 ∑ 为任意有限 *** ，ε 表示空串， 记 ∑ 0 为{ε}，全体长度为 n 的字串为 ∑ n ， ∑ * 为 ∑ 0 ∪∑ 1 ∪…∪∑ n ∪…， 语言 L 定义为 ∑ * 的任意子集。
注记：∑ * 的空子集 Φ 与 {ε} 是两个不同的语言。
语言间的运算
语言间的运算就是 ∑ * 幂集上的运算。
字串 *** 的交并补等运算。
连接运算：L 1 L 2 = { xy | x 属于L 1 并且 y 属于L 2 }。
幂运算：L n = L … L （共 n 个 L 连接在一起），L 0 = {ε}。
闭包运算：L * = L 0 ∪L 1 ∪…∪L n ∪…。
（右）商运算：L 1 /L 2 = {x | 存在 y 属于L 2 使得 xy 属于L 1 }。
语言的表示方法
一个形式语言可以通过多种方法来限定自身，比如：
枚举出各个字串（只适用于有限字串 *** ）。
通过 形式文法 来产生（参见 乔姆斯基谱系 ）。
通过正则表达式来产生。
通过某种自动机来识别，比如 图灵机 、 有限状态自动机 。
自动机
automata
对信号序列进行逻辑处理的装置。在自动控制领域内，是指离散数字系统的动态数学模型，可定义为一种逻辑结构，一种算法或一种符号串变换。自动机这一术语也广泛出现在许多其他相关的学科中，分别有不同的内容和研究目标。在计算机科学中自动机用作计算机和计算过程的动态数学模型，用来研究计算机的体系结构、逻辑操作、程序设计乃至计算复杂性理论。在语言学中则把自动机作为语言识别器，用来研究各种形式语言。在神经生理学中把自动机定义为神经网络的动态模型，用来研究神经生理活动和思维规律，探索人脑的机制。在生物学中有人把自动机作为生命体的生长发育模型，研究新陈代谢和遗传变异。在数学中则用自动机定义可计算函数，研究各种算法。现代自动机的一个重要特点是能与外界交换信息，并根据交换得来的信息改变自己的动作，即改变自己的功能，甚至改变自己的结构，以适应外界的变化。也就是说在一定程度上具有类似于生命有机体那样的适应环境变化的能力。
自动机与一般机器的重要区别在于自动机具有固定的内在状态，即具有记忆能力和识别判断能力或决策能力，这正是现代信息处理系统的共同特点。因此，自动机适宜于作为信息处理系统乃至一切信息系统的数学模型。自动机可按其变量集和函数的特性分类，也可按其抽象结构和联结方式分类。主要有：有限自动机和无限自动机、线性自动机和非线性自动机、确定型自动机和不确定型自动机、同步自动机和异步自动机、级联自动机和细胞自动机等。
这可能有你想要的答案
./question/7218281?fr=qrl3

问题九：编译原理中"(E)"表示什么 字符( 表达式 字符)

❽ 编译原理pdf

编译原理pdf是计算机专业的一门重要专业课。

学习编译原理pdf的方法：

1、端正认识：编译原理在静态文本处理上有广泛应用，把HTML文件转化为纯文本，利用编译原理来实现非常简单。理解编译原理的实用性，可以提高学习兴趣。

2、反复看书：是基本的方法，看书可以读懂很多内容。

3、结合源码学习：看懂代码，才能说真正理解理论。要完全看懂yacc的代码，工作量很大，同样要先理解理论。

4、删繁就简，避重就轻。对于词法分析，可避免自动机理论和集合论推演的介绍，直接搬出源码，降低理解难度，对于语法分析递归下降和LL文法及相应的源码可简单介绍，而对LR文法理解即可，这样可短时间内编写出一个能够运行的词法分析器和语法分析器，可以提高学习积极性。

❾ 编译原理 词法分析 要求输入一个源文件，或是text形式的，然后对该文件进行词法分析。要简单一点的。

#include <iostream>
#include <vector>
#include <string>
#include <fstream>

using namespace std;
/*用来存储目标文件名*/
string file_name;

/*提取文本文件中的信息。*/
string GetText();

/*获得一个单词符号,从位置i开始查找。
//并且有一个引用参数j，用来返回这个单词最后一个字符在str的位置。*/
string GetWord(string str,int i,int& j);

/*这个函数用来除去字符串中连续的空格和换行
//第一个参数为目标字符串，第二个参数为开始位置
//返回值为连续的空格和换行后的第一个有效字符在字符串的位置*/
int DeleteNull(string str,int i);

/*判断i当前所指的字符是否为一个分界符，是的话返回真，反之假*/
bool IsBoundary(string str,int i);

/*判断i当前所指的字符是否为一个运算符，是的话返回真，反之假*/
bool IsOperation(string str,int i);

/*此函数将一个pair数组输出到一个文件中*/
void OutFile(vector<pair<int,string> > v);

/*此函数接受一个字符串数组，对它进行词法分析，返回一个pair型数组*/
vector<pair<int,string> > analyst(vector<string> vec);

/*此函数判断传递的参数是否为关键字，是的话，返回真，反之返回假*/
bool IsKey(string str);

int main()
{
cout<<"*****************************\n";
cout<<"\n\nright: Archerzei\n\n\n";
cout<<"*****************************\n\n";
string com1=" ";
string com2="\n";
string fileline=GetText();
int begin=0,end=0;
vector<string> array;
do
{
begin=DeleteNull(fileline,begin);
string nowString;
nowString=GetWord(fileline,begin,end);
if(end==-1)
break;
if(nowString.compare(com1)&&nowString.compare(com2))
array.push_back(nowString);
begin=end+1;
}while(true);
vector<pair<int,string> > mid_result;
mid_result=analyst(array);
OutFile(mid_result);
cout<<"**********************************************************************\n";
cout<<"***程序已完成词法分析，分析结果已经存储在文件"<<file_name<<"中！！！***\n";
cout<<"**********************************************************************\n";
system("pause");
return 0;
}

/*提取文本文件中的信息*/
string GetText()
{
string file_name1;
cout<<"请输入源文件名（包括路径和后缀名）：";
cin>>file_name1;
ifstream infile(file_name1.c_str(),ios::in);
if (!infile)
{
cerr<<"无法打开文件! "<<file_name1.c_str()<<" !!!"<<endl;
exit(-1);
}
cout<<endl;
char f[1000];
infile.getline(f,1000,EOF);
infile.close();
return f;
}

/*获得一个单词符号,从位置i开始查找。
//并且有一个引用参数j，用来返回这个单词最后一个字符在原字符串的位置。*/
string GetWord(string str,int i,int& j)
{
string no_use("(){} , ; \n+=*/-<>\"");
j=str.find_first_of(no_use,i);
if(j==-1)
return "";
if(i!=j)
j--;
return str.substr(i,j-i+1);
}

/*这个函数用来除去字符串中连续的空格和换行
//第一个参数为目标字符串，第二个参数为开始位置
//返回值为连续的空格和换行后的第一个有效字符在字符串的位置*/
int DeleteNull(string str,int i)
{
for(;;i++)
if(str[i]!=' '&&str[i]!='\n')
return i;
}

/*判断i当前所指的字符是否为一个分界符，是的话返回真，反之假*/
bool IsBoundary(string str,int i)
{
int t;
char arr[7]={',',';','{','}','(',')','\"'};
for (t=0;t<7;t++)
if(str[i]==arr[t])
return true;
return false;
}

/*判断i当前所指的字符是否为一个运算符，是的话返回真，反之假*/
bool IsOperation(string str,int i)
{
int t;
char arr[7]={'+','-','*','/','=','<','>'};
for (t=0;t<7;t++)
if(str[i]==arr[t])
return true;
return false;
}

/*此函数将一个个字符串数组输出到一个文件中*/
void OutFile(vector<pair<int,string> > v)
{
cout<<"请输入目标文件名（包括路径和后缀名）：";
cin>>file_name;
ofstream outfile(file_name.c_str(),ios::out);
if (!outfile)
{
cerr<<"无法打开文件! "<<file_name.c_str()<<" !!!"<<endl;
exit(-1);
}
cout<<endl;
int i;
cout<<"*****************************\n";
cout<<"\n\nright: Archerzei\n\n\n";
cout<<"*****************************\n\n";
for(i=0;i<v.size();i++)
outfile<<"<"<<v[i].first<<" , \""<<v[i].second<<"\">"<<endl;
outfile<<"\n\n*********************************\n";
outfile.close();
return;
}

/*此函数接受一个字符串数组，对它进行词法分析，返回一个pair型数组*/
vector<pair<int,string> > analyst(vector<string> vec)
{
vector<pair<int,string> > temp;
int i;
for(i=0;i<vec.size();i++)
{
if(vec[i].size()==1)
{
if((vec[i]==">"||vec[i]=="<"||vec[i]=="!")&&vec[i+1]=="=")
{
string jk=vec[i];
jk.append(vec[++i],0,1);
pair<int,string> pp(4,jk);
temp.push_back(pp);
continue;
}
if((vec[i]=="+"&&vec[i+1]=="+")||(vec[i]=="-"&&vec[i+1]=="-"))
{
string jk=vec[i];
jk.append(vec[++i],0,1);
pair<int,string> pp(4,jk);
temp.push_back(pp);
continue;
}
if(IsBoundary(vec[i],0))
{
pair<int,string> pp(5,vec[i]);
temp.push_back(pp);
}
else if(IsOperation(vec[i],0))
{
pair<int,string> pp(4,vec[i]);
temp.push_back(pp);
}
else if(vec[i][0]<='9'&&vec[i][0]>='0')
{
pair<int,string> pp(3,vec[i]);
temp.push_back(pp);
}
else
{
pair<int,string> pp(2,vec[i]);
temp.push_back(pp);
}
}
else if(vec[i][0]<='9'&&vec[i][0]>='0')
{
pair<int,string> pp(3,vec[i]);
temp.push_back(pp);
}
else if(IsKey(vec[i]))
{
pair<int,string> pp(1,vec[i]);
temp.push_back(pp);
}
else
{
pair<int,string> pp(2,vec[i]);
temp.push_back(pp);
}
}
return temp;
}

/*此函数判断传递的参数是否为关键字，是的话，返回真，反之返回假*/
bool IsKey(string str)
{
string p[16]={"char","double","int","long","double","float","for","while","do","break","continue","switch","short","case","return","if"};
vector<string> ppp(p,p+16);
int u;
for(u=0;u<ppp.size();u++)
if(!str.compare(ppp[u]))
return true;
return false;
}
/*finished*/

已经验收过了，在VC6.0上运行没有问题。程序很容易看懂的，报告的话自己写写就可以了。要是有分就好了…………哈哈！！！