Advertisement
Guest User

RAM

a guest
Apr 7th, 2020
200
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 2.92 KB | None | 0 0
  1. import java.io.BufferedReader;
  2. import java.io.File;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.util.Scanner;
  6.  
  7. public class Programm {
  8.  
  9.     static int MAX_REG = 10;
  10.     static int akkumulator;
  11.     static int PC = 0;
  12.     static int[] register = new int[MAX_REG];
  13.  
  14.     public static void main(String args[]) {
  15.  
  16.         initReg(register);
  17.         String dateiName = "RAM.txt";
  18.         ladeDatei(dateiName);
  19.     }
  20.  
  21.     private static void ladeDatei(String datName) {
  22.  
  23.         File file = new File(datName);
  24.  
  25.         if (!file.canRead() || !file.isFile())
  26.             System.exit(0);
  27.  
  28.         BufferedReader in = null;
  29.  
  30.         try {
  31.            
  32.             in = new BufferedReader(new FileReader(datName));
  33.             String zeile = null;
  34.            
  35.             while ((zeile = in.readLine()) != null) {
  36.                
  37.                 if(PC == 99) break; //Programm Ende, Hlt 99
  38.                
  39.                 for (int i = 0; i<PC-1; i++) {
  40.                     zeile = in.readLine();
  41.                 }
  42.                
  43.                 leseZeile(zeile);
  44.                 in.close();
  45.                 in = new BufferedReader(new FileReader(datName));
  46.            
  47.             }
  48.         } catch (IOException e) {
  49.             e.printStackTrace();
  50.         } finally {
  51.             if (in != null)
  52.                 try {
  53.                     in.close();
  54.                 } catch (IOException e) {
  55.                 }
  56.         }
  57.     }
  58.  
  59.     private static void leseZeile(String zeile) {
  60.         String befehl = zeile.substring(0, 2);
  61.         String adresse = zeile.substring(2, 4);
  62.         befehlsTabelle(befehl, adresse);
  63.         return;
  64.     }
  65.  
  66.     private static void befehlsTabelle(String befehl, String adresse) {
  67.        
  68.         int wert = Integer.parseInt(adresse);
  69.  
  70.         switch (befehl) {
  71.         case "01":
  72.             akkumulator += register[wert];
  73.             break;
  74.            
  75.         case "02":
  76.             akkumulator -= register[wert];
  77.             break;
  78.            
  79.         case "03":
  80.             akkumulator *= register[wert];
  81.             break;
  82.            
  83.         case "04":
  84.             akkumulator /= register[wert];
  85.             break;
  86.            
  87.         case "05":
  88.             akkumulator = register[wert];
  89.             break;
  90.            
  91.         case "06":
  92.             akkumulator = wert;
  93.             break;
  94.            
  95.         case "07":
  96.             register[wert] = akkumulator;
  97.             break;
  98.            
  99.         case "08":
  100.             Scanner sc = new Scanner(System.in);
  101.             System.out.print("Bitte Wert fΓΌr n eingeben: ");
  102.             register[wert] = sc.nextInt();
  103.             sc.close();
  104.             break;
  105.            
  106.         case "09":
  107.             System.out.println(register[wert]);
  108.             break;
  109.            
  110.         case "0A":
  111.             PC = wert;
  112.             return;
  113.            
  114.         case "0B":
  115.             PC = wert;
  116.             return;
  117.            
  118.         case "0C":
  119.             if (akkumulator == 0) {
  120.                 PC = wert;
  121.                 return;
  122.             }
  123.             break;
  124.            
  125.         case "0D":
  126.             if (akkumulator != 0) {
  127.                 PC = wert;
  128.                 return;
  129.             }
  130.             break;
  131.            
  132.         case "0E":
  133.             if (akkumulator < 0) {
  134.                 PC = wert;
  135.                 return;
  136.             }
  137.             break;
  138.            
  139.         case "0F":
  140.             if (akkumulator <= 0) {
  141.                 PC = wert;
  142.                 return;
  143.             }
  144.             break;
  145.            
  146.         case "10":
  147.             if (akkumulator > 0) {
  148.                 PC = wert;
  149.                 return;
  150.             }
  151.             break;
  152.            
  153.         case "11":
  154.             if (akkumulator >= 0) {
  155.                 PC = wert;
  156.                 return;
  157.             }
  158.             break;
  159.         }
  160.        
  161.         PC++;
  162.         return;
  163.     }
  164.  
  165.    
  166.    
  167.     private static void initReg(int[] register) {
  168.         for (int i = 0; i < register.length; i++) {
  169.             register[i] = 0;
  170.         }
  171.  
  172.         return;
  173.     }
  174. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement