net.mograsim.machine/src/net/mograsim/machine/mi/MicroprogramMemoryParser.java

   1 package net.mograsim.machine.mi;
   2
   3 import java.io.BufferedReader;
   4 import java.io.FileInputStream;
   5 import java.io.FileOutputStream;
   6 import java.io.IOException;
   7 import java.io.InputStreamReader;
   8 import java.io.OutputStreamWriter;
   9 import java.math.BigInteger;
  10 import java.util.ArrayList;
  11 import java.util.List;
  12
  13 import net.mograsim.logic.core.types.BitVector;
  14 import net.mograsim.machine.MemoryDefinition;
  15 import net.mograsim.machine.mi.parameters.BooleanClassification;
  16 import net.mograsim.machine.mi.parameters.BooleanImmediate;
  17 import net.mograsim.machine.mi.parameters.IntegerClassification;
  18 import net.mograsim.machine.mi.parameters.IntegerImmediate;
  19 import net.mograsim.machine.mi.parameters.MicroInstructionParameter;
  20 import net.mograsim.machine.mi.parameters.MnemonicFamily;
  21 import net.mograsim.machine.mi.parameters.MnemonicFamily.MnemonicPair;
  22 import net.mograsim.machine.mi.parameters.ParameterClassification;
  23
  24 public class MicroprogramMemoryParser
  25 {
  26         public static MicroprogramMemory parseMemory(MicroInstructionDefinition definition, String input) throws IOException
  27         {
  28                 try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(input))))
  29                 {
  30                         return parseMemory(definition, reader);
  31                 }
  32         }
  33
  34         public static MicroprogramMemory parseMemory(MicroInstructionDefinition definition, BufferedReader input)
  35         {
  36                 List<MicroInstruction> instructions = new ArrayList<>();
  37                 try
  38                 {
  39                         String line;
  40                         while (input.ready() && !"".equals((line = input.readLine())))
  41                                 instructions.add(parse(definition, line));
  42                 } catch (IOException e)
  43                 {
  44                         e.printStackTrace();
  45                 }
  46
  47                 int maxAddress = instructions.size() - 1;
  48                 MicroprogramMemory memory = MicroprogramMemory
  49                                 .create(MemoryDefinition.create((int) Math.ceil(Math.log(maxAddress)), 0, maxAddress));
  50                 int i = 0;
  51                 for (MicroInstruction inst : instructions)
  52                         memory.setCell(i++, inst);
  53                 return memory;
  54         }
  55
  56         public static MicroInstruction parse(MicroInstructionDefinition definition, String toParse)
  57         {
  58                 int size = definition.size();
  59                 String[] strings = toParse.split(",");
  60                 if (size != strings.length)
  61                         throw new MicroprogramMemoryParseException(
  62                                         "String does not match definition! The number of parameters does not match.");
  63                 MicroInstructionParameter[] params = new MicroInstructionParameter[size];
  64                 ParameterClassification[] classes = definition.getParameterClassifications();
  65                 try
  66                 {
  67                         for (int i = 0; i < size; i++)
  68                         {
  69                                 params[i] = classes[i].parse(strings[i]);
  70                         }
  71                         return new StandardMicroInstruction(params);
  72                 } catch (Exception e)
  73                 {
  74                         throw new MicroprogramMemoryParseException(e.getCause());
  75                 }
  76         }
  77
  78         public static void write(MicroprogramMemory memory, String output) throws IOException
  79         {
  80                 try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(output)))
  81                 {
  82                         write(memory, writer);
  83                 }
  84         }
  85
  86         public static void write(MicroprogramMemory memory, OutputStreamWriter output) throws IOException
  87         {
  88                 MemoryDefinition def = memory.getDefinition();
  89                 long min = def.getMinimalAddress(), max = def.getMaximalAddress() + 1;
  90                 for (long i = min; i < max; i++)
  91                 {
  92                         output.write(toCSV(memory.getCell(i)) + "\n");
  93                 }
  94         }
  95
  96         private static String toCSV(MicroInstruction inst)
  97         {
  98                 int max = inst.getSize() - 1;
  99                 StringBuilder sb = new StringBuilder();
 100                 for (int i = 0; i < max; i++)
 101                 {
 102                         sb.append(inst.getParameter(i).toString());
 103                         sb.append(",");
 104                 }
 105                 sb.append(inst.getParameter(max).toString());
 106                 return sb.toString();
 107         }
 108
 109         public static void main(String[] args)
 110         {
 111                 MnemonicFamily family = new MnemonicFamily(new MnemonicPair("ZERO", BitVector.SINGLE_0),
 112                                 new MnemonicPair("ONE", BitVector.SINGLE_1));
 113                 MicroInstructionDefinition def = MicroInstructionDefinition.create(new BooleanClassification(),
 114                                 new IntegerClassification(8), family);
 115                 MicroprogramMemory memory = new StandardMicroprogramMemory(MemoryDefinition.create(4, 0, 16));
 116                 for (int i = 0; i < 17; i++)
 117                         memory.setCell(i, new StandardMicroInstruction(new BooleanImmediate(false),
 118                                         new IntegerImmediate(BigInteger.valueOf(i), 8), family.get(i % 2)));
 119                 try
 120                 {
 121                         write(memory, "test.txt");
 122                         MicroprogramMemory newMemory = parseMemory(def, "test.txt");
 123                         write(newMemory, "test2.txt");
 124                 } catch (IOException e)
 125                 {
 126                         e.printStackTrace();
 127                 }
 128
 129         }
 130 }