Converting prefix

import std.stdio;
 
int main() {
   string ECJformat1 = "(- (- (+ (+ I19 I02) (- I22 I50)) (* I13 I21)) (* I13 I21))";
   string ECJformat2 = "(- (- (exp (+ I52 -0.32028294)) (cos (sin I29))) (+ (log 4.7557163) (cos (exp I05))))";
 
   string ELformat = eval_expr(ECJformat2);
   writefln();
   writefln(ECJformat2);
   writefln(ELformat);
   return 0;
}
 
string eval_expr(string expr, char lastOp = '+') {
   expr = expr[1..expr.length - 1];    //Strip outer ()
   string op1, op2;
   bool binary = false, lastBinary = false;
   char operator = expr[0];
   if(lastOp == '+' || lastOp == '-' || lastOp == '*' || lastOp == '/') lastBinary = true;
   if(opCode == '+' || opCode == '-' || opCode == '*' || opCode == '/') {
      expr = expr[2..expr.length];     //Remove binary opCode from expr
      binary = true; 
   } else expr = expr[4..expr.length]; //Remove unary opCode
 
   if(expr[0] == '(') {    //There is an inner expression, split it
      int closes = 0;
      foreach(pos, ch; expr) {
         if(ch == '(') closes++;
         else if(ch == ')') { 
            if(--closes == 0) {
               /*if(binary) writefln("OP1: " ~ expr[0..pos+1] ~ "\tOP2: " ~ expr[pos+2..expr.length]);
               else writefln("OP1: " ~ expr);
               writefln();*/
               op1 = eval_expr(expr[0..pos+1], operator);                        //Operand 1/Left
               if(binary) op2 = eval_expr(expr[pos+2..expr.length], operator);   //Operand 2/Right
               break;
            }
         }
      }   
   } else {             //No inner expr, convert to ELformat
      string ELexpr; 
      if(lastBinary) {
         foreach(pos, ch; expr) {
            if(ch == ' ') ELexpr = "f[0] " ~ lastOp ~ "= " ~ expr[0..pos] ~ operator ~ expr[pos+1..expr.length] ~ "\n";
         }
      } else ELexpr = "f[0] " ~ operator ~ "= " ~ lastOp ~ "(" ~expr ~ ")\n";
 
      return ELexpr;
   }
   return op1 ~ op2;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:

void translate(vector<float> PFProgram) {
   vector<float>::iterator step = PFProgram.begin();
   int nextF = 201, del = 0;
   ofstream m_outputFile;
   m_outputFile.open("out2.stat", fstream::app);
   ostringstream opL, opR, op, IFProgram;
   while(*step != 5) {
      if(*step == 1) *step++;
      else if(*step < 100) {
         op << OpToStr(*step);
         IFProgram << OpToStr(nextF) << " = ";
         //The ERCs cause some problems. If the left OP is ERC, we need to move one extra back, but if the right OP is ERC, we need to move one back AND move the left check one back.
         if(*(step - 2) == 1) {
            opR << *(step - 1);
            del = 1;
            if(*(step - 4) == 1) {
               del = 2;
               opL << *(step - 3);
            } else opL << OpToStr(*(step - 3));
         } else {
            opR << OpToStr(*(step - 1));
            if(*(step - 3) == 1) {
               opL << *(step - 2);
               del = 1;
            } else opL << OpToStr(*(step - 2));
         }
         IFProgram << opL.str() << " " << op.str() << " " << opR.str() << ";" << endl;
         *(step) = nextF++;
         PFProgram.erase(step - (2 + del), step);
         del = 0;
         opL.str("");
         opR.str("");
         op.str("");
         step = (PFProgram.begin() - 1);
      }
      *step++;
   } IFProgram << "f[0] = " << OpToStr(--nextF) << ";";
   m_outputFile << IFProgram.str() << endl << endl << "-------------------------" << endl << endl;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39: