API tools faq
paste
Advertisement
Dimension

ExportStructure.java

Dimension
Dec 26th, 2011
117
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 14.66 KB | None | 0 0
raw download clone embed print report
  1. package emulator.editor;
  2.  
  3. import emulator.editor.Export.MemoryImage;
  4.  
  5. public abstract class ExportStructure {
  6.     // TODO access:
  7.     // fat pointer, string pointer (start,size)
  8.     // array list
  9.     //
  10.    
  11.     public static interface IField {
  12.        
  13.     }
  14.    
  15.     public final byte[] structure;
  16.     public final int size;
  17.    
  18.     public ExportStructure(int size) {
  19.         this.size = size;
  20.         this.structure = new byte[size];
  21.     }
  22.    
  23.     public static class InterruptDescriptorTableRegister extends ExportStructure {
  24.         public enum Field implements IField {
  25.             LIMIT, // in bytes
  26.             BASE,
  27.         }
  28.  
  29.         public InterruptDescriptorTableRegister() {
  30.             super(6); // 48 bits
  31.            
  32.             //write(Field.LIMIT, 0x800); // 8 * 256
  33.         }
  34.        
  35.         @Override
  36.         public Object read(IField field, int start) {
  37.             switch((Field) field) {
  38.             case LIMIT:
  39.                 {
  40.                     int value = 0;
  41.                     value |= structure[0] << 0; // 0
  42.                     value |= structure[1] << 8; // 8
  43.                     return value;
  44.                 }
  45.             case BASE:
  46.                 {
  47.                     int value = 0;
  48.                     value |= structure[2] << 0; // 16
  49.                     value |= structure[3] << 8; // 24
  50.                     value |= structure[4] << 16; // 32
  51.                     value |= structure[5] << 24; // 40
  52.                     return value;
  53.                 }
  54.             default:
  55.                 assert false;
  56.                 return null;
  57.             }
  58.         }
  59.         @Override
  60.         public void write(IField field, Object object) {
  61.             switch((Field) field) {
  62.             case LIMIT:
  63.                 {
  64.                     int value = (Integer) object;
  65.                     structure[0] = (byte) ((value & 0x000000FF) >>> 0); // 0
  66.                     structure[1] = (byte) ((value & 0x0000FF00) >>> 8); // 8
  67.                 }
  68.                 break;
  69.             case BASE:
  70.                 {
  71.                     int value = (Integer) object;
  72.                     structure[2] = (byte) ((value & 0x000000FF) >>> 0); // 16
  73.                     structure[3] = (byte) ((value & 0x0000FF00) >>> 8); // 24
  74.                     structure[4] = (byte) ((value & 0x00FF0000) >>> 16); // 32
  75.                     structure[5] = (byte) ((value & 0xFF000000) >>> 24); // 40
  76.                 }
  77.                 break;
  78.             default:
  79.                 assert false;
  80.             }
  81.         }
  82.     }
  83.    
  84.     public static class InterruptDescriptor extends ExportStructure {
  85.         public enum Field implements IField {
  86.             SEGMENT,
  87.             OFFSET,
  88.             TYPE_ATTR,
  89.         }
  90.        
  91.         public static class TypeAttr {
  92.             public int type = 0; // constant of Type
  93.             public boolean storageSegment = false;
  94.             public int privilege = 0; // 0 .. 3
  95.             public boolean present = true;
  96.         }
  97.        
  98.         public static class Type { // only 32-bit
  99.             public static final int TASK_GATE       = Integer.parseInt("00000101", 2); // 0x5
  100.             public static final int INTERRUPT_GATE  = Integer.parseInt("00001110", 2); // 0xE, interrupt gate, disable interrupts (fixed stack size)
  101.             public static final int TRAP_GATE       = Integer.parseInt("00001111", 2); // 0xF
  102.         }
  103.        
  104.         public InterruptDescriptor() {
  105.             super(8); // 64 bits
  106.            
  107.             structure[4] = 0; // 32
  108.         }
  109.        
  110.         @Override
  111.         public Object read(IField field, int start) {
  112.             switch((Field) field) {
  113.             case SEGMENT:
  114.                 {
  115.                     int value = 0;
  116.                     value |= structure[2] << 0; // 16
  117.                     value |= structure[3] << 8; // 24
  118.                     return value;
  119.                 }
  120.             case OFFSET:
  121.                 {
  122.                     int value = 0;
  123.                     value |= structure[0] << 0; // 0: low offset
  124.                     value |= structure[1] << 8; // 8
  125.                     value |= structure[6] << 16; // 48: high offset
  126.                     value |= structure[7] << 24; // 56
  127.                     return value;
  128.                 }
  129.             case TYPE_ATTR:
  130.                 {
  131.                     TypeAttr value = new TypeAttr();
  132.                     value.type              = (structure[5] & (byte) Integer.parseInt("00001111", 2)) >>> 0; // 40 .. 43
  133.                     value.storageSegment    = (structure[5] & (byte) Integer.parseInt("00010000", 2)) != 0; // 44
  134.                     value.privilege         = (structure[5] & (byte) Integer.parseInt("01100000", 2)) >>> 5; // 45 .. 46
  135.                     value.present           = (structure[5] & (byte) Integer.parseInt("10000000", 2)) != 0; // 47
  136.                     return value;
  137.                 }
  138.             default:
  139.                 assert false;
  140.                 return null;
  141.             }
  142.         }
  143.         @Override
  144.         public void write(IField field, Object object) {
  145.             switch((Field) field) {
  146.             case SEGMENT:
  147.                 {
  148.                     int value = (Integer) object;
  149.                     structure[2] = (byte) ((value & 0x000000FF) >>> 0); // 16
  150.                     structure[3] = (byte) ((value & 0x0000FF00) >>> 8); // 24
  151.                 }
  152.                 break;
  153.             case OFFSET:
  154.                 {
  155.                     int value = (Integer) object;
  156.                     structure[0] = (byte) ((value & 0x000000FF) >>> 0); // 0: low offset
  157.                     structure[1] = (byte) ((value & 0x0000FF00) >>> 8); // 8
  158.                     structure[6] = (byte) ((value & 0x00FF0000) >>> 16); // 48: high offset
  159.                     structure[7] = (byte) ((value & 0xFF000000) >>> 24); // 56
  160.                 }
  161.                 break;
  162.             case TYPE_ATTR:
  163.                 {
  164.                     TypeAttr value = (TypeAttr) object;
  165.                     structure[5] = 0;
  166.                     structure[5] |= (value.type         & 0x0000000F)   << 0; // 40 .. 43
  167.                     structure[5] |= (value.storageSegment   ? 1 : 0)    << 4; // 44
  168.                     structure[5] |= (value.privilege    & 0x00000003)   << 5; // 45 .. 46
  169.                     structure[5] |= (value.present          ? 1 : 0)    << 7; // 47
  170.                 }
  171.                 break;
  172.             default:
  173.                 assert false;
  174.             }
  175.         }
  176.     }
  177.    
  178.     public static class GlobalDescriptorTableRegister extends ExportStructure {
  179.         public enum Field implements IField {
  180.             SIZE, // entry count
  181.             LINEAR_ADDRESS,
  182.         }
  183.  
  184.         public GlobalDescriptorTableRegister() {
  185.             super(6); // 48 bits
  186.         }
  187.        
  188.         @Override
  189.         public Object read(IField field, int start) {
  190.             switch((Field) field) {
  191.             case SIZE:
  192.                 {
  193.                     int value = 0;
  194.                     value |= structure[0] << 0; // 0
  195.                     value |= structure[1] << 8; // 8
  196.                     value++;
  197.                     return value;
  198.                 }
  199.             case LINEAR_ADDRESS:
  200.                 {
  201.                     int value = 0;
  202.                     value |= structure[2] << 0; // 16
  203.                     value |= structure[3] << 8; // 24
  204.                     value |= structure[4] << 16; // 32
  205.                     value |= structure[5] << 24; // 40
  206.                     return value;
  207.                 }
  208.             default:
  209.                 assert false;
  210.                 return null;
  211.             }
  212.         }
  213.         @Override
  214.         public void write(IField field, Object object) {
  215.             switch((Field) field) {
  216.             case SIZE:
  217.                 {
  218.                     int value = (Integer) object;
  219.                     assert value > 0;
  220.                     value--;
  221.                     structure[0] = (byte) ((value & 0x000000FF) >>> 0); // 0
  222.                     structure[1] = (byte) ((value & 0x0000FF00) >>> 8); // 8
  223.                 }
  224.                 break;
  225.             case LINEAR_ADDRESS:
  226.                 {
  227.                     int value = (Integer) object;
  228.                     structure[2] = (byte) ((value & 0x000000FF) >>> 0); // 16
  229.                     structure[3] = (byte) ((value & 0x0000FF00) >>> 8); // 24
  230.                     structure[4] = (byte) ((value & 0x00FF0000) >>> 16); // 32
  231.                     structure[5] = (byte) ((value & 0xFF000000) >>> 24); // 40
  232.                 }
  233.                 break;
  234.             default:
  235.                 assert false;
  236.             }
  237.         }
  238.     }
  239.    
  240.     public static class GlobalDescriptor extends ExportStructure {
  241.         public enum Field implements IField {
  242.             LIMIT,
  243.             BASE,
  244.             ACCESS_BYTE,
  245.             FLAGS,
  246.         }
  247.        
  248.         public static class AccessByte {
  249.             public boolean accessed = false;
  250.             public boolean readable_writable = false; // code can read (write disallowed regardless), data can write (read allowed regardless)
  251.             public boolean direction_conforming = false; // data grows up, code specified privilege only
  252.             public boolean executable = false;
  253.             public int privilege = 3; // 0 .. 3
  254.             public boolean present = true;
  255.         }
  256.        
  257.         public static class Flags {
  258.             public boolean size = true;
  259.             public boolean granularity = true;
  260.         }
  261.  
  262.         public GlobalDescriptor() {
  263.             super(8); // 64 bits
  264.         }
  265.        
  266.         @Override
  267.         public Object read(IField field, int start) {
  268.             switch((Field) field) {
  269.             case LIMIT:
  270.                 {
  271.                     int value = 0;
  272.                     value |= structure[0] << 0; // 0: I
  273.                     value |= structure[1] << 8; // 8
  274.                     value |= (structure[6] & 0xF) << 16; // 48 .. 51: II
  275.                     return value;
  276.                 }
  277.             case BASE:
  278.                 {
  279.                     int value = 0;
  280.                     value |= structure[2] << 0; // 16: I
  281.                     value |= structure[3] << 8; // 24
  282.                     value |= structure[4] << 16; // 32: II
  283.                     value |= structure[7] << 24; // 56: III
  284.                     return value;
  285.                 }
  286.             case ACCESS_BYTE:
  287.                 {
  288.                     AccessByte value = new AccessByte();
  289.                     value.accessed              = (structure[5] & (byte) Integer.parseInt("00000001", 2)) != 0; // 40
  290.                     value.readable_writable     = (structure[5] & (byte) Integer.parseInt("00000010", 2)) != 0; // 41
  291.                     value.direction_conforming  = (structure[5] & (byte) Integer.parseInt("00000100", 2)) != 0; // 42
  292.                     value.executable            = (structure[5] & (byte) Integer.parseInt("00001000", 2)) != 0; // 43
  293.                     value.privilege             = (structure[5] & (byte) Integer.parseInt("01100000", 2)) >>> 5; // 45 .. 46
  294.                     value.present               = (structure[5] & (byte) Integer.parseInt("10000000", 2)) != 0; // 47
  295.                     return value;
  296.                 }
  297.             case FLAGS:
  298.                 {
  299.                     Flags value = new Flags();
  300.                     value.size          = (structure[6] & (byte) Integer.parseInt("01000000", 2)) != 0; // 54
  301.                     value.granularity   = (structure[6] & (byte) Integer.parseInt("10000000", 2)) != 0; // 55
  302.                     return value;
  303.                 }
  304.             default:
  305.                 assert false;
  306.                 return null;
  307.             }
  308.         }
  309.         @Override
  310.         public void write(IField field, Object object) {
  311.             switch((Field) field) {
  312.             case LIMIT:
  313.                 {
  314.                     int value = (Integer) object;
  315.                     structure[0] = (byte) ((value & 0x000000FF) >>> 0); // 0: I
  316.                     structure[1] = (byte) ((value & 0x0000FF00) >>> 8); // 8
  317.                     structure[6] &= 0xF0;
  318.                     structure[6] |= (byte) ((value & 0x000F0000) >>> 16); // 48 .. 51: II
  319.                 }
  320.                 break;
  321.             case BASE:
  322.                 {
  323.                     int value = (Integer) object;
  324.                     structure[2] = (byte) ((value & 0x000000FF) >>> 0); // 16: I
  325.                     structure[3] = (byte) ((value & 0x0000FF00) >>> 8); // 24
  326.                     structure[4] = (byte) ((value & 0x00FF0000) >>> 16);// 32: II
  327.                     structure[7] = (byte) ((value & 0xFF000000) >>> 24); // 56: III
  328.                 }
  329.                 break;
  330.             case ACCESS_BYTE:
  331.                 {
  332.                     AccessByte value = (AccessByte) object;
  333.                     structure[5] = 0;
  334.                     structure[5] |= (value.accessed             ? 1 : 0)    << 0; // 40
  335.                     structure[5] |= (value.readable_writable    ? 1 : 0)    << 1; // 41
  336.                     structure[5] |= (value.direction_conforming ? 1 : 0)    << 2; // 42
  337.                     structure[5] |= (value.executable           ? 1 : 0)    << 3; // 43
  338.                     structure[5] |= 1                                       << 4; // 44
  339.                     structure[5] |= (value.privilege        & 0x00000003)   << 5; // 45 .. 46
  340.                     structure[5] |= (value.present              ? 1 : 0)    << 7; // 47
  341.                 }
  342.                 break;
  343.             case FLAGS:
  344.                 {
  345.                     Flags value = (Flags) object;
  346.                     structure[6] &= 0x0F;
  347.                     structure[6] |= (value.size         ? 1 : 0) << 6; // 54
  348.                     structure[6] |= (value.granularity  ? 1 : 0) << 7; // 55
  349.                 }
  350.                 break;
  351.             default:
  352.                 assert false;
  353.             }
  354.         }
  355.     }
  356.    
  357.     public static class PageDirectoryEntry extends ExportStructure {
  358.         public enum Field implements IField {
  359.             FLAGS,
  360.             CUSTOM,
  361.             PHYSICAL_ADDRESS,
  362.         }
  363.        
  364.         public static class Flags {
  365.             public boolean present = true;
  366.             public boolean read_write = false;
  367.             public boolean user_supervisor = false;
  368.             public boolean writeThrough = false;
  369.             public boolean cacheDisabled = true;
  370.             public boolean accessed = false;
  371.             public boolean dirty = false;
  372.             public boolean pageSize = false;
  373.             public boolean global = false; // ignored for 4kb
  374.         }
  375.        
  376.         public PageDirectoryEntry() {
  377.             super(4); // 32 bits
  378.         }
  379.        
  380.         @Override
  381.         public Object read(IField field, int start) {
  382.             switch((Field) field) {
  383.             case FLAGS:
  384.                 {
  385.                     Flags value = new Flags();
  386.                     value.present           = (structure[0] & (byte) Integer.parseInt("00000001", 2)) != 0; // 0
  387.                     value.read_write        = (structure[0] & (byte) Integer.parseInt("00000010", 2)) != 0; // 1
  388.                     value.user_supervisor   = (structure[0] & (byte) Integer.parseInt("00000100", 2)) != 0; // 2
  389.                     value.writeThrough      = (structure[0] & (byte) Integer.parseInt("00001000", 2)) != 0; // 3
  390.                     value.cacheDisabled     = (structure[0] & (byte) Integer.parseInt("00010000", 2)) != 0; // 4
  391.                     value.accessed          = (structure[0] & (byte) Integer.parseInt("00100000", 2)) != 0; // 5
  392.                     value.dirty             = (structure[0] & (byte) Integer.parseInt("01000000", 2)) != 0; // 6
  393.                     value.pageSize          = (structure[0] & (byte) Integer.parseInt("10000000", 2)) != 0; // 7
  394.                     value.global            = (structure[1] & (byte) Integer.parseInt("00000001", 2)) != 0; // 8
  395.                     return value;
  396.                 }
  397.             case CUSTOM:
  398.                 {
  399.                     int value = 0;
  400.                     value |= (structure[1] & (byte) Integer.parseInt("00001110", 2)) >>> 1; // 9 .. 11
  401.                     return value;
  402.                 }
  403.             case PHYSICAL_ADDRESS:
  404.                 {
  405.                     int value = 0;
  406.                     value |= (structure[1] & 0xF0) << 8; // 12 .. 15
  407.                     value |= structure[2] << 16; // 16
  408.                     value |= structure[3] << 24; // 24
  409.                     return value;
  410.                 }
  411.             default:
  412.                 assert false;
  413.                 return null;
  414.             }
  415.         }
  416.         @Override
  417.         public void write(IField field, Object object) {
  418.             switch((Field) field) {
  419.             case FLAGS:
  420.                 {
  421.                     Flags value = (Flags) object;
  422.                     structure[0] = 0;
  423.                     structure[0] |= (value.present          ? 1 : 0) << 0; // 0
  424.                     structure[0] |= (value.read_write       ? 1 : 0) << 1; // 1
  425.                     structure[0] |= (value.user_supervisor  ? 1 : 0) << 2; // 2
  426.                     structure[0] |= (value.writeThrough     ? 1 : 0) << 3; // 3
  427.                     structure[0] |= (value.cacheDisabled    ? 1 : 0) << 4; // 4
  428.                     structure[0] |= (value.accessed         ? 1 : 0) << 5; // 5
  429.                     structure[0] |= (value.dirty            ? 1 : 0) << 6; // 6
  430.                     structure[0] |= (value.pageSize         ? 1 : 0) << 7; // 7
  431.                     structure[1] &= (byte) Integer.parseInt("11111110", 2);
  432.                     structure[1] |= (value.global           ? 1 : 0) << 0; // 8
  433.                 }
  434.                 break;
  435.             case CUSTOM:
  436.                 {
  437.                     int value = (Integer) object;
  438.                     structure[1] &= (byte) Integer.parseInt("11110001", 2);
  439.                     structure[1] |= (byte) ((value & (byte) Integer.parseInt("00000111", 2)) << 1); // 9 .. 11
  440.                 }
  441.                 break;
  442.             case PHYSICAL_ADDRESS:
  443.                 {
  444.                     int value = (Integer) object;
  445.                     structure[1] &= 0x0F;
  446.                     structure[1] |= (byte) ((value & 0x0000F000) >>> 8); // 12 .. 15
  447.                     structure[2] = (byte) ((value & 0x00FF0000) >>> 16); // 16
  448.                     structure[3] = (byte) ((value & 0xFF000000) >>> 24); // 24
  449.                 }
  450.                 break;
  451.             default:
  452.                 assert false;
  453.             }
  454.         }
  455.     }
  456.    
  457.     /*public static class TaskSegmentDescriptor extends ExportStructure {
  458.         public enum Field implements IField {
  459.             LIMIT,
  460.             BASE,
  461.             FLAGS,
  462.            
  463.         }
  464.        
  465.         public TaskSegmentDescriptor(int size) {
  466.             super(8);
  467.         }
  468.        
  469.         @Override
  470.         public Object read(IField field, int start) {
  471.             return null;
  472.         }
  473.         @Override
  474.         public void write(IField field, Object object) {
  475.            
  476.         }
  477.     }
  478.    
  479.     public static class TaskSegment extends ExportStructure {
  480.         public enum Field implements IField {
  481.             PREVIOUS_TASK,
  482.             ESP0,
  483.             ESP1,
  484.             ESP2,
  485.             SS0,
  486.             SS1,
  487.             SS2,
  488.             CR3,
  489.             EIP,
  490.             EFLAGS,
  491.             EAX,
  492.             ECX,
  493.             EDX,
  494.             EBX,
  495.             ESP,
  496.             EBP,
  497.             ESI,
  498.             EDI,
  499.             ES,
  500.             CS,
  501.             SS,
  502.             DS,
  503.             FS,
  504.             GS,
  505.             LDT_SELECTOR,
  506.             IO_MAP_BASE,
  507.         }
  508.        
  509.         public TaskSegment(int size) {
  510.             super(1234);
  511.         }
  512.        
  513.         @Override
  514.         public Object read(IField field, int start) {
  515.             assert false;
  516.             return null;
  517.         }
  518.         @Override
  519.         public void write(IField field, Object object) {
  520.             assert false;
  521.         }
  522.     }*/
  523.  
  524.     public abstract Object read(IField field, int start); // load structure field from memory
  525.     public abstract void write(IField field, Object object); // write structure field to memory
  526. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!