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

最新推荐文章于 2024-05-08 08:26:47 发布
最新推荐文章于 2024-05-08 08:26:47 发布
阅读量4.1k 收藏 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
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
基于Pascal语言的语法分析器
12-13
包含编译原理实验中的语法分析源程序及实验报告，此语法分析器基于pascal语言，在实验报告中有详细的说明，该语法分析器只能说是小语言语法分析器，文法并不齐全，供大家参考
Pascal词法分析器用java实现
m0_57190341的博客
10-20 402
测试文本用了IO流读取，诸位可以直接定义一个字符串当测试文本。也可以在电脑上新建一个txt文件，然后复制自己的文件路径替换掉我的路径。这种思路精妙之处在于定义一个静态变量p当指针，一次扫文本一行当字符串，每扫一行总方法把指针p置零，子方法先判断，判否立刻break，p可以到其他子方法中去。所以虽然总方法和子方法都在循环p，但是遍历过的字符并没有重复遍历。指针定位和回拨是个精细活，诸位可自研之。你们的支持是我更新的最大动力！
编译原理——词法分析程序
最新发布
m0_74219898的博客
05-08 965
分程序>→[<常量说明部分>][<变量说明部分>][<过程说明部分>]<复合语句><语句>→<赋值语句>|<条件语句>|<当型循环语句>|<过程调用语句><过程说明部分>→<过程首部><分程序>；{<过程首部><分程序>；<常量说明部分>→CONST<常量定义>{，<常量定义>}；<条件>→<表达式><关系运算符><表达式> | ODD<表达式><写语句>→WRITE(<表达式>{，<表达式>})<表达式>→[+|-]<项>{<加型运算符><项>}<当型循环语句>→WHILE<条件>DO<语句>
类 Pascal语言词法分析实验（简易版）
Cheney ' blog
04-05 2787
一、 实验目的 设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。 二、 实验要求 2.1 待分析的简单的词法 （1）关键字： begin if then while do end 所有的关键字都是小写。 （2）运算符和界符 ： = + - * / < <= <> > >= = ; ( ) # （3）其他单词是标识符（ID）和整型常数（SUM），通过以下正规式定义： ID = letter (letter | dig
Pascal语言子集词法分析器
wangjiaoni的专栏
05-28 4394
  编译原理实验实战 作者: falcon   发表日期: 2006-04-07 17:47   编译原理课程设计实现一，概述1、词法分析2、语法分析3、语义分析相关资料：1）实验教材信息学院ftp>in
Pascal词法分析器 源代码 实验报告
11-16
总的来说，这个实验旨在让学习者理解并实现一个基本的Pascal词法分析器，这不仅加深了对Pascal语言的理解，也有助于掌握编译器设计的基本概念和技术。通过这个过程，学生可以更好地理解编程语言的解析过程，为将来...
Pascal Compiler(词法分析+语法分析)C语言版
12-03
本项目“Pascal Compiler(词法分析+语法分析)C语言版”是用C语言实现的一个Pascal语言的编译器，它包含了词法分析和语法分析两个核心部分，以及主程序和必要的头文件。下面我们将详细讨论这两个主要阶段以及它们在...
词法分析器_编译原理
06-30
编译原理中的词法分析，对于入门者来说是非常友好的。
编译原理——词法分析器设计与实现
04-30
项目提供了"主程序（改为cpp）.cpp"，这表明词法分析器的实现是用C++语言完成的。C++是一种通用的、面向对象的编程语言，它的性能强大且具有丰富的库支持，非常适合开发这种需要高效处理文本的工具。 "使用说明.txt...
词法分析示例程序（C语言编写，针对PL/0语言)
06-16
词法分析器，也称为扫描器，其主要任务是对源代码进行逐字符扫描，并依据预定义的构词规则识别出一个个有意义的单词，即单词符号或符号。这些单词符号可以是关键字、标识符、常量、运算符或其他特殊的符号。在此，...
编译原理——词法分析代码
05-28
⒈ 题目 编写前述PASCAL子集的词法分析程序。 １）主程序设计考虑，（参阅后面给出的程序框架） 主程序的说明部分为各种表格和变量安排空间。 数组k为关键字表，每个数组元素存放一个关键字。采用定长的方式，较短的关键字后面补空格。 P 数组存放分界符。为了简单起见，分界符、算术运算符和关系运算符都放在p表中（学生编程时，应建立算术运算符表和关系运算符表，并且各有类号），合并成一类。 id 和ci 数组分别存放标识符和常数。 instring 数组为输入源程序的单词缓存。 outtoken 记录为输出内部表示缓存。 还有一些为造表填表设置的变量。 主程序开始后，先以人工方式输入关键字，造 k 表；再输入分界符等造 p 表。 主程序的工作部分设计成便于调试的循环结构。每个循环处理一个单词；接收键盘上送来的一个单词；调用词法分析过程；输出每个单词的内部码。 ２）词法分析过程考虑 该过程取名为 lexical，它根据输入单词的第一个字符（有时还需读第二个字符），判断单词类，产生类号：以字符k表示关键字；i表示标识符；c 表示常数；p 表示分界符；s 表示运算符（学生编程时类号分别为1,2,3,4,5）。 对于标识符和常数，需分别与标识符表和常数表中已登记的元素相比较，如表中已有该元素，则记录其在表中的位置，如未出现过，将标识符按顺序填入数组 id 中，将常数变为二进制形式存入数组中 ci 中，并记录其在表中的位置。 lexical 过程中嵌有两个小过程：一个名为 getchar，其功能为从 instring 中按顺序取出一个字符，并将其指针 pint 加 1 ；另一个名为 error，当出现错误时，调用这个过程，输出错误编号。 将词法分析程序设计成独（入口）立一遍扫描源程序的结构。其流程图见图5-1。 图5-1 词法分析程序流程图 ⒉ 要求 ⑴ 所有识别出的单词都用两个字节的等长表示，称为内部码。第一个字节为 t ，第二个字节为 i 。 t 为单词的种类。关键字的 t=１；分界符的 t=２；算术运算符的 t=３；关系运算符的 t=４；无符号数的 t=５；标识符的 t=６。i 为该单词在各自表中的指针或内部码值。表 5-1 为关键字表；表 5-2 为分界符表；表 5-3 为算术运算符的 i 值；表 5-4 为关系运算符的 i 值。 表5-1 关键字表 表5-2 分界符表 指针1 关键字 指针1 分界符 0 BEGIN 0 ， 1 DO 1 ； 2 ELSE 2 . 3 END 3 := 4 IF 4 ( 5 THEN 5 ) 6 VAR 7 WHILE 表5-3 算术运算符 表5-4 关系运算符 i 值 算术运算符 i 值 关系运算符 00H < 10H + 01H 21H / 04H >= 05H 常数表和标识符表是在编译过程中建立起来的。其 i 值是根据它们在源程序中出现的顺序确定的。 ⑵ 常数分析程序、关键字和标识符分析程序、其他单词分析程序请参阅范例自行设计。 ⑶ 本实践题可通过扩充下面给出的程序框架完成。 PROGRAM plexical(input,output); LABEL l; CONST keylen=10; identlen=10; TYPE //定义的类型 tstring=ARRAY[1..identlen] OF char; outreco=RECORD//记录为输出内部表示缓存。 ty: char; point: integer; END; {outreco} VAR cip,ip,pint,i,j,l,m,errorx:integer; charl:CHAR; ci:ARRAY[1..10] OF integer; k,id:ARRAY[1..keylen] OF tstring; token:tstring; //标志符 outtoken:outreco; instring:ARRAY[1..10]OF char; p:ARRAY[1..16] OF ARRAY [1..2] OF char; PROCEDURE lexical; VAR l,m,num:integer; b: boolean; PROCEDURE
编译原理 词法分析 代码
04-11
用C语言编写一个只包含部分保留字和单词符号（见语言子集L）的PASCAL语言的扫描器（词法分析器）。 1、该词法分析器的任务： （1）滤掉源程序中的无用成分，如空格； （2）输出分类记号供语法分析器使用，并产生两个表格：常数表和标识符表，表的数据结构和包含内容可参看书中第八章符号表； （3）识别非法输入，并将其标记为“出错记号”。 2、该词法分析器的功能： 以在下面段落中定义的PASCAL语言子集的源程序作为词法分析程序的输入数据。词法分析器打开该文件后，自文件头开始扫描源程序字符，发现符合“单词”定义的源程序字符串时，将它翻译成固定长度的单词内部表示，并查填适当的信息表，一旦发现不符合“单词”定义的源程序字符串时，给出错误提示。经过词法分析后，源程序字符串（源程序的外部表示）被翻译成具有等长信息的单词串（源程序的内部表示），并产生两个表格：常数表和标识符表，它们分别包含了源程序中的所有常数和所有标识符。 3、PASCAL语言子集L----保留字不区分大小写 L={ VAR，BEGIN，ELSE，END，IF，THEN，REAL，INTEGER，=，:=，-，+，*，; ，. }∪{常数}∪{标识符} 4、实验要求： （1）词法分析器构造：正规式设计、DFA设计、代码编写； （2）进行词法分析器的测试：测试例程（一小段程序）、测试结果与测试结果分析。 （3）实验报告格式自拟；实验报告中要对实验要求中正规式设计、DFA设计、代码编写、测试例程（3中定义的PASCAL语言子集的源程序段）、测试结果与测试结果分析逐项给予说明。 例子： 本例中单词符号（记号）的种类: 1、保留字； 2、分隔符； 3、运算符； 4、等符 5、常数； 6、标识符 （单词符号的分类可以自己规定，只是要在实验报告中给出说明） 测试例程PASCAL程序清单如下： BEGIN IF I=1 THEN ^ A:=I+1 ELSE *& IF I=2 THEN A:=I+11; END. # 运行词法分析程序后，显示如下结果如下： BEGIN (1,1) IF (1,4) I (6,0) = (4,2) 1 (5,0) THEN (1,5) ^ error, not a word A (6,1) := (2,2) I (6,0) + (3,0) 1 (5,0) ELSE (1,2) * (3,2) & error, not a word IF (1,4) I (6,0) = (4,2) 2 (5,1) THEN (1,5) A (6,1) := (2,2) I (6,0) + (3,0) 11 (5,2) ; (2,1) END (1,3) . (2,3) # error, not a word over 常数表CT：1，2 标识符表LT：I，A
SAMPLE (类pascal) 词法分析程序 C++版
11-17
a) 启动程序后，先输出作者姓名、班级、学号（可用汉语、英语或拼音）； b) 请求输入测试程序名，键入程序名后自动开始词法分析并输出结果； c) 输出结果为单词的二元式序列（样式见样板输出1和2）； d) 要求能发现下列词法错误和指出错误性质和位置： 非法字符，即不是SAMPLE字符集的符号； 字符常数缺右边的单引号（字符常数要求左、右边用单引号界定，不能跨行）； 注释部分缺右边的界符*/（注释要求左右边分别用/*和*/界定，不能跨行）。
【编译原理实验】 -- 词法分析程序设计原理与实现（C语言实现）
热门推荐
张修宇的博客
10-15 1万+
编译原理研究型学习实验：词法分析程序设计原理与实现，使用C语言实现
c语言的适当大小的子集,使用直接分析法编制C语言子集的词法分析程序..doc
weixin_42465158的博客
05-19 295
一、题目使用直接分析法编制C语言子集的词法分析程序二、目的通过设计、编制、调试一个具体的词法分析程序，加深对词法分析原理的理解，并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法．三、要求1. 根据具体情况，由同学们自己选取C 语言的一个适当大小的子集(可取一类典型单词，也可以尽可能使各种类型的单词都兼顾到)；在实习前一定要制出相应的表．2. 实验时间：4－8学时．3. 检...
PASCAL语言子集的词法、语法分析器之实现
weixin_34008933的博客
08-18 2525
针对简单的文法（PASCAL语言子集），制作相应的词法分析器和递归下降的语法分析器。        文法要求如下： 1、  关键字、标识符、数字等： 1.begin         2.if             3.then         4.while       5.do            6.end          10.标识符           11.数字 13.+...
用c实现pascal词法分析器
hengshan的专栏
05-20 3855
#include "define.h"#include #include #include #include FILE *fp;/*//////////////////////////////////////////////////////////////////////////////This is a pretreatment./////////////////////////////////
通过状态转换图构造c或者pascal语言子集的词法分析程序.,词法分析程序的构造讲解.doc...
weixin_33814002的博客
05-20 270
词法分析程序的构造讲解通达学院专业课程设计II题 目： 词法分析程序的构造专 业 计 算 机 通 信学 生 姓 名班 级 学 号 28班指 导 教 师 徐 佳指 导 单 位 计算机学院计算机科学与技术系日 期 2012.11.12-2012.11.23教师评语同学出勤率(满勤、较高、一般...
pascal语言的词法分析器
10-12
Pascal语言的词法分析器通常使用有限状态自动机（finite state automaton）来实现。它将源代码作为输入，逐个字符读取并根据当前状态进行转换，直到识别出一个完整的词法单元。如果遇到无法识别的字符或组合，则会...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值