用C语言写的Pascal语言词法分析器

最新推荐文章于 2021-05-20 00:09:52 发布
最新推荐文章于 2021-05-20 00:09:52 发布
阅读量4.2k 收藏 6
点赞数
文章标签： 语言 pascal c buffer token fp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hammerwoo/article/details/669241
版权

虽然只是个词法分析器，但是重拾C语言好难！好久没用过C了。放在这儿勉励自己做事一定要有始有终

/*Trans.c -main,Trans */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
//char *name[]={"begin","1","end","2","integer","3","if","4","then","5","else","6","function","7","read","8","write","9"};
//char *sign[]={"=","<>","<=","<",">=",">","-","*",":=","(",")",";"};
int match_code=0;
char buffer1[256];
char buffer2[256];
char *infile;
char* outfile;
char* errfile;
char token[15];
int token_index=0;
char ch;
int buffer1Empty=1;
int buffer2Empty=1;
int EndofFile=0;


//int reserve_(int* code)  //本来自己写了一个比较保留字段的函数，但是不知道什么原因工作不是很良好，鉴于时间很紧就没有用
//{
//     int match=-1;
//     int i=0;
//     while(i!=18)
//     {
//                match=strcmp(name[i],token);
//    i++;
//                if(match==0)
//                {
//                            *code=i;
//                            break;
//                }
//     }
//     return match;            
//}

//void write_dyd(int code,FILE* fp)  //这个是针对上一个函数的写入文件流的函数，同样也放弃了
//{
//    int blank=16-strlen(name[code]);
//    while(blank!=0)
//    {
//       fputc(' ',fp);
//    blank=blank-1;
//    }
// fputs(name[code],fp);
// fputc(' ',fp);
// fputs(name[code+1],fp);
// fputc('/n',fp);
//}
void ReadIntoBuffer(char buffer[256],FILE* fp)
{
     int i;
     char c;
     char tmp;
     for(i=0;i<255;i++)
     {
       c=fgetc(fp);
       switch(c)
       {
        case ' ':
             tmp=c;
             while(c==' ')
                c=fgetc(fp);
             if(c!=EOF)
             {
                if(c!='/t'&&c!=' ')
                   fseek(fp,-1L,1);
                if(buffer[i-1]!=' ')
                   buffer[i]=tmp;
                else
                   i=i-1;
             }
             else
                buffer[i]=EOF;
             break;
        case '/t':
              while(c=='/t')
                 c=fgetc(fp);
              if(c!=EOF)
              {
                 if(c!='/t'&&c!=' ')    //如果非这些字符，就要把文件当前读取位置往前移
                    fseek(fp,-1L,1);                 
                 if(buffer[i-1]!=' ')                 //如果缓冲区的前一个字符不为空格，就要输入一个空格来分开token
                    buffer[i]=' ';
                 else
                    i=i-1;            //因为这轮for循环缓冲区什么也没有修改，而缓冲区的游标又要被加1，所以这里要把i减1
              }
              else
                 buffer[i]=EOF;        //其他情况就把文件结束符写到缓冲区里面去
              break;
  case EOF:
   buffer[i]=EOF;
            break;
        default:
              buffer[i]=c;
     break;
    }
     }
}
int read_buffer(FILE* fp,int* index) //这个函数从两个缓冲区中的一个读出一个字符赋给全局变量ch，缓冲区空则调用ReadInotBuffer函数写入缓冲区
{
  char* readfrom;                    //readfrom是我设的缓冲区数组的指针
  if(buffer1Empty&&!buffer2Empty)       //缓冲区空与否由两个变量buffer1Empty和buffer2Empty来测定
      readfrom=buffer2;
  else
  {
      if(buffer2Empty&&!buffer1Empty)
           readfrom=buffer1;
      else
   {
          if(buffer1Empty&&buffer2Empty)
          {
              readfrom=buffer1;
              ReadIntoBuffer(readfrom,fp);     //第一次读文件时默认填充缓冲区1
          }
   }
  }
  if(readfrom==buffer1)
       buffer1Empty=0;
  else
  {
      if(readfrom==buffer2)
          buffer2Empty=0;
  }
  if(readfrom[*index]!=EOF&&*index<256)
  {
       ch=readfrom[*index];                  //将ch赋值
       *index=*index+1;
  }
  else
  {
      if(readfrom[*index]==EOF)
      {
          return 1;                      //若读到文件尾，则返回1，1在函数translate中被赋给了全局变量EndofFile,这个全局变量控制了整个translate的while循环
      }
      else
          if(*index>255)
          {
              *index=0;
              readfrom=buffer1Empty?buffer1:buffer2;
              ReadIntoBuffer(readfrom,fp);
              if(readfrom==buffer1)
              {
                 buffer1Empty=0;
                 buffer2Empty=1;
              }                                                  
              else
              {
                  if(readfrom==buffer2)
                  {
                     buffer1Empty=1;
                     buffer2Empty=0;
                  }
              }
              ch=readfrom[*index];
              *index=*index+1;
          }
  }
  return 0;
}
void translate(const char *infile,const char *outfile,const char *errfile)         //词法分析器主要功能函数
{
     FILE *ifp = fopen(infile,"r");
     FILE *ofp = fopen(outfile,"a");
     FILE *efp = fopen(errfile,"a");
     int index=0;                            //index为读缓冲区的下标变量
     int line_number=1;
     while(ifp!=NULL&&!EndofFile)
     {
          printf("token now is %s|/n",token);
          EndofFile=read_buffer(ifp,&index);
          if(isdigit((int)ch)&&!EndofFile)
          {
            while(isdigit((int)ch)&&!EndofFile)
            {
               token[token_index]=ch;
               token_index=token_index+1;
               EndofFile=read_buffer(ifp,&index);
            }
            token[token_index]='/0';
            token_index=0;
            index=((index-1)==-1)?255:index-1;     //每个缓冲区为256个字符，若回退下标的时候处在缓冲区头，则切换到上一次读的缓冲区尾
            int blank=16-strlen(token);
            while(blank!=0)
            {
                fputc(' ',ofp);
                blank=blank-1;
            }
            fputs(token,ofp);
            fputc(' ',ofp);
            fputs("11/n",ofp);
            continue;
          }
          if(isalpha((int)ch)&&!EndofFile)
          {
              while((isalpha((int)ch)||isdigit((int)ch))&&!EndofFile)
              {
                  token[token_index]=ch;
                  token_index=token_index+1;
                  EndofFile=read_buffer(ifp,&index);
              }
              token[token_index]='/0';
              token_index=0;
              index=((index-1)==-1)?255:index-1;
              if(!strcmp(token,"begin"))
              {
                 fputs("           begin 1/n",ofp);
                 continue;
              }
              if(!strcmp(token,"end"))
              {
                 fputs("             end 2/n",ofp);
                 continue;
              }
              if(!strcmp(token,"integer"))
              {
                 fputs("         integer 3/n",ofp);
                 continue;
              }
              if(!strcmp(token,"if"))
              {
                 fputs("              if 4/n",ofp);
                 continue;
              }
              if(!strcmp(token,"then"))
              {
                               fputs("            then 5/n",ofp);
                               continue;
              }
              if(!strcmp(token,"else"))
              {
                               fputs("            else 6/n",ofp);
                               continue;
              }
              if(!strcmp(token,"function"))
              {
                                   fputs("        function 7/n",ofp);
                                   continue;
              }
              if(!strcmp(token,"read"))
              {
                         fputs("            read 8/n",ofp);
                         continue;
              }
              if(!strcmp(token,"write"))
              {
                                fputs("           write 9/n",ofp);
                                continue;
              }                                                                   
              else
              {
                  int blank=16-strlen(token);
                  while(blank!=0)
                  {
                      fputc(' ',ofp);
                      blank=blank-1;
                  }
                  fputs(token,ofp);
                  fputc(' ',ofp);
                  fputs("10/n",ofp);
              }
   continue;
          }
          if((ch=='=')&&!EndofFile)
          {
                     fputs("               = 12/n",ofp);
                     continue;
          }
          if((ch=='<')&&!EndofFile)
          {
               EndofFile=read_buffer(ifp,&index);
               if((ch=='=')&&!EndofFile)
               {
                    fputs("              <= 14/n",ofp);
                    continue;
               }
               else
               {
                   if((ch=='>')&&!EndofFile)
                   {
                       fputs("              <> 13/n",ofp);
                       continue;
                   }
                   else
                   {
                       if(!EndofFile)
                       {
                        fputs("               < 15/n",ofp);
                        index=((index-1)==-1)?255:index-1;
                        continue;
                       }
                       else
                       {
                           fputs("             EOF 25/n",ofp);
                           break;
                       }
                   }
               }
          }
          if((ch=='>')&&!EndofFile)
          {
              EndofFile=read_buffer(ifp,&index);
              if((ch=='=')&&!EndofFile)
              {
                 fputs("              >= 16/n",ofp);
                 continue;
              }
              else
              {
                  if(!EndofFile)
                  {
                       index=((index-1)==-1)?255:index-1;
                       fputs("               > 17/n",ofp);
                       continue;
                  }
                  else
                  {
                      fputs("             EOF 25/n",ofp);
                      break;
                  }
              }
          }
          if((ch=='-')&&!EndofFile)
          {
              fputs("               - 18/n",ofp);
              continue;
          }
          if((ch=='*')&&!EndofFile)
          {
              fputs("               * 19/n",ofp);
              continue;
          }
          if((ch==':')&&!EndofFile)
          {
              EndofFile=read_buffer(ifp,&index);
              if((ch=='=')&&!EndofFile)
              {
                  fputs("              := 20/n",ofp);
                  continue;
              }
              else
              {
                  if(!EndofFile)
                  {
                      index=((index-1)==-1)?255:index-1;
                      fprintf(efp,"%d ':' is not defined",line_number);
                      continue;
                  }
                  else
                  {
                      fputs("             EOF 25/n",ofp);
                      break;
                  }
              }
          }
          if((ch=='(')&&!EndofFile)
          {
              fputs("               ( 21/n",ofp);
              continue;
          }
          if((ch==')')&&!EndofFile)
          {
              fputs("               ) 22/n",ofp);
              continue;
          }
          if((ch==';')&&!EndofFile)
          {
              fputs("               ; 23/n",ofp);
              continue;
          }                 
                 
          if((ch=='/n')&&!EndofFile)
          {
              fputs("            EOLN 24/n",ofp);
              line_number=line_number+1;
              continue;
          }
     }
     fputs("             EOF 25/n",ofp);
     fclose(ifp);
     fclose(ofp);
     fclose(efp);
}           
             
     
     
int main(int argc, char *argv[])
{
  switch(argc)                                //处理命令行参数
  {
             case 1:
                  infile="input.txt";         
         outfile="output.txt";
         errfile="error.txt";
         break;
             case 2:
                  infile = argv[1];
                  outfile="output.txt";
         errfile="error.txt";
         break;
             case 3:
                  infile = argv[1];
                  outfile = argv[2];
                  errfile="error.txt";
                  break;
             case 4:
                  infile = argv[1];
                  outfile = argv[2];
                  errfile = argv[3];
                  break;
             default:
                     fprintf(stderr,"usage:Trans [Infile path] [outfile path] [error log path]/n");
                     exit(-1);
  }
  translate(infile,outfile,errfile);
  system("PAUSE"); 
}

 

 

       


hammerwoo
关注
PASCAL语言子集的词法、语法分析器之实现
weixin_34008933的博客
08-18 2535
针对简单的文法（PASCAL语言子集），制作相应的词法分析器和递归下降的语法分析器。        文法要求如下： 1、  关键字、标识符、数字等： 1.begin         2.if             3.then         4.while       5.do            6.end          10.标识符           11.数字 13.+...
用Lex编写的简易版C语言词法分析器（编译原理大作业1）
热门推荐
never_say_never7的博客
11-16 1万+
本文讲解关于如何用lex工具来编写一个简易版的C语言的词法分析器。
pascal语言的词法分析器
01-05
东华大学 姚砺 pascal语言的词法分析器，全部实现
用c实现pascal词法分析器
hengshan的专栏
05-20 3861
#include "define.h"#include #include #include #include FILE *fp;/*//////////////////////////////////////////////////////////////////////////////This is a pretreatment./////////////////////////////////
Pascal语言子集词法分析器
wangjiaoni的专栏
05-28 4405
  编译原理实验实战 作者: falcon   发表日期: 2006-04-07 17:47   编译原理课程设计实现一，概述1、词法分析2、语法分析3、语义分析相关资料：1）实验教材信息学院ftp>in
Pascal Compiler(词法分析+语法分析)C语言版
12-03
Pascal 词法分析 语法分析 C语言 Pascal Compiler(词法分析+语法分析)C语言版
Pascal词法分析器 源代码 实验报告
11-16
总的来说，这个实验旨在让学习者理解并实现一个基本的Pascal词法分析器，这不仅加深了对Pascal语言的理解，也有助于掌握编译器设计的基本概念和技术。通过这个过程，学生可以更好地理解编程语言的解析过程，为将来...
词法分析器_编译原理
06-30
编译原理中的词法分析，对于入门者来说是非常友好的。
词法分析示例程序（C语言编写，针对PL/0语言)
06-16
词法分析器，也称为扫描器，其主要任务是对源代码进行逐字符扫描，并依据预定义的构词规则识别出一个个有意义的单词，即单词符号或符号。这些单词符号可以是关键字、标识符、常量、运算符或其他特殊的符号。在此，...
编译原理上机作业-词法分析程序实现（PASCAL简单词法分析器）
06-02
压缩文档里包括源代码和PASCAL词法分析器的设计要求等。
Pascal词法分析程序
01-09
Pascal词法分析程序 procedure TForm1.cmdCreateClick(Sender: TObject); var KeyInfo: KEY_INFO; begin KeyInfo.KeyName:='key_name_age'; KeyInfo.KeyType:=KEY_DUPLICATED; KeyInfo.KeyFieldCount:=2; KeyInfo.KeyFieldNo[0]:=1; KeyInfo.KeyFieldCase[0]:=KEY_FIELD_CASE; KeyInfo.KeyFieldPos[0]:=0; KeyInfo.KeyFieldLen[0]:=32; KeyInfo.KeyFieldNo[1]:=2; if mCreateField('Number',FIELD_INTEGER)=1 then if mCreateField('Name',FIELD_STRING,32)=1 then if mCreateField('Age',FIELD_SMALLINT)=1 then if mCreateField('Score',FIELD_DOUBLE)=1 then if mCreateKey('Key_num',KEY_UNDUPLICATED,0)=1 then if mCreateKey('Key_name',KEY_DUPLICATED,1)=1 then if mCreateDB('test.sdb')=1 then ShowMessage('Create DB Sucessfully'); end; end.
类pascal语言的词法分析程序
12-09
能识别基本pascal语言，输入二元式，很好很强大，下下就知道了
用C++语言编写Pascal语言词法语法器
05-25
这是做毕业设计的时候找到的资料，很有用。词法和语法分析封装在一个类CFenXi中, 程序在Visual C++6.0下调试通过. 程序采用单文档设计,利用了分割窗体技术。这个软件用Visual C++6.0的MFC设计的，它的界面设计没问题，这个我试过，只是它分析的是Pascal语言代码。这个资源里附带了一个exe文件，可以直接运行。还有一个说明文档。说真的，这是我见过的资料最齐全的词法语法器软件了。很有用。
编译原理Pascal语言编译器用C实现
12-10
编译原理 Pascal 编译器 C语言实现 编译原理 Pascal 编译器 C语言实现 编译原理 Pascal 编译器 C语言实现 编译原理 Pascal 编译器 C语言实现 编译原理 Pascal 编译器 C语言实现
类 Pascal语言词法分析实验（简易版）
Cheney ' blog
04-05 2802
一、 实验目的 设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。 二、 实验要求 2.1 待分析的简单的词法 （1）关键字： begin if then while do end 所有的关键字都是小写。 （2）运算符和界符 ： = + - * / < <= <> > >= = ; ( ) # （3）其他单词是标识符（ID）和整型常数（SUM），通过以下正规式定义： ID = letter (letter | dig
编译原理----词法分析器实现（C）
cike110120的专栏
05-29 8700
编译原理是计算机科学与技术专业的一门重要专业课程。课程旨在对整个编译过程和技术作一重点介绍，使学生具有设计、实现编译程序的基本技能，清楚了解高级语言程序到机器语言程序的转换步骤。并为进一步学习形式语言与自动机、软件工程打下坚实的基础。 实验是对学生的一种全面综合训练，是与课堂听讲、自学和练习相辅相成的必不可少的一个教学环节。通常，实验中的问题比平时的练习题要复杂，也更接近实际。编译原理这门课程安
c语言的适当大小的子集,使用直接分析法编制C语言子集的词法分析程序..doc
weixin_42465158的博客
05-19 319
一、题目使用直接分析法编制C语言子集的词法分析程序二、目的通过设计、编制、调试一个具体的词法分析程序，加深对词法分析原理的理解，并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法．三、要求1. 根据具体情况，由同学们自己选取C 语言的一个适当大小的子集(可取一类典型单词，也可以尽可能使各种类型的单词都兼顾到)；在实习前一定要制出相应的表．2. 实验时间：4－8学时．3. 检...
通过状态转换图构造c或者pascal语言子集的词法分析程序.,词法分析程序的构造讲解.doc...
weixin_33814002的博客
05-20 280
词法分析程序的构造讲解通达学院专业课程设计II题 目： 词法分析程序的构造专 业 计 算 机 通 信学 生 姓 名班 级 学 号 28班指 导 教 师 徐 佳指 导 单 位 计算机学院计算机科学与技术系日 期 2012.11.12-2012.11.23教师评语同学出勤率(满勤、较高、一般...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值