А что если сделать свою мини-среду программирования с компилятором? (2 стр)

a1 +1 0 0 
b1 -1 0 0
c1 -1 0 4
d1 +1 0 4
end
c 255 : .+. 255 0 2 0
q a1 b1 c1 d1

id00000010 RunChilds (exec args)
id00000000         pnt3Flt
                           id00000001 "+1"
                           id00000002 "0"
                           id00000003 "0"
id00000004         pnt3Flt
                           id00000005 "-1"
                           id00000006 "0"
                           id00000007 "0"
id00000008         pnt3Flt
                           id00000009 "-1"
                           id0000000A "0"
                           id0000000B "4"
id0000000C         pnt3Flt
                           id0000000D "+1"
                           id0000000E "0"
                           id0000000F "4"
id00000014         .+.
                           id00000015 "255"
                           id00000016 "0"
id00000013         :
                           id00000014 ".+."
                           id00000017 "2"
id00000011         glColor
                           id00000012 "255"
                           id00000013 ":"
                           id00000018 "0"
id0000001A         GL_QUADS
id0000001B                 glVertex3fv
                                   id00000000 "pnt3Flt"
id0000001C                 glVertex3fv
                                   id00000004 "pnt3Flt"
id0000001D                 glVertex3fv
                                   id00000008 "pnt3Flt"
id0000001E                 glVertex3fv
                                   id0000000C "pnt3Flt"

__asm
{

}

#ifndef __AST_H__
#define __AST_H__

#include <string>
#include <vector>
#include <iostream>

class NodeAST
{
  public:
  virtual ~NodeAST(){};
  virtual void print() = 0;
};

class IntNodeAST : public NodeAST
{
  std::string val;
  
  public:
  IntNodeAST(std::string v):val(v){}
  
  void print()
  {
    std::cout<<val;
  }
};

class VarNodeAST : public NodeAST
{
  std::string var;
  
  public:
  VarNodeAST(std::string n):var(n){}
  
  void print()
  {
    std::cout<<var;
  }
};

class BinOpNodeAST : public NodeAST
{
  int op;
  NodeAST* lhs;
  NodeAST* rhs;
  
  public:
  BinOpNodeAST(int o, NodeAST* l, NodeAST* r): op(o), lhs(l), rhs(r){}
  
  void print()
  {
    std::cout<<"( ";
    lhs->print();
    switch(op)
    {
      case 1: std::cout<<"+"; break;
      case 2: std::cout<<"-"; break;
      case 3: std::cout<<"*"; break;
      case 4: std::cout<<"/"; break;
    }
    rhs->print();
    std::cout<<" )";
  }
};

class UnOpNodeAST : public NodeAST
{
  int op;
  NodeAST* rhs;
  
  public:
  UnOpNodeAST(int o, NodeAST* r): op(0), rhs(r){}
  
  void print()
  {
    switch(op)
    {
      case 1: std::cout<<"+"; break;
      case 2: std::cout<<"-"; break;
    }
    rhs->print();
  }
};

class StmtNodeAST : public NodeAST
{
  VarNodeAST* var;
  NodeAST* expr;
  
  public:
  StmtNodeAST(VarNodeAST* v, NodeAST* e):var(v), expr(e){}
  
  void print()
  {
    var->print();
    std::cout<<"=";
    expr->print();
    std::cout<<";"<<std::endl;    
  }
};

extern std::vector<NodeAST*> _stmts;

#endif

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

#include "ast.h"

typedef std::vector<std::string> strvec_t;
typedef std::string stdstring_t;

namespace BINOPS
{
  enum BINOPS_
  {
    AddOp=1, SubOp, MulOp, DivOp, ModOp,
  };  
}

COMPILER gmaker

CHARACTERS

  letter="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_".
  digit="0123456789".
  cr="\r".
  lf="\n".
  tab="\t".
  ws=" ".

TOKENS

  IDENT = letter {letter | digit}.
  INT = digit {digit}.

COMMENTS FROM "#" TO cr lf

IGNORE cr + lf + tab + ws

PRODUCTIONS

gmaker = {stmt} EOF.

  
stmt  (. VarNodeAST* var; NodeAST* e; .)
  = 
  {Variable<var> "=" Expr<e>
    (.
      StmtNodeAST* s = new StmtNodeAST(var, e);
      _stmts.push_back(s);
    .)
  } ";" .
  
Expr<NodeAST*& ef>  (. int op; NodeAST* tf; NodeAST* ctf; .)
  =
  Term<tf>
  {AddOp<op>  Term<ctf>
    (.
      NodeAST* tmp;
      tmp = new BinOpNodeAST(op, tf, ctf);
      tf = tmp;
    .)
  }
  (. ef = tf; .)
  .

Term<NodeAST*& tf>  (. int op; NodeAST* sf; NodeAST* bf; .)
  =
  Sfactor<sf>
    {MulOp<op> Factor<bf>
      (.                
        NodeAST* tmp;
        tmp = new BinOpNodeAST(op, sf, bf);
        sf = tmp;
      .)
    }
  
  (. tf = sf; .)
  .

Sfactor<NodeAST*& sf>  (. int op; NodeAST* f; .)
  =  (. op = -1; .)
  [AddOp<op>] Factor<f>
  (.
    if (op == -1) sf = new UnOpNodeAST(op, f);
    else sf = f;
  .)
  .

Factor<NodeAST*& f>  (. NodeAST* e; IntNodeAST* i;  VarNodeAST* v; .)
  = Int<i> (. f = i; .)
  | Variable<v> (. f = v; .)
  | "(" Expr<e> ")" (. f = e; .)
  .

Variable<VarNodeAST*& var> (. stdstring_t name; .)
  =
  IDENT
  (.
    char* v = coco_string_create_char(t->val);
    name = v;
    coco_string_delete(v);
    var = new VarNodeAST(name);
  .).

Int<IntNodeAST*& res> (. stdstring_t val; .)
  =
  INT 
  (.
    char* v = coco_string_create_char(t->val);
    val = v;
    res = new IntNodeAST(val);
    coco_string_delete(v);
  .)
  .
  
AddOp<int& op> = (. op = -1; .)
  ( "+" (. op = BINOPS::AddOp; .)
  | "-" (. op = BINOPS::SubOp; .)
  ).
  
MulOp<int& op> = (. op = -1; .)
  ( "*" (. op = BINOPS::MulOp; .)
  | "/" (. op = BINOPS::DivOp; .)
  | "%" (. op = BINOPS::ModOp; .)
  ).
  
END gmaker.