MiniBasic解析器实现二

最新推荐文章于 2024-09-15 18:25:31 发布
最新推荐文章于 2024-09-15 18:25:31 发布
阅读量929 收藏 2
点赞数
文章标签： fp cmd file command input list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WACR2008/article/details/6067338
版权

上文给出实现的头文件以及演示界面，朋友拿去我这个去参赛，竟然入了决赛，汗一个先，现在给它的实现文件。注释完整，在此基础上大家可以实现自己的迷你脚本解析器。如有问题不要找我也不用告诉我，我是喜新厌旧的人，懒得再动它了。

转载请注明出处，你可以任意的强*它，代码可以按你的爱好去修改，一句话：任你为所欲为吧。

#include "LineNode.h"

LineNode::LineNode(int auto_number)
{
   m_auto_number = auto_number;
   m_auto_line_number =1;
   pHead=0;
}

LineNode::~LineNode()
{
 Clear();
    pHead=0;
}

void LineNode::Clear()
{
 m_auto_line_number =1;
 pLNode pNode =pHead;
 pLNode pTmpNode;
 while(pNode)
 {
    pTmpNode = pNode->next;
    free(pNode);
    pNode= pTmpNode;
 } 
}

pLNode LineNode::AllocNode()
{
 pLNode pNode =(pLNode)malloc(sizeof(LNode));
 pNode->LineNumber           =0;
 pNode->CType                =EUnKnown;
 pNode->OType                =ESet;
 pNode->LeftValue.is_const   =1;
 pNode->LeftValue.value      =0;
 pNode->RightValue.is_const  =1;
 pNode->RightValue.value     =0;
 pNode->RightValue.is_const  =1;
 pNode->ResultValue.is_const =0;
 pNode->Commands[0]          ='/0';

 
 //将新分配的节点放到链表的最后一个节点
 if(0==pHead)
 {
     pNode->prior   =0;
     pHead =pNode;
 }
 else
 {
     pLNode pTempNode =pHead;
  while(0!=pTempNode->next)
  {
   pTempNode= pTempNode->next;
  }

  pTempNode->next = pNode;
     pNode->prior    =pTempNode;
 }
 
 pNode->next              =0;

 return pNode;
}

void LineNode::LoadCommandFromFile(const char *sFileName)
{
      FILE *fp =fopen(sFileName,"r");
   if(NULL==fp)
    return ;

   char sBuffer[2048];
   while(0 !=ReadLine(fp,sBuffer,2048))
   {
      LocalInput(sBuffer);
   }
   fclose(fp);
}

void LineNode::SaveCommandToFile(const char *sFileName)
{
      FILE *fp =fopen(sFileName,"w");
   if(NULL==fp)
    return ;

   pLNode pNode =pHead;
   while(pNode)
   {
         fprintf(fp,"%s /n",pNode->Commands);
   pNode= pNode->next;
   } 
   fclose(fp);
}

void LineNode::PrintCommands(FILE *fp)
{
      pLNode pNode =pHead;
   while(pNode)
   {
         if(NULL==fp)
           printf("%s/n",pNode->Commands);
   else
           fprintf(fp,"%s/n",pNode->Commands);
   pNode= pNode->next;
   } 
}

int LineNode::ParseLineNumber(const char *sBuffer,int *endPos)
{
 int start,end;
 char int_v[128];
 const char *pStartPtr = sBuffer;

 start =0;

 //找到第一个不为空的字符
    while('/0' != *sBuffer)
 {
        if(BLANK_CHAR !=*sBuffer)
       break;

  sBuffer++;
  start++;
     ++(*endPos);
 }

 
    //找到第一个为空的字符
 end   =start;
    while('/0' != *sBuffer)
 {
        if(BLANK_CHAR ==*sBuffer)
       break;

  end++;
  sBuffer++;
     ++(*endPos);
 }

 //取数字行号
 if(end>start)
 {
      memset(int_v,'/0',sizeof(int_v));
      memcpy(int_v,pStartPtr+start,end-start);
   memset(int_v+end-start+1,1,'/0');
   return atoi(int_v);
 }
 return 0;
}

CommmandType LineNode::ParseCommand(const char *sBuffer,int *endPos)
{
 int start,end;
 char cmd_v[128];
 const char *pStartPtr = sBuffer;

 start =0;

 //找到第一个不为空的字符
    while('/0' != *sBuffer)
 {
        if(BLANK_CHAR !=*sBuffer)
       break;

  sBuffer++;
  start++;
     ++(*endPos);
 }

 
    //找到第一个为空的字符
 end   =start;
    while('/0' != *sBuffer)
 {
        if(BLANK_CHAR ==*sBuffer)
       break;

  end++;
  sBuffer++;
     ++(*endPos);
 }

 //取数字行号
 if(end>start)
 {
      memset(cmd_v,'/0',sizeof(cmd_v));
      memcpy(cmd_v,pStartPtr+start,end-start);
   memset(cmd_v+end-start+1,1,'/0');

   if(strcmp("LET",cmd_v)==0)
         return ELET;
   else if(strcmp("PRINT",cmd_v)==0)
         return EPRINT;
   else if(strcmp("IF",cmd_v)==0)
         return EIF;
   else if(strcmp("GOTO",cmd_v)==0)
         return EGOTO;
   else if(strcmp("STOP",cmd_v)==0)
         return ESTOP;
 }
 return EUnKnown;
}

//返回 指定符号的位置，如果返回0表未找不到指定符号
int LineNode::PosChar(const char *sBuffer,char ch)
{
 int i=0;
 while('/0' != *sBuffer)
 {
  if(ch == *sBuffer)
   return i;
  sBuffer++;
  i++;
 }
 return -1;
}

void LineNode::ParseExpression(char *sBuffer,int *endPos,pLNode pNode)
{
 int start,end,ret;
 char ch;

 start =0;
 //找到第一个不为空的字符
    while('/0' != *sBuffer)
 {
        if(BLANK_CHAR !=*sBuffer)
       break;
  sBuffer++;
  start++;
     ++(*endPos);
 }

 end   =start;

 //找到第一个为空的字符
 
 switch(pNode->CType)
 {
  case ELET: /*赋值语句*/
   {
                 //X
     pNode->ResultValue.is_const = 0;
     pNode->ResultValue.value    =  *sBuffer-'A';
                
     sBuffer+=2;  //跳过=号

     ret =PosChar(sBuffer,'+');
     if(ret<0) //如果找不到 "+" 号
     {
      /*赋值，LET X=Y    X:ResultValue Y:LeftValue  */
      pNode->OType =ESet;
      if(IS_CONST_CHAR(*sBuffer))
      {
       pNode->LeftValue.is_const = 1;
       pNode->LeftValue.value    = atoi(sBuffer);
      }
      else
      {
       pNode->LeftValue.is_const = 0;
       pNode->LeftValue.value    = *sBuffer - 'A';
      }
     }
     else
     {
       /*相加，LET X=Y+Z  X:ResultValue Y:LeftValue Z:RightValue */
       pNode->OType =EAdd;

       //Y
      
       if(IS_CONST_CHAR(*sBuffer))
       {
       ch = *(sBuffer+ret);
       *(sBuffer+ret) ='/0';
       pNode->LeftValue.is_const = 1;
       pNode->LeftValue.value    = atoi(sBuffer);
       *(sBuffer+ret) =ch;
       }
       else
       {
       pNode->LeftValue.is_const = 0;
       pNode->LeftValue.value    = *sBuffer - 'A';
       }
      
       // +
       sBuffer +=ret;
       sBuffer++; //跳过 "+" 号

       // Z
      
       if(IS_CONST_CHAR(*sBuffer))
       {
       pNode->RightValue.is_const = 1;
       pNode->RightValue.value    = atoi(sBuffer);
       }
       else
       {
       pNode->RightValue.is_const = 0;
       pNode->RightValue.value    = *sBuffer - 'A';
       }
     }
   }
   break;
  case EPRINT:  /*打印*/
   {
                    pNode->ResultValue.is_const =0;
     pNode->ResultValue.value    =*sBuffer-'A';
   }
   break;
  case EGOTO:  /*跳转*/
   {
       
     if(IS_CONST_CHAR(*sBuffer))  //Line number ,Goto expression
     {           
        pNode->ResultValue.is_const =1;
        pNode->ResultValue.value    =atoi(sBuffer);
     }
     else
     {
        pNode->ResultValue.is_const = 0;
        pNode->ResultValue.value    = *sBuffer-'A';
     }
   }
   break;
  case EIF:   /*判断语句*/
   {
        ret =PosChar(sBuffer,'>');
     if(ret>=0)
     {       
      /*大于，IF  X>Y    X:LeftValue   Y:RightValue      */ 
      //X
      
      if(IS_CONST_CHAR(*sBuffer))
      {   
         ch = *(sBuffer+ret);
         *(sBuffer+ret) ='/0';
         pNode->LeftValue.is_const = 1;
         pNode->LeftValue.value    = atoi(sBuffer);
         *(sBuffer+ret) =ch;
      }
      else
      {
         pNode->LeftValue.is_const = 0;
         pNode->LeftValue.value    = *sBuffer-'A';
      }

      //跳过>号
      sBuffer +=ret;
      sBuffer++;

      //Y
      
      if(IS_CONST_CHAR(*sBuffer)) 
      {           
         pNode->RightValue.is_const =1;
         pNode->RightValue.value    =atoi(sBuffer);
      }
      else
      {
         pNode->RightValue.is_const = 0;
         pNode->RightValue.value    = *sBuffer-'A';
      }
     }
   }
   break;
  case ESTOP:
   {
               
   }
   break;
 } 

}

CommmandType LineNode::ParseInput(char *sBuffer)
{
    pLNode pNode;
 CommmandType cType;
 int length; 
 int len;   //当前解释的开始位置
 cType   = EUnKnown;
 length  = strlen(sBuffer);
 pNode   = AllocNode();
 len     = 0;

 strcpy(pNode->Commands,sBuffer);

 //解析行号
    pNode->LineNumber = ParseLineNumber(sBuffer+len,&len);
 if(0==pNode->LineNumber)
 {
  free(pNode);
  return cType;
 }


 //解析命令
 cType =ParseCommand(sBuffer+len,&len);
 pNode->CType = cType;

 //解析表达式
    ParseExpression(sBuffer+len,&len,pNode);

    return cType;
}

void  LineNode::SetAutoNumber(int auto_number)
{
    m_auto_number = auto_number;
}

bool LineNode::LocalInput(const char *sBuf)
{
    if(m_auto_number) //如果是自动填充行号
 {
     char sBuffer[2048];
  sprintf(sBuffer,"%d ",m_auto_line_number);
  printf("%d ",m_auto_line_number);
  strcpy(sInputBuffer,sBuffer);
  strcat(sInputBuffer,sBuf);

  m_auto_line_number++;
 }
 else  //手工输写行号
 {
     strcpy(sInputBuffer,sBuf);
 }

 switch(ParseInput(sInputBuffer))
 {
    case ELET:
       case EPRINT:
    case EGOTO:
    case EIF:
    case ESTOP:
     return true;
    case EUnKnown:
     return false;
    default:
     return true;
 }
}

bool LineNode::Input()
{ 
 if(m_auto_number) //如果是自动填充行号
 {
     char sBuffer[2048];
  sprintf(sBuffer,"%d ",m_auto_line_number);
  printf("%d ",m_auto_line_number);
  strcpy(sInputBuffer,sBuffer);
  gets(sBuffer);
  strcat(sInputBuffer,sBuffer);

  m_auto_line_number++;
 }
 else  //手工输写行号
 {
     gets(sInputBuffer);
 }

 switch(ParseInput(sInputBuffer))
 {
    case ELET:
       case EPRINT:
    case EGOTO:
    case EIF:
    case ESTOP:
     return true;
    case EUnKnown:
     return false;
    default:
     return true;
 }
}

bool  LineNode::ExpressionResult(Var *leftVar,Var *rightVar)
{
     return ( GetValue(leftVar) > GetValue(rightVar) );
}

void  LineNode::PrintResult(Var *var,FILE *fp)
{
  if(NULL==fp)
       printf("%c=%d/n",var->value+'A',GetValue(var)); 
  else
       fprintf(fp,"%c=%d/n",var->value+'A',GetValue(var)); 

}

int LineNode::GetValue(Var *var)
{
 switch(var->is_const)
 {
         case 1:  //常量
    return (var->value);
   case 0:  //变量
    return (var->value<VAR_ARRY_MAX) ? Var_Values[var->value] : 0;
 } 
 return 0;
}

void LineNode::SetValue(Var *var,int value)
{
 switch(var->is_const)
 {
   case 0:  //变量
    {
     if(var->value<VAR_ARRY_MAX)
      Var_Values[var->value]= value;
    }
    break;
 } 
}

pLNode LineNode::GotoLine(Var *var)
{
 int line_number;
    if(1 ==var->is_const) //常量
 {
       line_number = var->value;
 }
 else
 {
       if(var->value<VAR_ARRY_MAX)
         line_number = Var_Values[var->value];
    else
      return 0;
 }

 

 pLNode pNode =pHead;
 while(pNode)
 {
        if(pNode->LineNumber == line_number)
   return pNode;
     pNode = pNode->next; 
 } 
 return 0;
}

void LineNode::Caculate()
{
 //自动初始化所有变量
 for(int i=0; i<VAR_ARRY_MAX; i++)
   Var_Values[i]=0;
 
 printf("/n Result List:/n");
 //逐条命令解析
 pLNode pNode =pHead;
 while(pNode)
 { 
       switch(pNode->CType)
    {
        case ELET:   /*赋值语句*/
      {
       switch(pNode->OType)
       {
           case ESet: /*赋值，LET X=Y    X:ResultValue Y:LeftValue  */
         {
                              SetValue(&pNode->ResultValue, GetValue(&pNode->LeftValue));
         }
         break;
        case EAdd:  /*相加，LET X=Y+Z  X:ResultValue Y:LeftValue Z:RightValue */
         {
                              SetValue(&pNode->ResultValue,GetValue(&pNode->LeftValue) + GetValue(&pNode->RightValue));
         }
         break;
       }
                pNode= pNode->next; 
      }
       break;
     case EPRINT:  /*打印*/
      {
                   PrintResult(&pNode->ResultValue);
                pNode= pNode->next; 
      }
       break;
     case EGOTO:  /*跳转*/
      {
       pNode = GotoLine(&pNode->ResultValue);
      }
       break;
     case EIF: /*判断语句*/
      {
                   pNode = ExpressionResult(&pNode->LeftValue,&pNode->RightValue) ? pNode : pNode->next ;
                pNode= pNode->next; 
      }
       break;
     case ESTOP: /*停止执行*/
                 return ;
       break;
     case EUnKnown:/*未知，错误指令*/ 
      return;
     default:
      return ;
    }
 } 
}

//从文件中取一行数据到Buffer中
int LineNode::ReadLine(FILE  *fp, char *lineBuffer, int maxLength)
{
    int size = 0;
    char ch;
    memset(lineBuffer, 0, maxLength);
    while( !feof( fp ) )
    {
        if( size < maxLength )
        {
            ch = fgetc( fp );
   switch(ch)
   {
       case 0x0A: // 支持windows和Linux换行符
    case EOF: //遇到文件结束符
     {
         lineBuffer[size] = 0;
      return size;
     }
    default:
     {
      lineBuffer[size] = ch;
                        size++;
     }
     break;

   }
        }
    }
    return size;
}

 

测试用例：

// MiniBasic.cpp : Defines the entry point for the console application.
//

#include <stdio.h>
#include "LineNode.h"

int main(int argc, char* argv[])
{
    LineNode NodeList;
 char cmd[1];
 char file_name[512];

 const char *pComment ="/n Welcome to MiniBasic     /n "
                    " Make sure there is no more black around of oprator ( '+', '=' )/n"
                    " Please select !          /n "
        " 1. Load command from file with line number /n "
        " 2. Load command from file no line number   /n "
        " 3. Input commmand manual /n "
        " 4. Print latest commands /n "
        " 5. Clear screen          /n "
        " 6. Quit                  /n ";
 
 do
 {
    printf("%s",pComment);
    scanf("%c",cmd);
       
    if('6' ==cmd[0])
     break;

    switch(cmd[0])
    {
     case '1':
      {
        printf("Please input file name:");
        scanf("%s",file_name);
        NodeList.SetAutoNumber(0);
        NodeList.LoadCommandFromFile(file_name);
        printf("/n Command List：/n");
        NodeList.PrintCommands();
        NodeList.Caculate();
      }
      break;    
     case '2':
      {
        printf("Please input file name:");
        scanf("%s",file_name);
        NodeList.SetAutoNumber(1);
        NodeList.LoadCommandFromFile(file_name);
        printf("/n Command List：/n");
        NodeList.PrintCommands();
        NodeList.Caculate();
      }
      break;
     case '3':
      {
         NodeList.SetAutoNumber(1);
      while(NodeList.Input())
       ;

      NodeList.Caculate();
      }
      break;
     case '4':
      {
      printf("/n Command List：/n");
      NodeList.PrintCommands();
      }
      break;
     case '5':
      {
         system( "CLS");

      }
      break;
    }
 } 
 while(0);

 return 0;
}

 

 

code.txt文件内容：

1 LET A=10     
2 LET I=0
3 LET X=I+I
4 LET T=1
5 LET X=X+T
6 PRINT X
7 LET T=1
8 LET I=I+T
9 IF A>I
10 GOTO 3
11 STOP

吴丁
关注
轻量级BASIC脚本解析器my_basic.zip
07-19
my_basic 是简单可扩展的轻量级 BASIC 脚本解析器，使用 C 编写，可以作为独立的解析器使用，也可以集成到现有项目。至此和工作台，PC，平板，移动端，PDA，视频游戏工作台，Raspberry Pi，甚至是 MCU。完全支持 Windows, OS X, Linux, iOS, Android, RTOS 等等。 标签：mybasic
MiniBasic
03-10
MiniBasic是一款基于QT框架构建的、简化的Basic解释器，旨在提供一个轻量级的编程环境，让初学者和有经验的程序员都能快速上手。它以Basic语言为基础，简化了复杂的语法，使得编程变得更加直观易懂。Basic语言本身...
MiniBasic解析器实现
WACR2008的专栏
12-03 1696
Minibasic
Python写个Basic解析器（1）表达式。
perry_peng的专栏
04-03 481
Testing...
Python写个Basic解析器（1）解析全局变量声明。
perry_peng的专栏
04-09 884
def _make_dim(self): while True: ''' 变量必须是一个标识符，但如使用了某个保留的关键字 将引起一个错误。 ''' if self._reader.type == BSCTK_KEYWORD: return 0x80000010 ''' 变
MY-BASIC应用1：MY-BASIC解析器介绍
长江后浪
03-07 1086
MY-BASIC is a lightweight BASIC interpreter written in standard C in dual files. //MY-BASIC是一个轻量级的BASIC解释器，用标准C语言在双文件中编写。 It's aimed to be embeddable, extendable and portable. //它的目标是可嵌入、可扩展和可移植。 I...
MiniBasic:ANSI C中的基本解释器-开源
04-26
MiniBasic是一个小型但可用的Basic解释器。 它是用纯ANSI C编写的，因此在几乎任何环境中都应该易于启动和运行。 它已用于PIC32电子项目，用作嵌入式脚本语言和用作教学辅助工具。 有一本相关的书，以及在线的完整...
csdn minibasic expression program
12-31
使用MiniBasic编写表达式程序非常简单，只需要按照一定的语法规则编写表达式，并且通过MiniBasic的解释器进行解析和执行。比如，我们可以编写一个简单的加法表达式程序，将两个数字相加并输出结果。这样的程序可以...
Basic语言解释器1.0
08-30
Basic的一些基础语法做成的Basic语言解释器.能够运行一般的Basic程序. 做此软件的目的不是为了做一个真正的Basic,而是给大家参考做语言解释方面的知识，所以我将它列入源程序列。 关于此Basic运行的手册说明...
A-minimal-BASIC:迷你BASIC
04-03
最小的BASIC解释器 SE-2322的项目。 由Qt创建者创建。 译文 若有歧义，以Basic-doc.pdf为准 输入 每条指令前的数字确定了指令的执行顺序。 输入一样的数字将替换这条指令。 输入一个数字而不跟任何东西将删除这行。 必须按照行号显示已经输入的代码。 表达式 需要实现的运算： + - * / () ，对于至少32位的有符号整数。 另外：实现乘方** ，优先级大于* / 对于所有的表达式和声明，你需要能够处理多余的空间。 LET PRINT INPUT可以被直接执行，不需要输入行号。 转到REM REM END必须要输入行号才重置。 表达式种类： 常亮表达式。constantexpression 变量。identifierexpression 复合表达式。1E E op E 2 (E) 指令 意义 快速眼动 注释 转到n 转到第n行，若无n，报错 如果exp1 op
脚本解析器
wjh_monkey的博客
05-07 5656
命令脚本解析器，自创建一种脚本语法，解释执行它。目前脚本形式类似于命令，没有变量类型的概念，关键字为=、$()、if、else、while、break、continue ，解释与C语言一样。
自己动手写basic解释器(二)
刺猬小屋
09-14 5596
自己动手写basic解释器刺猬@http://blog.csdn.net/littlehedgehog 注: 文章basic解释源码摘自梁肇新先生的《编程高手箴言》(据他所说这个代码也是网上摘录的)，源码解读参考《java编程艺术》。《java编程艺术》里面自然是java版了(可能旭哥更加适合点儿)，我这里还是解读的C版basic解释器代码。上次我们把程序装载入内存，这里我们开始做词法分析了。
11_跳表（Skip List）
刘炫320的博客
09-11 697
老鸟：跳表通过在链表上增加多级索引，使得查找、插入和删除操作的平均时间复杂度都可以达到O(log n)。我们先从基本概念开始。菜鸟：听起来不错，能具体解释一下吗？老鸟：当然。假设我们有一个有序链表，跳表在这个基础上增加了多层索引。第一层是原始链表，第二层是每两个节点挑选一个节点作为索引，第三层是第二层中每两个节点挑选一个节点作为索引，以此类推。菜鸟：这样做的好处是什么？老鸟：这样可以大幅减少查找的步骤。假设我们要查找某个元素，可以从最高层索引开始，逐层向下查找，大大减少了需要遍历的节点数。老鸟。
STL02——手写简单版本的list
2402_84438596的博客
09-10 720
STL02——手写一个简单版本的list
STL值list
最新发布
qq_75073393的博客
09-15 818
头文件：#include- list是一个双向链表容器，可高效地进行插入删除元素- list不可以随机存取元素，所以不支持at.(pos)函数与[]操作符注：list使用迭代器访问数据时可以一步一步走自增自减（即it++）不允许跨太多步去访问元素list容器是可以进行遍历的，即进行数据访问时不会进行删除操作。
使用jackson将xml和对象、List相互转换
weixin_46425661的博客
09-11 1373
jackson中xml和对象、List相互转换
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值