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