C BF编译器优化

我写了简单的brainfuck2c翻译。我添加了一些轻微的优化（针对指针移动），但我考虑优化加法/减法，例如，我们有像

++++

这样的代码，可以转换为

mem[0]+=1；mem[0]+=1；mem[0]+=1；mem[0]+=1。我的目标是让我的解释器优化加法和减法，以便为此输出以下代码：
mem[0]+=4。我写的代码（只有箭头优化）；我知道这不是“c++风格”，但我是c程序员。那么，如何实现添加/子存储优化呢？我在谷歌上搜索过一些，但我只找到了python解决方案，我没有使用它们，因为我不了解它们，以及使用外部库（例如LLVM）的解决方案

#包括
#包括
#包括
int main（int argc，字符**argv）{
int pos=0；
整数金额=0；
int括号=0；
如果（argc！=2）退出（0）；
文件*f=fopen（argv[1]，“r”）；
如果（f！=NULL）{
char*exputffer=malloc（1024*1024*1024）；
char c=fgetc（f）；
strcpy（exputffer，“intgetch（void）；\nvoid putch（int）；\nintmain（）{\n”）；
而（！feof（f））{
如果（c=''）{
如果（pos==65536）pos=0；
else-pos++；
}
如果（c=='['）{
括号++；
sprintf（exputffer，“while（mem[%d]）{”，pos；
}
如果（c==']'）{
括号--；
sprintf（突发事件，“}”）；
}
如果（c=='+'）{
sprintf（exputfer，“mem[%d]+=1；”，pos）；
}
如果（c=='-'）{
sprintf（突发，“内存[%d]-=1；”，位置）；
}
如果（c=='。）{
sprintf（exputffer，“putch（mem[%d]）；”，pos）；
}如果（c=='。）{
sprintf（exputfer，“mem[%d]=getch（）；”，pos）；
}
c=fgetc（f）；
}
如果（括号==1）{
printf（“编译成功”）；
printf（“生成的代码：\n%s”，exputfer）；
自由（突发）；
}
否则{
printf（“组合故障。不平衡括号”）；
自由（突发）；
}
}
}

好的，我找到了一个答案。我创建了单独的函数；在用C后端编写编译器时它会很有帮助；感谢Gene的帮助

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

int minus(FILE* f){
    int c;
    int amount = 0;
    while ((c = getc(f)) == '-')
        amount++;
    ungetc(c, f);
    return amount;
}

int plus(FILE* f){
    int c;
    int amount = 0;
    while ((c = getc(f)) == '+')
        amount++;
    ungetc(c, f);
    return amount;
}

int main(int argc, char** argv){
    int pos = 0;
    int brackets = 0;
    if(argc!=2)exit(0);
    int amount = 1;
    FILE* f = fopen(argv[1], "r");
    if(f!=NULL){
        char* outbuffer = (char*)malloc(1024*1024);
        strcpy(outbuffer, "int getch(void);\nvoid putch(int);\nint main(){\n");
        while(!feof(f)){
            printf("Iterating.");
            char c = fgetc(f);
            if(c == '<'){
                if(pos==0)pos=65536;
                else pos--;
            }
            if(c == '>'){
                if(pos==65536)pos=0;
                else pos++;
            }
            if(c == '['){
                brackets++;
                sprintf(outbuffer, "%swhile(mem[%d]){",outbuffer,pos);
            }
            if(c == ']'){
                brackets--;
                sprintf(outbuffer, "%s}", outbuffer);
            }
            if(c == '+'){
                amount = plus(f)+1;
                sprintf(outbuffer, "%smem[%d]+=%d;",outbuffer, pos, amount);
            }
            if(c == '-'){
                amount = minus(f)+1;
                sprintf(outbuffer, "%smem[%d]-=%d;",outbuffer, pos, amount);
            }
            if(c == '.'){
                sprintf(outbuffer, "%sputch(mem[%d]);",outbuffer, pos);
            }
            if(c == '.'){
                sprintf(outbuffer, "%smem[%d]=getch();",outbuffer, pos);
            }
        }
        if(brackets == 0){
            printf("Compilation succesfull. ");
            printf("Generated Code:\n%s", outbuffer);
            free(outbuffer);
        }
        else{
            printf("Comilation fault. Unbalanced brackets.");
            free(outbuffer);
        }
    }
}

#包括
#包括
#包括
整数减（文件*f）{
INTC；
整数金额=0；
而（（c=getc（f））='-'）
金额++；
ungetc（c，f）；
退货金额；
}
整数加（文件*f）{
INTC；
整数金额=0；
而（（c=getc（f））=='+'）
金额++；
ungetc（c，f）；
退货金额；
}
int main（int argc，字符**argv）{
int pos=0；
int括号=0；
如果（argc！=2）退出（0）；
整数金额=1；
文件*f=fopen（argv[1]，“r”）；
如果（f！=NULL）{
char*exputffer=（char*）malloc（1024*1024）；
strcpy（exputffer，“intgetch（void）；\nvoid putch（int）；\nintmain（）{\n”）；
而（！feof（f））{
printf（“迭代”）；
char c=fgetc（f）；
如果（c=''）{
如果（pos==65536）pos=0；
else-pos++；
}
如果（c=='['）{
括号++；
sprintf（突发，“%swwhile（mem[%d]）{”，突发，位置；
}
如果（c==']'）{
括号--；
sprintf（突发，“%s}”，突发）；
}
如果（c=='+'）{
金额=加（f）+1；
sprintf（突发事件，“%smem[%d]+=%d；”，突发事件，位置，金额）；
}
如果（c=='-'）{
金额=减（f）+1；
sprintf（突发事件，“%smem[%d]-=%d；”，突发事件，位置，金额）；
}
如果（c=='。）{
sprintf（突发，“%sputch（mem[%d]）；”，突发，位置）；
}
如果（c=='。）{
sprintf（突发，“%smem[%d]=getch（）；”，突发，位置）；
}
}
如果（括号==0）{
printf（“编译成功”）；
printf（“生成的代码：\n%s”，exputfer）；
自由（突发）；
}
否则{
printf（“组合故障。不平衡括号”）；
自由（突发）；
}
}
}
编译器用于此类简单优化的一般方法是惰性地生成代码

它不是立即为给定的HLL功能发出代码，而是存储在一个方便的数据结构中，用作缓冲区。添加每个新的代码块后，优化器会检查缓冲区并应用模式匹配重写规则，以降低缓冲代码的成本，而不改变其含义

在您的例子中，规则看起来像
X+=m；X+=n；-->X+=（m+n）；
。也就是说，将相同l值的两个增量重写为一个增量，将原始两个增量相加

另一个简单的例子：
X+=0-->
。也就是说，擦除增量为零

只要代码可能与其中一条规则相匹配，它就被保存在缓冲区中。当这不可能时，它最终被发出并删除

缓冲区有时被称为指令输出流中的“窥视孔”。因此，这种改进代码的方法被称为“窥视孔优化”。通过搜索这个术语，您可以学到很多东西

实现缓冲区有很多方案。对于表达式，符号操作数堆栈可以很好地工作。对于语句，通常的方法是存储由2或3个地址代码组成的FIFO队列，这是输出代码的抽象表示。
除非遇到严重问题，否则在编码器上提出这个问题会更相关EXIEW.STACKExchange。com：学习关于<代码>开关>代码>。因为你把你的帖子标记为C++，你应该阅读关于代码> STD::CUT和。而且，更喜欢使用<代码> STD:：vector < /C> >而不是动态数组。@托马斯我已经标记为C，但是Mat删除了这个。好吧，它现在是纯的了。
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

int minus(FILE* f){
    int c;
    int amount = 0;
    while ((c = getc(f)) == '-')
        amount++;
    ungetc(c, f);
    return amount;
}

int plus(FILE* f){
    int c;
    int amount = 0;
    while ((c = getc(f)) == '+')
        amount++;
    ungetc(c, f);
    return amount;
}

int main(int argc, char** argv){
    int pos = 0;
    int brackets = 0;
    if(argc!=2)exit(0);
    int amount = 1;
    FILE* f = fopen(argv[1], "r");
    if(f!=NULL){
        char* outbuffer = (char*)malloc(1024*1024);
        strcpy(outbuffer, "int getch(void);\nvoid putch(int);\nint main(){\n");
        while(!feof(f)){
            printf("Iterating.");
            char c = fgetc(f);
            if(c == '<'){
                if(pos==0)pos=65536;
                else pos--;
            }
            if(c == '>'){
                if(pos==65536)pos=0;
                else pos++;
            }
            if(c == '['){
                brackets++;
                sprintf(outbuffer, "%swhile(mem[%d]){",outbuffer,pos);
            }
            if(c == ']'){
                brackets--;
                sprintf(outbuffer, "%s}", outbuffer);
            }
            if(c == '+'){
                amount = plus(f)+1;
                sprintf(outbuffer, "%smem[%d]+=%d;",outbuffer, pos, amount);
            }
            if(c == '-'){
                amount = minus(f)+1;
                sprintf(outbuffer, "%smem[%d]-=%d;",outbuffer, pos, amount);
            }
            if(c == '.'){
                sprintf(outbuffer, "%sputch(mem[%d]);",outbuffer, pos);
            }
            if(c == '.'){
                sprintf(outbuffer, "%smem[%d]=getch();",outbuffer, pos);
            }
        }
        if(brackets == 0){
            printf("Compilation succesfull. ");
            printf("Generated Code:\n%s", outbuffer);
            free(outbuffer);
        }
        else{
            printf("Comilation fault. Unbalanced brackets.");
            free(outbuffer);
        }
    }
}