fork(1) download
copy 
  1. fn main() {
  2.     let line = read_line();
  3.     let por = parse(&line);
  4.  
  5.     print_casl2(por);
  6. }
  7.  
  8. fn read_line() -> String {
  9.     let mut line = String::new();
  10.     std::io::stdin().read_line(&mut line).unwrap();
  11.     println!("{}", line.trim());
  12.  
  13.     for ch in "()+-*".chars() {
  14.         use std::iter::FromIterator;
  15.         line = line.replace(ch, &String::from_iter(&[' ', ch, ' ']));
  16.     }
  17.     println!("{}", line.trim());
  18.  
  19.     line
  20. }
  21.  
  22. fn parse(line: &str) -> Vec<&str> {
  23.     let mut ops = vec![];
  24.     let mut por = vec![];
  25.     for token in line.split_whitespace() {
  26.         match token {
  27.             "(" => {
  28.                 ops.push(token);
  29.             }
  30.             ")" => {
  31.                 while let Some(token) = ops.pop() {
  32.                     if token == "(" {
  33.                         break;
  34.                     }
  35.                     por.push(token);
  36.                 }
  37.             }
  38.             "+" | "-" => {
  39.                 while let Some(token) = ops.pop() {
  40.                     if token == "(" {
  41.                         ops.push(token);
  42.                         break;
  43.                     }
  44.                     por.push(token);
  45.                 }
  46.                 ops.push(token);
  47.             }
  48.             "*" => {
  49.                 while let Some(token) = ops.pop() {
  50.                     if token != "*" {
  51.                         ops.push(token);
  52.                         break;
  53.                     }
  54.                     por.push(token);
  55.                 }
  56.                 ops.push(token);
  57.             }
  58.             _ => {
  59.                 por.push(token);
  60.             }
  61.         }
  62.     }
  63.  
  64.     ops.reverse();
  65.     por.append(&mut ops);
  66.     println!("{}", por.join(" "));
  67.  
  68.     por
  69. }
  70.  
  71. fn print_casl2(por: Vec<&str>) {
  72.     let is_op = |token| match token {
  73.         "+" | "-" | "*" => true,
  74.         _ => false,
  75.     };
  76.     let is_digit = |token: &str| token.chars().all(|c| c.is_ascii_digit());
  77.     let print_op = |token, r| match token {
  78.         "+" => println!("    ADDL   GR{},GR{}", r + 1, 2 - r),
  79.         "-" => println!("    SUBL   GR{},GR{}", r + 1, 2 - r),
  80.         "*" => {
  81.             println!("    CALL   MUL");
  82.             println!("    LD     GR{},GR0", r + 1);
  83.         }
  84.         _ => {}
  85.     };
  86.     let mut var = std::collections::BTreeSet::new();
  87.     for token in &por {
  88.         if !is_op(token) && !is_digit(token) {
  89.             var.insert(*token);
  90.         }
  91.     }
  92.     println!("FOO START");
  93.     for token in &var {
  94.         println!("    LD     GR0,='{}'", token);
  95.         println!("    ST     GR0,STR");
  96.         println!("    LD     GR0,={}", token.len());
  97.         println!("    ST     GR0,LEN");
  98.         println!("    OUT    STR,LEN");
  99.         println!("    CALL   RED");
  100.         println!("    ST     GR0,{}", token);
  101.     }
  102.  
  103.     let mut stk = vec![];
  104.     let mut reg = [None, None];
  105.     let mut r = 0;
  106.     for token in por {
  107.         match token {
  108.             "+" | "-" | "*" => {
  109.                 if let Some(gr) = reg[r] {
  110.                     if is_digit(gr) {
  111.                         println!("    LAD    GR{},{}", r + 1, gr);
  112.                     } else if !is_op(gr) {
  113.                         println!("    LD     GR{},{}", r + 1, gr);
  114.                     }
  115.                 } else if let Some(gr) = stk.pop() {
  116.                     if is_op(gr) {
  117.                         println!("    POP    GR{}", r + 1);
  118.                     } else if is_digit(gr) {
  119.                         println!("    LAD    GR{},{}", r + 1, gr);
  120.                     } else {
  121.                         println!("    LD     GR{},{}", r + 1, gr);
  122.                     }
  123.                 }
  124.                 if let Some(gr) = reg[1 - r] {
  125.                     if is_digit(gr) {
  126.                         println!("    LAD    GR{},{}", 2 - r, gr);
  127.                     } else if !is_op(gr) {
  128.                         println!("    LD     GR{},{}", 2 - r, gr);
  129.                     }
  130.                 }
  131.                 reg[1 - r] = None;
  132.                 print_op(token, r);
  133.             }
  134.             _ => {
  135.                 if let Some(gr) = reg[r] {
  136.                     if is_op(gr) {
  137.                         println!("    PUSH   0,GR{}", r + 1);
  138.                     }
  139.                     stk.push(gr);
  140.                 }
  141.             }
  142.         }
  143.         reg[r] = Some(token);
  144.         r = 1 - r;
  145.     }
  146.  
  147.     println!("    LD     GR0,GR{}", 2 - r);
  148.     println!("    RET");
  149.  
  150.     println!("MUL XOR    GR0,GR0");
  151.     println!("TOP SRL    GR1,1");
  152.     println!("    JOV    ADD");
  153.     println!("    JNZ    NXT");
  154.     println!("    RET");
  155.     println!("ADD ADDL   GR0,GR2");
  156.     println!("NXT SLL    GR2,1");
  157.     println!("    JUMP   TOP");
  158.  
  159.     println!("RED IN     STR,LEN");
  160.     println!("    XOR    GR0,GR0");
  161.     println!("    XOR    GR1,GR1");
  162.     println!("LOP CPL    GR1,LEN");
  163.     println!("    JNZ    RCH");
  164.     println!("    RET");
  165.     println!("RCH LD     GR2,GR0");
  166.     println!("    SLL    GR0,1");
  167.     println!("    SLL    GR2,3");
  168.     println!("    ADDL   GR0,GR2");
  169.     println!("    ADDL   GR0,STR,GR1");
  170.     println!("    SUBL   GR0,='0'");
  171.     println!("    LAD    GR1,1,GR1");
  172.     println!("    JUMP   LOP");
  173.     println!("LEN DS     1");
  174.     println!("STR DS     5");
  175.  
  176.     for token in var {
  177.         println!("{:3} DS     1", token);
  178.     }
  179.  
  180.     println!("    END");
  181. }
  182.  
Success #stdin #stdout 0s 4380KB
comments (?)
stdin
copy 
(12+A*5+U)  *  ((7-B)-(2+X)) * 4
stdout
copy 
(12+A*5+U)  *  ((7-B)-(2+X)) * 4
( 12 + A * 5 + U )    *    (  ( 7 - B )  -  ( 2 + X )  )   *  4
12 A 5 * + U + 7 B - 2 X + - * 4 *
FOO START
    LD     GR0,='A'
    ST     GR0,STR
    LD     GR0,=1
    ST     GR0,LEN
    OUT    STR,LEN
    CALL   RED
    ST     GR0,A
    LD     GR0,='B'
    ST     GR0,STR
    LD     GR0,=1
    ST     GR0,LEN
    OUT    STR,LEN
    CALL   RED
    ST     GR0,B
    LD     GR0,='U'
    ST     GR0,STR
    LD     GR0,=1
    ST     GR0,LEN
    OUT    STR,LEN
    CALL   RED
    ST     GR0,U
    LD     GR0,='X'
    ST     GR0,STR
    LD     GR0,=1
    ST     GR0,LEN
    OUT    STR,LEN
    CALL   RED
    ST     GR0,X
    LD     GR2,A
    LAD    GR1,5
    CALL   MUL
    LD     GR2,GR0
    LAD    GR1,12
    ADDL   GR1,GR2
    LD     GR2,U
    ADDL   GR1,GR2
    PUSH   0,GR1
    LAD    GR2,7
    LD     GR1,B
    SUBL   GR2,GR1
    PUSH   0,GR2
    LAD    GR1,2
    LD     GR2,X
    ADDL   GR1,GR2
    POP    GR2
    SUBL   GR2,GR1
    POP    GR1
    CALL   MUL
    LD     GR1,GR0
    LAD    GR2,4
    CALL   MUL
    LD     GR1,GR0
    LD     GR0,GR1
    RET
MUL XOR    GR0,GR0
TOP SRL    GR1,1
    JOV    ADD
    JNZ    NXT
    RET
ADD ADDL   GR0,GR2
NXT SLL    GR2,1
    JUMP   TOP
RED IN     STR,LEN
    XOR    GR0,GR0
    XOR    GR1,GR1
LOP CPL    GR1,LEN
    JNZ    RCH
    RET
RCH LD     GR2,GR0
    SLL    GR0,1
    SLL    GR2,3
    ADDL   GR0,GR2
    ADDL   GR0,STR,GR1
    SUBL   GR0,='0'
    LAD    GR1,1,GR1
    JUMP   LOP
LEN DS     1
STR DS     5
A   DS     1
B   DS     1
U   DS     1
X   DS     1
    END
https://ideone.com/wCfKLq
language:
Rust (rust 1.56)
created:
4 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!