linux下用lex/yacc实现的一个小汇编器,for 体系实习2,实习中唯一可以拿的出来的东西

最新推荐文章于 2024-03-10 21:31:45 发布
最新推荐文章于 2024-03-10 21:31:45 发布
阅读量3.5k 收藏 1
点赞数
文章标签： 汇编 linux yacc command hex flex
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/polisan/article/details/1677830
版权

上学期在编译实习课上在Window环境中用Lex/yacc完成了一个不大不小的Cm(C minus,呵呵,比C小多了)编译器, 而今天做体系实习2,要求设计一个新的指令系统,然后写汇编,再到二进制,再到simplescalar执行.汇编到二进制要是手工就很麻烦了.

由于汇编到二进制,基本上是直接翻译就可,所以可以使用awk来完成.但我花了一个通宵的时间(也不算,还做了别的事情),在Linux环境下使用GNU的lex(flex)和Yacc(bison),写了一个简单的汇编器,贴出来,让初学者看看,如果你是高手,就找找毛病啦,我的没有进行错误处理,默认输入是stdin,并且是正确的.

首先先看一个写好的简单汇编代码.

DATA SEG:
  10
  10
  9
  8
  7
  6
  5
  4
  3
  2
  1
DATA END

CODE SEG:
    addi    $ 4 ,    $ 0 ,     512   #当然也可以写成 addi $4, $0, 0x200
    lw    $ 3 ,    $ 4 ,     0     #还可以写成 lw $3, 0($4)
    add    $ 2 ,    $ 3 ,    $ 0
    addi    $ 1 ,    $ 4 ,     4
    swi     2
    addi    $ 5 ,    $ 0 ,     1
    add    $ 11 ,    $ 3 ,    $ 3
    add    $ 11 ,    $ 11 ,    $ 11
    add    $ 11 ,    $ 11 ,    $ 4
    addi    $ 11 ,    $ 11 ,     4
    addi    $ 6 ,    $ 4 ,     4


L4:    slt    $ 9 ,    $ 6 ,    $ 11
    beq    $ 9 ,    $ 0 ,    L1
    lw    $ 8 ,    $ 6 ,     0     #$ 8 = key
    addi    $ 7 ,    $ 6 ,     - 4     #A + j  =  A + i  - 4
L3:    slt    $ 9 ,    $ 4 ,    $ 7
    beq    $ 9 ,    $ 0 ,    L2
    lw    $ 10 ,    $ 7 ,     0
    slt    $ 9 ,    $ 8 ,    $ 10
    beq    $ 9 ,    $ 0 ,    L2        #$
    sw    $ 10 ,    $ 7 ,     4         #
    addi    $ 7 ,    $ 7 ,     - 4
    beq    $ 0 ,    $ 0 ,    L3
L2:    sw    $ 8 ,    $ 7 ,     4
    addi    $ 6 ,    $ 6 ,     4     
    beq    $ 0 ,    $ 0 ,    L4
L1:    swi     2  #swi 2为系统调用,显示内存中的一段数据,$1为基址,$2为长度
    swi     1  #swi 1为系统调用,退出程序,是我们自定义的
CODE END
    

呵呵,是一个Insert Sort排序,对上面的十个数排序.

要生成二进制代码和二进制文件.我的Lex/Yacc的程序是在控制台里运行,标准输入输出.文件只需使用管道就好.

下面首先是lex文件:

 

% {
#include  " myp.tab.h "
extern   " C " {
     int  yywrap( void );
     int  yylex( void );
    }
 % }
 % x cc     //用来处理注释
 %%
" 0x "         {     return  HEX;    }    //处理16进制
 " CODE SEG "     {     return  CODEBEG;    }
 " CODE END "     {     return  CODEEND;    }
 " DATA SEG "     {     return  DATABEG;    }
 " DATA END "     {     return  DATAEND;    }
 " lw "         {     return  LW;    }
 " sw "         {     return  SW;    }
 " add "         {     return  ADD;    }
 " addi "         {     return  ADDI;    }
 " sub "         {     return  SUB;    }
 " subi "         {     return  SUBI;    }
 " mult "         {     return  MULT;    }
 " multi "         {     return  MULTI;    }
 " swi "         {     return  SWI;    }
 " jmp "         {     return  JMP;    }
 " slt "         {     return  SLT;    }
 " beq "         {     return  BEQ;    }
 " bne "         {     return  BNE;    }
 " swp "         {     return  SWP;    }
[ 0 - 9 ] +         {    
            yylval.ival  =  atoi(yytext);
             return  NUMBER;
        }
[a - zA - Z_][ 0 - 9a - zA - Z_] *  {
            strcpy(yylval.imm,yytext);
             return  ID;
        }
 " ( "         {     return   ' ( ' ;    }
 " ) "         {     return   ' ) ' ;    }
 " : "         {     return   ' : ' ;    }
 " , "         {     return   ' , ' ;    }
 " $ "         {     return   ' $ ' ;    }
 " - "         {     return   ' - ' ;    }
[ /t] | [/n]    ;
 " # "         {    BEGIN cc;    }
 < cc > (.) *     {    ;        }
 < cc > " "     {    BEGIN  0 ;    }

 %%
int  yywrap( void )
{
     return   1 ;
}

呵呵,下面是Yacc文件

 

% {
#include < iostream >
#include < string >
#include < fstream >
#include  " src/func.h "
// #include "inc/func.cpp"
using   namespace  std;
 extern   " C " {
     void  yyerror( const   char   * s);
     extern   int  yylex( void );
}
 // extern int yylex();
 // mylexer lexer;

char  bin[MAX][ 33 ];  //用来记录生成的01字符串结果
 int  binNum  =   0 ;  //记录指令条数
 int  data[MAX];  //记录数据段数据
 int  dataNum  =   0 ;  //数据段数目
 int  curPC  =   0 ;  //当前处理的PC值
 int  dataInd  =   0 ;  //
 char  pindex[max][ 33 ];  //标签的名称
 int  indPo[max];   //用来记录标签对应的位置,这里是PC值,不过因为PC值和当前的指令位置有4倍关系
 int  indexNum  =   0 ;  //记录标签的数目
//条件转移时
 char  backId[max][ 33 ];  //需要回填的标签
 int  backPo[max];  //要回填的标签所在的指令位置
 int  backPC[max];  //要回填的标签所在的PC值
 int  backNum  =   0 ;  //要回填的标签数目

//非条件转移,因为只是为了简单的实现InsertSort函数,所以现在的指令系统中没有非条件转移指令
//不过设计时加上了
char  jbackId[max][ 33 ];  //要回填的JMP标签
 int  jbackPo[max];  //要回填的JMP标签位置
 int  jbackNum  =   0 ;  //回填的JMP数目
 % }

 % union {
     char  imm[ 33 ];
     char  opName[ 6 ];
     int  ival;
}
 % start PROGRAM
 % token ADDI ADD SUB SUBI LW SWI SW MULT MULTI DATABEG DATAEND CODEBEG CODEEND BEQ BNE SLT JMP SWP HEX
 % token < imm >  ID 
 % type < opName >  I_OP R_OP J_OP
 % token < ival >  NUMBER 
 % type < ival > IMM
 %%

PROGRAM: {
 //     cout<<"world"<<endl;
       }DATASEG CODESEG{
    fillback();
     // cout<<"fillback ok"<<endl;
     int  i;
     for (i  =   0 ;i <  binNum;i ++ )
        cout << bin[i] << endl;

       }
    ;
DATASEG: DATABEG  ' : '  DATA DATAEND{
     int  i  =   0 ;
     char  temp[ 33 ];
     for (i  =   0 ;i  <  dataNum; i ++ ){
        int2bin32(data[i],temp);
        strcpy(bin[i + 2 ],temp);
    }
    binNum  =  dataNum  +   2 ;
 //     printf("data ok ");
       }
    ;
DATA:    IMM {data[dataNum ++ ]  =  $ 1 ;} DATA
     |  
    ;
CODESEG:CODEBEG  ' : '  CODE CODEEND{
 //     cout<<"CODESEG OK"<<endl;
    }
       ;
CODE:    STATE    CODE
     |
    ;
STATE:    ID {
        strcpy(pindex[indexNum],$ 1 );
        indPo[indexNum ++ ]  =  curPC;
    }  ' : '     COMMAND 
    {curPC  +=   4 ;binNum ++ ;} 
      |  COMMAND {curPC  +=   4 ;binNum ++ ;}
     ;
COMMAND:I_COM
        | R_COM
        | J_COM
       ;
I_COM:I_OP  ' $ '  NUMBER  ' , '  IMM  ' ( '   ' $ '  NUMBER  ' ) '
     {
     char  temp[ 17 ];
    strcat(bin[binNum],$ 1 );
    int2bin5($ 3 ,temp);
    strcat(bin[binNum],temp);
    int2bin5($ 8 ,temp);
    strcat(bin[binNum],temp);
    int2bin16($ 5 ,temp);
    strcat(bin[binNum],temp);
     }
      | I_OP  ' $ '  NUMBER  ' , '   ' $ '  NUMBER  ' , '  IMM
     {
     char  temp[ 17 ];
    strcat(bin[binNum], $ 1 );
    int2bin5($ 3 ,temp);
    strcat(bin[binNum],temp);
    int2bin5($ 6 ,temp);
    strcat(bin[binNum],temp);
    int2bin16($ 8 , temp);
    strcat(bin[binNum],temp);
     }
      |     I_OP  ' $ '  NUMBER  ' , '   ' $ '  NUMBER  ' , '  ID
     {
     char  temp[ 17 ];

    strcpy(bin[binNum],$ 1 );
    int2bin5($ 3 ,temp);
    strcat(bin[binNum],temp);
    int2bin5($ 6 ,temp);
    strcat(bin[binNum],temp);
    strcpy(backId[backNum],$ 8 );
    backPC[backNum]  =  curPC;
    backPo[backNum ++ ]  =  binNum;
    
     }
      |  I_OP  ' $ '     NUMBER  ' , '   ' $ '  NUMBER
     {
 //     cout<<"swp"<<endl;
     char  temp[ 17 ];
    strcpy(bin[binNum],$ 1 );
    int2bin5($ 3 ,temp);
    strcat(bin[binNum], temp);
    int2bin5($ 6 ,temp);
    strcat(bin[binNum],temp);
    strcat(bin[binNum], " 0000000000000000 " );
    }
    ;
R_COM: R_OP  ' $ '  NUMBER  ' , '   ' $ '  NUMBER  ' , '   ' $ '  NUMBER
     {
     char  temp[ 6 ];
    strcpy(bin[binNum],$ 1 );
    int2bin5($ 3 ,temp);
    strcat(bin[binNum],temp);
    int2bin5($ 6 ,temp);
    strcat(bin[binNum],temp);
    int2bin5($ 9 ,temp);
    strcat(bin[binNum],temp);
    strcat(bin[binNum], " 00000000000 " );
    }
     ;
J_COM: J_OP ID{
    strcpy(bin[binNum],$ 1 );
    strcpy(jbackId[jbackNum],$ 2 );
    jbackPo[jbackNum]  =  binNum;
     }
      |  J_OP NUMBER{
    strcpy(bin[binNum],$ 1 );
     char  temp[ 27 ];
     if ( ! int2bin26($ 2 ,temp))
        cout << " J_op Number:failed " << endl;
    strcat(bin[binNum],temp);
    }
     ;
I_OP:    ADDI    { int2bin6(opAddi,$$);}
     |  SUBI    { int2bin6(opSubi,$$);}
     |  MULTI    { int2bin6(opMulti,$$);}
     |  LW    { int2bin6(opLw,$$);}
     |  SW    { int2bin6(opSw,$$);}
     |  BEQ    { int2bin6(opBeq,$$);}
     |  BNE    { int2bin6(opBne,$$);}
     |  SWP    { int2bin6(opSwp,$$);}
    ;
R_OP:    ADD    { int2bin6(opAdd,$$);}
     |  SUB    { int2bin6(opSub,$$);}
     |  MULT    { int2bin6(opMult,$$);}
     |  SLT    { int2bin6(opSlt,$$);}
    ;
J_OP: JMP    { int2bin6(opJmp,$$);}
     |  SWI    { int2bin6(opSwi,$$);}
    ;
IMM: NUMBER    { $$  =  $ 1 ;}
    |  HEX NUMBER    { $$  =  hex2dec($ 2 );    }
    |   ' - '  NUMBER    { $$  =   0 - $ 2 ;}
   ;
 %%
void  yyerror( const   char * s)
{
     extern   int  yylineno;
    cout << " error:  " << s << " : line " << yylineno << endl;
}
 int  main( int  args, char   * argv[])
{
 /*     parse parser;
    if(args<=2)
        cout<<"no file indicated"<<endl;
    ifstream *fin = new ifstream(argv[1]);
    if(!fin){
        cout<<"Can't open file: "<<argv[1]<<endl;
        return 1;
    }
    lexer.yyin = fin;
    int n = 1;
    if(parser.yycreate(&lexer)){
        if(lexer.yycreate(&parser)){
            n = parser.yyparser();
        }
    }
     */
//     printf("hello ");
    yyparse();
     return   0 ;
}



    

然后是func.cpp和func.h文件,两个文件放在src子目录里面

func.h

 

#ifndef FUNC_H
 #define  FUNC_H
#define  MAX 1000
#define  max 100

#define  opAdd 1
#define  opAddi 2
#define  opSlt 3
#define  opBeq 4
#define  opLw 5
#define  opSw 6
#define  opSwi 7 
#define  opSwp 8

#define  opBne 0
#define  opJmp 0
#define  opSub 0
#define  opSubi 0
#define  opMult 0
#define  opMulti 0



bool  int2bin5( int  a,  char   * b);
 bool  int2bin16( int  a,  char   * b);
 bool  int2bin26( int  a, char   * b);
 bool  int2bin6( int  a, char   * b);
 bool  int2bin32( int  a, char   * b);
 bool  fillback();
 int  hex2dec( int  a);
 #endif

 

func.cpp

 

#include "func.h"
#include<iostream>
using namespace std;
#define MAX 1000
#define max 100
bool int2bin5(int a,char *b) //regNum  转化寄存器号成5位01字符串
{
 int i = 0;
 unsigned int base = 16;
 for(i = 0;i< 5;i++){
  b[i]=( a&base ?'1':'0');
  base /=2;
 }
 b[i] = '/0';
 return true;
}
bool int2bin6(int a,char *b)    //opCode,操作码 占六位
{
 int i = 0;
 unsigned int base = 32;
 for(i = 0;i< 6;i++){
  b[i] = (a&base?'1':'0');
  base/=2;
 }
 b[i] = '/0';
 return true;
}
bool int2bin26(int a,char *b)  //J型指令的立即数转换
{
 int i = 0;
 unsigned int base;
 base = (1<<25);
 if(a>0&&(a&base))
  return false;
 if(a<0&&!(a&base))
  return false;
 for(i = 0;i<26;i++){
  b[i] = (a&base?'1':'0');
  base >>=1;
 }
 b[i] = '/0';
 return true;
  
}
bool int2bin16(int a,char *b)  //I型指令的立即数转换
{
 int i = 0;
 unsigned int base = (1<<15);
 if(a>0&&(a&base))
  return false;
 if(a<0&&!(a&base))
  return false;
 for(i = 0;i< 16;i++){
  b[i] = (a&base?'1':'0');
  base>>=1;
 }
 b[i] = '/0';
 return false;
}
bool int2bin32(int a,char *b)  //数据段的数据转换
{
// cout<<"int2bin32:"<<a<<endl;
 int i = 0;
 unsigned int base = (1<<31);
 if(a>0&&(a&base))
  return false;
 if(a<0&&!(a&base))
  return false;
 for(i = 0;i< 32;i++){
  b[i] = (a&base?'1':'0');
 // cout<<base<<endl;
  base>>=1;
 }
 b[i] = '/0';
 //cout<<b<<endl;
 return false;
}

bool fillback()   //回填
{
 
 extern char pindex[max][33],bin[MAX][33],
        backId[max][33],jbackId[max][33];
 extern int backPo[max], backNum,backPC[max];
 extern int jbackPo[max],jbackNum;
 extern int indPo[max],indexNum;
 extern int dataNum,binNum;
 //cout<<"fillback begins"<<endl;
 int i = 0,j = 0, offset;
 char temp[33];
 //cout<<"back fill Num:"<<backNum<<" and indexNum is "<<indexNum<<endl;
 for(i = 0;i < backNum;i++){
  //cout<<"This time "<<backId[i]<<endl;
  for(j = 0;j < indexNum;j++){
   if(strcmp(backId[i],pindex[j])==0)
    break;
  }
  if(j == indexNum){
   cout<<backId[i]<<" not found"<<endl;
   return false;
  }
  offset = (indPo[j]-backPC[i])/4;
  int2bin16(offset,temp);
  strcat(bin[backPo[i]],temp);
  //cout<<i<<"hello"<<endl;
 }

 //cout<<"backfill ok"<<endl;
//非条件转移
 for(i = 0;i< jbackNum;i++){
  for(j = 0;j< indexNum;j++){
   if(strcmp(jbackId[i],pindex[j])==0)
     break;
  }
  if(j == indexNum){
   cout<<jbackId[i]<<"not found"<<endl;
   return false;
  }
  int2bin26(indPo[j],temp);
  strcat(bin[jbackPo[i]],temp);
 }
//完成程序开头的设置,第一个为指令数目,第二个是起始地址
// cout<<"jback ok"<<endl;
 int2bin32(binNum -2,temp);
 strcpy(bin[0],temp);
 int2bin32(0x200 + dataNum*4,temp);
 strcpy(bin[1],temp);
 return true;
}
int hex2dec(int a)  //16进制处理
{
 int res = 0;
 int base = 1;
 while(a!=0){
  res += (a%10)*base;
  base *= 16;
  a /= 10;
 }
// cout<<res<<endl;
 return res;
}

接着就是Makefile了

 

LEX = flex
YACC = bison
CPP = g ++
CC = gcc
all:myasm 
myasm:lex.yy.o myp.tab.o func.o
    $(CPP) lex.yy.o myp.tab.o func.o  - o myasm

func.o:src / func.cpp src / func.h
    $(CPP)  - c src / func.cpp  - o func.o
lex.yy.o:lex.yy.c myp.tab.h 
    $(CPP)  - c lex.yy.c 

myp.tab.o:myp.tab.c
    $(CPP)  - c myp.tab.c

myp.tab.c myp.tab.h:myp.y
    $(YACC)  - d myp.y

lex.yy.c:myassm.l myp.tab.h 
    $(LEX) myassm.l 
clean:
    rm  - f  * .o  * .c  * .h
    rm  - f  * .bin  * .txt

嘿嘿,这就是整个代码,在debian 3.1r5,gcc g++版本为4.1.2,flex,bison 环境下运行很正常.
polisan
关注
用lex与yacc构造汇编器vasm及其指令模拟器vsim
11-15
用lex与yacc构造汇编器vasm及其指令模拟器vsim vasm及vsim源于Designing Digital Computer Systems with Verilog一书中定义的VeSPA（一个小型的RISC指令集的CPU）的指令集。 vasm通过两遍扫描的方式将VeSPA的汇编程序翻译为机器指令。 vsim模拟CPU的取指->译码->执行的循环完成机器指令的逐条执行，直到遇到停机或者运行时错误为止。 阅读及DIY该代码，你将深入理解并学会：1.两遍扫描的汇编器的工作原理，及其汇编器的设计和程序编写。2.lex与yacc工具在汇编器器和指令模拟器的构造过程中的应用。3.CPU的指令执行过程。4.对理解计算机体系结构有参考意义。5.提供了若干.asm汇编源程序样例以进行程序测试。 /////README file ############################################################## # README file for VeSPA assembler & instruction simulation # snallieATtomDOTcom # Sat Nov 15 13:44:43 CST 2014 ############################################################## 1.to build # make or # make clean; make then vasm and vsim be made 2.run vasm # ./vasm ./asm_example/count.org.asm then ./asm_example/count.org.hx produced 3. run vsim # ./vsim ./asm_example/count.org.hx snapshot of vsim as the following: [root@rh9 vas]# ./vsim ./asm_example/count.org.hx Designing Digital Computer Systems with Verilog, 2005 David J. Lilja and Sachin S. Sapatnekar http://www.arctic.umn.edu/vespa/ VeSPA Instruction Interactive Simulator. version 0.01 snallieATtomDOTcom, Thu May 2 05:40:37 CST 2013 built: Nov 15 2014 - 13:51:25 hint: 'h' or '?' for help CPU_endian = BIG [r]>> u 0 1c @0000 50000018 | LD r0 , 0x18 @0004 58400000 | LDI r1 , #0 @0008 08430001 | ADD r1 , r1 , #0x1 @000c 38020000 | CMP r1 , r0 @0010 46fffff4 | BLE 0x8 @0014 f8000000 | HLT @0018 0000000a | NOP @001c 00000000 | NOP [w]>> w a All watch registers enabled. [w]>> t 0004: 58400000 LDI r1 , #0 @0008 08430001 ADD r1 , r1 , #0x1 PC =00000008 N=0 Z=0 C=0 V=0 r0 =0000000a r1 =00000000 r2 =00000000 r3 =00000000 r4 =00000000 r5 =00000000 r6 =00000000 r7 =00000000 r8 =00000000 r9 =00000000 r10=00000000 r11=00000000 r12=00000000 r13=00000000 r14=00000000 r15=00000000 r16=00000000 r17=00000000 r18=00000000 r19=00000000 r20
一个简洁小巧的汇编器 hasm
01-03
学习intel指令集时实现的一个实验性质的汇编器，参考了nasm的一些内容，结构非常之简单，适合用于单片机汇编器的二次开发
cpp-HelloWorld执行的最小指令集和汇编器编译器
08-15
“Hello World”执行的最小指令集和汇编器/编译器
linux下lex词法分析器,Lex词法分析器
weixin_29630465的博客
05-15 791
LEX/FLEX词法分析器CONTENTS：[TOC]这篇文章的内容包括：lex语法格式linux下flex的安装和使用flex实例flex源代码的编译和使用Lex/Flex词法分析器Lex是LEXical compiler的缩写，是Unix环境下非常著名的工具,主要功能是生成一个词法分析器(scanner)的C源码,描述规则采用正则表达式(regular expression)。描述词法分析器的...
linux下编译 lex,ubuntu下安装lex,yacc
weixin_31974659的博客
05-05 981
最近在看这本书。不过发现需要安装编译工具 lex, yacc。书上说Linux自带lex, yacc。不过我发现我的没有。并且，ubuntu不使用lex, yacc。输入sudo apt-get install yacc lex会报错, 报错内容如下:Reading package lists... DoneBuilding dependency treeReading state informa...
c语言编译器，用lex和yacc工具完成词法分析与语法分析并生成语法树
10-19
在这个项目中，我们将关注两个关键的编译工具：lex（也称为flex）和yacc（或其现代变体bison），它们分别用于词法分析和语法分析。 1. **词法分析（Lex/Flex）**： - Lex是一个词法分析器生成器，它根据用户定义的...
掌握lex与yacc：vasm汇编器与vsim模拟器实战指南
在深入探讨“用lex与yacc构造汇编器vasm及其指令模拟器vsim”的主题之前，我们首先需要了解几个关键概念。 汇编器（assembler）是一种将汇编语言转换成机器语言的程序。汇编语言是一种低级语言，指令接近于机器语言...
Linux下51汇编器的设计及实现.pdf
09-07
总之，《Linux下51汇编器的设计及实现》一文详细介绍了如何在Linux环境中利用flex和bison开发51汇编器的过程，对于系统开发者和嵌入式工程师来说，是一篇极具参考价值的专业指导文献。通过阅读和实践，读者可以掌握...
CParser工具：结合lex与yacc实现C/C++语法树输出
### 知识点详解 #### 标题分析 ...文件“cparser.rar”很可能包含了一份用lex和yacc工具实现的C/C++编译器或解释器的源代码及其相关文档，这对于学习和理解编译原理以及实际的编译器设计具有极高的价值。
linux终端lex程序运行,lex的简单使用
weixin_39549110的博客
05-04 1568
Lex & Flex 简介Lex是lexical compiler的缩写，是Unix环境下非常著名的工具， Lex (最早是埃里克·施密特和 Mike Lesk 制作)是许多 UNIX 系统的标准词法分析器(lexical analyzer)产生程式，而且这个工具所作的行为被详列为 POSIX 标准的一部分。Lex的基本工作原理为：由正则表达式生成NFA，将NFA变换成DFA，DFA经化简...
tinyC-compiler:使用flex，yacc和gnu汇编器制作的精简C编译器
05-19
tinyC编译器 使用flex，yacc和gnu汇编器制作的精简C编译器。 支持常见的C函数，例如int，char和string数据类型的变量声明和赋值，循环，算术运算，函数调用，数组和变量作用域。 使用tinyC进行编译 允许文件执行 chmod +x compile.sh chmod +x test.sh 编译 ./compile.sh filename.c 跑步 ./filename.out 运行测试文件 要运行测试文件夹中提供的所有测试文件， ./test.sh
一个Lex/Yacc完整的示例(可使用C++)
04-27
作者: 胡彦 本框架是一个lex/yacc完整的示例，用于学习lex/yacc程序基本的搭建方法，在linux/cygwin下敲入make就可以编译和执行。 本例子虽小却演示了lex/yacc程序最常见和重要的特征： * lex/yacc文件格式、程序结构。 * 如何在lex/yacc中使用C++和STL库，用extern "C"声明那些lex/yacc生成的、要链接的C函数，如yylex(), yywrap(), yyerror()。 * 重定义YYSTYPE/yylval为复杂类型。 * 用%token方式声明yacc记号。 * 用%type方式声明非终结符的类型。 * lex里正则表达式的定义、识别方式。 * lex里用yylval向yacc返回属性值。 * 在yacc嵌入的C代码动作里，对记号属性($1, $2等)、和非终结符属性($$)的正确引用方法。 * 对yyin/yyout重赋值，以改变yacc默认的输入/输出目标。 * 如何开始解析(yyparse函数)，结束或继续解析(yywrap函数)。 本例子功能是，对当前目录下的file.txt文件，解析出其中的标识符、数字、其它符号，显示在屏幕上。linux调试环境是Ubuntu 10.04。 总之，大部分框架已经搭好了，你只要稍加扩展就可以成为一个计算器之类的程序，用于《编译原理》的课程设计。 文件列表： lex.l: lex程序文件。 yacc.y: yacc程序文件。 main.hpp: 共同使用的头文件。 Makefile: makefile文件。 file.txt: 给程序解析的文本文件。 使用方法： 1-把lex_yacc_example.rar解压到linux/cygwin下。 2-命令行进入lex_yacc_example目录。 3-敲入make，这时会自动执行以下操作： (1) 自动调用flex编译.l文件，生成lex.yy.c文件。 (2) 自动调用bison编译.y文件，生成yacc.tab.c和yacc.tab.h文件。 (3) 自动调用g++编译、链接出可执行文件main。 (4) 自动执行main，得到如下结果：。 bison -d yacc.y g++ -c lex.yy.c g++ -c yacc.tab.c g++ lex.yy.o yacc.tab.o -o main id: abc id: defghi int: 123 int: 45678 op: ! op: @ op: # op: $ AllId: abc defghi 参考资料：《Lex和Yacc从入门到精通(6)-解析C-C++包含文件》, http://blog.youkuaiyun.com/pandaxcl/article/details/1321552 其它文章和代码请留意我的blog: http://blog.youkuaiyun.com/huyansoft 2013-4-27
linux下lex词法分析器,用Lex设计词法分析器
weixin_35950365的博客
05-15 788
实验内容Exp2使用lex为下述文法语言写一个词法分析器。 -> PROGRAM ; -> BEGIN END. -> VAR ; ->: | : ; - > INTEGER | REAL -> | , -> | ; -> | | | -> := -> IF THEN ELSE -> WHILE D...
linux环境下使用lex进行词法分析
qq_62086562的博客
09-22 1011
这里我给出一个示例，说白了flex就是基于这个源码里面的规则来进行词法分析的，但是这里我就不细讲该源码的书写规范了，可自行搜索。这个示例大概是对一个c程序进行词法分析，但是里面的保留字（reservedWord）可能不太全，这里就是举例一下。解析之后会生成一个名为a.out的文件，可以使用这个文件来进行对需要进行词法分析的data.txt文件进行词法分析，在命令行输入命令。解析之后会生成一个lex.yy.c的文件对该文件进行编译，在命令行输入命令。下面为一个示例，名字是什么都行只要是.l为后缀就好。
Linux C/C++下使用Lex/Yacc构建实现DBMS（Minisql）
最新发布
chen1415886044的博客
03-10 1125
使用Lex可以使得DBMS更有效地解析复杂的SQL语句，同时，由于Lex生成的解析器是高度优化的，因此可以提高数据库系统的性能和响应速度。Lex和Yacc是用于生成词法分析器和语法分析器的工具。在DBMS中，Yacc通常与Lex一起使用，Lex负责生成词法分析器，将输入的文本分解为词法单元，而Yacc则使用BNF（巴科斯-诺尔范式）语法规定的语法规则来定义语法分析器。总的来说，选择C语言、Lex和Yacc作为构建DBMS的工具，是因为它们可以提供高效、灵活和可靠的开发平台，同时具备广泛的支持和使用经验。
汇编器
hengshan的专栏
07-18 1391
汇编器的分类(the category of the assembler)1、MASM（Microsoft Assembler）      masm 6.0 是免费的。微软现在不再发行masm，此功能已经集成在visual studio 中。2、MASM32     是由Stev
yacc/lex linux 下 使用指南
小蜜蜂的专栏
01-07 5491
 关于Parser Generator的使用方法可以到：/html/linuxshijie/20070917/84.html以下文章属林木100版权所有，请勿转载。Lex介绍Lex 通过对.lex或.l文件定义的格式生成一个C语言源码文件，通过编译这个源码，就生成了.lex文件或.l文件定义的编译器。.lex或.l文件的格式分三段:1.全局变量声明部分2.词法规则部分3.函数定义部分以下是一个
如何在Linux（wsl）环境下配置Lex和Yacc（一行代码）
Lxxiaodiao的博客
05-23 779
如何在Linux（wsl）环境下配置Lex和Yacc（一行代码搞定）
yacc 编译 linux,如何编写真正的编译器和使用Yacc、lex构建编译器简介
weixin_35775608的博客
05-09 358
编译器后端一是要考虑目标机器的代码形式，二是要考虑目标操作系统的ABI(应用程序二进制接口)，比如WINDOW下的目标文件是COFF结构，LINUX下是ELF结构，还有OUT结构等等，写操作系统要做成BIN结构。 GCC生成ELF文件格式的目标代码，它的连接器只能读取ELF格式，并生成LINUX下的可执行文件,WINDOWS下使用的是COFF，生成的是PE结构的EXE文件。编译器要考虑两种形式的目...
linux中flex的使用
06-07
Flex是一种用于生成词法分析器的工具，可以将输入的文本流分解为词法单元（token），然后将这些单元传递给语法分析器进行进一步处理。在Linux中，可以通过以下步骤使用Flex： 1.编写一个Flex源文件，通常以“.l”为后缀。该文件包含正则表达式和相应的动作，用于指定如何识别和处理文本流中的词法单元。 2.使用Flex命令生成词法分析器的C代码。例如，使用以下命令将Flex源文件“lexer.l”转换为C代码： flex lexer.l 该命令将生成一个名为“lex.yy.c”的文件，其中包含生成的C代码。 3.编译生成的C代码并链接到你的程序中。例如，使用以下命令将生成的C代码编译为可执行文件： gcc lex.yy.c -o lexer 4.运行生成的可执行文件，将文本流输入到程序中并观察输出结果。 以上就是在Linux中使用Flex的基本步骤。需要注意的是，Flex是一种强大的工具，可以用于处理各种不同类型的文本流，因此需要仔细阅读Flex的文档并熟悉其语法和语义。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值