Adding more warning messages

Author: danijelaskov

src/app/bytecode-viewer/bytecode-viewer.component.html

@@ -42,11 +42,15 @@
  <img src="assets/gear.gif" alt="Spinner" style="width: 32px; height: auto;" />&nbsp;Wait for a few seconds... Crunching zeros and ones just for you!
  </ng-container>
  <ng-template #elseTemplate7>
- {{disassembler.getCodeSize() + ' bytes'}}
- <ng-container *ngIf="disassembler.getCodeSize() < 0">
+ {{disassembler.getDeclaredCodeSize() + ' bytes'}}
+ <ng-container *ngIf="disassembler.getDeclaredCodeSize() < 0">
  &nbsp;
  <fa-icon [icon]="exclamationIcon" class="pulse red-colored" data-toggle="tooltip" data-placement="bottom" title="Negative value is not expected here!"></fa-icon>
  </ng-container>
+ <ng-container *ngIf="disassembler.getDeclaredCodeSize() !== disassembler.getRealCodeSize()">
+ &nbsp;
+ <fa-icon [icon]="exclamationIcon" class="pulse red-colored" data-toggle="tooltip" data-placement="bottom" title="Code size declared here does not match real code size!"></fa-icon>
+ </ng-container>
  </ng-template>
  </td>
  </tr>
@@ -72,7 +76,7 @@
  <img src="assets/gear.gif" alt="Spinner" style="width: 32px; height: auto;" />&nbsp;Wait for a few seconds... Crunching zeros and ones just for you!
  </ng-container>
  <ng-template #elseTemplate9>
- <ng-container *ngIf="disassembler.getEntryPoint() < disassembler.getCodeSize(); else elseTemplate11">
+ <ng-container *ngIf="disassembler.getEntryPoint() < disassembler.getRealCodeSize(); else elseTemplate11">
  <a href="{{'#address-' + disassembler.getEntryPoint()}}">{{disassembler.getEntryPoint()}}</a>
  </ng-container>
  <ng-template #elseTemplate11>

src/app/shared/disassembler.shared.ts

@@ -17,7 +17,7 @@
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  */
 
-class Instruction {
+export class Instruction {
  public readonly opcode: number;
  public readonly mnemonic: string;
 }
@@ -52,22 +52,23 @@ class DisassembledInstruction {
 
 export class Disassembler {
 
- uint8Array: Uint8Array;
- current: number = 0;
- address: number = 0;
- headerSize: number = 0;
+ private uint8Array: Uint8Array;
+ private current: number = 0;
+ private address: number = 0;
+ private headerSize: number = 0;
  public disassembledInstructions: DisassembledInstruction[];
 
- opcode: number;
- operand1: number;
- operand2: number;
+ private opcode: number;
+ private operand1: number;
+ private operand2: number;
 
- codeSize: number;
- dataSize: number;
- entryPoint: number;
+ private declaredCodeSize: number;
+ private realCodeSize = 0;
+ private dataSize: number;
+ private entryPoint: number;
 
- jumpDestination: number;
- warning: string;
+ private jumpDestination: number;
+ private warning: string;
 
  public static readonly MIN_OBJ_SIZE: number = 1 + 1 + 3 * 4 + 1;
 
@@ -149,6 +150,8 @@ export class Disassembler {
  public static readonly DUP_X1: Instruction = {mnemonic: "dup_x1", opcode: 59};
  public static readonly DUP_X2: Instruction = {mnemonic: "dup_x2", opcode: 60};
 
+ public static readonly INVALID_INSTR: Instruction = {mnemonic: "", opcode: 61};
+
  public static readonly INSTRUCTIONS: Instruction[] = [
  Disassembler.LOAD, Disassembler.LOAD_0, Disassembler.LOAD_1, Disassembler.LOAD_2,
  Disassembler.LOAD_3, Disassembler.STORE, Disassembler.STORE_0, Disassembler.STORE_1,
@@ -175,6 +178,7 @@ export class Disassembler {
  }
 
  get() {
+ this.realCodeSize++;
  return this.uint8Array[this.current++] & 0x0ff;
  }
 
@@ -207,9 +211,11 @@ export class Disassembler {
  else if (String.fromCharCode(this.get()) != 'M' || String.fromCharCode(this.get()) != 'J')
  throw new Error("The file has invalid header!");
 
- this.codeSize = this.get4();
+ this.declaredCodeSize = this.get4();
  this.dataSize = this.get4();
  this.entryPoint = this.get4();
+
+ this.realCodeSize = 0;
 
  this.headerSize = this.current;
  this.address = this.current - this.headerSize;
@@ -265,11 +271,17 @@ export class Disassembler {
  }
 case Disassembler.GETSTATIC.opcode: {
  this.operand1 = this.get2();
+ if (this.operand1 >= this.dataSize) {
+ this.warning = "This adress is out of Data memory area address range" + (this.dataSize > 0 ? "([0, " + (this.dataSize - 1) + "])" : "") + "!"; 
+ }
  this.put(Disassembler.GETSTATIC, new Uint8Array([this.opcode, (this.operand1 >> 8) & 0x0ff, this.operand1 & 0x0ff]), this.operand1.toString());
  break;
  }
 case Disassembler.PUTSTATIC.opcode: {
  this.operand1 = this.get2();
+ if (this.operand1 >= this.dataSize) {
+ this.warning = "This adress is out of Data memory area address range" + (this.dataSize > 0 ? "([0, " + (this.dataSize - 1) + "])" : "") + "!"; 
+ }
  this.put(Disassembler.PUTSTATIC, new Uint8Array([this.opcode,(this.operand1 >> 8) & 0x0ff, this.operand1 & 0x0ff]), this.operand1.toString());
  break;
  }
@@ -508,7 +520,7 @@ export class Disassembler {
  } 
 default: {
  this.warning = 'This is not a valid instruction!';
- this.put({opcode: -1, mnemonic: ''}, new Uint8Array([this.opcode]));
+ this.put(Disassembler.INVALID_INSTR, new Uint8Array([this.opcode]));
  break;
  }
  }
@@ -521,8 +533,8 @@ export class Disassembler {
  });
  }
 
- getCodeSize() {
- return this.codeSize;
+ getDeclaredCodeSize() {
+ return this.declaredCodeSize;
  }
 
  getDataSize() {
@@ -533,4 +545,8 @@ export class Disassembler {
  return this.entryPoint;
  }
 
+ getRealCodeSize() {
+ return this.realCodeSize;
+ }
+
 }

src/app/stats/stats.component.html

@@ -78,8 +78,8 @@ <h3>Instructions</h3>
  <code>{{leftOutInstruction.mnemonic}}</code>
  </li>
 </ol>
-<p>Instructions that do appear in this object file are:</p>
-<div class="table-responsive">
+<p *ngIf="!loading && instructionCountArray.length">Instructions that do appear in this object file are:</p>
+<div *ngIf="!loading && instructionCountArray.length" class="table-responsive">
  <table class="table table-bordered table-hover">
  <thead>
  <tr>

src/app/stats/stats.component.ts

@@ -18,7 +18,7 @@
  */
 
 import { Component, OnInit, Input } from '@angular/core';
-import { Disassembler } from '../shared/disassembler.shared';
+import { Disassembler, Instruction } from '../shared/disassembler.shared';
 
 @Component({
  selector: 'stats-component',
@@ -38,7 +38,7 @@ export class StatsComponent implements OnInit {
  public instructionCountArray = [];
 
  public totalNumInstructions = Disassembler.INSTRUCTIONS.length;
- public leftOutInstructions = Object.assign([], Disassembler.INSTRUCTIONS);
+ public leftOutInstructions: Instruction[] = [];
 
  constructor() { }
 
@@ -57,20 +57,23 @@ export class StatsComponent implements OnInit {
  this.numJumpInstructions = 0;
  this.instructionCount = {};
  this.instructionCountArray = [];
+ this.leftOutInstructions = Object.assign([], Disassembler.INSTRUCTIONS);
 
- this.numInstructions = disassembler.disassembledInstructions.length;
  disassembler.disassembledInstructions.forEach(disassembledInstruction => {
- this.averageInstructionLength += disassembledInstruction.bytes.length;
- if (disassembledInstruction.instruction == Disassembler.RETURN)
- this.numSubroutines++;
- else if (disassembledInstruction.instruction.opcode >= Disassembler.JMP.opcode && disassembledInstruction.instruction.opcode <= Disassembler.JGE.opcode && !disassembledInstruction.warning) {
- this.averageJumpOffset += disassembledInstruction.referencedAddress - disassembledInstruction.address;
- this.numJumpInstructions++;
+ if (disassembledInstruction.instruction !== Disassembler.INVALID_INSTR) {
+ this.numInstructions++;
+ this.averageInstructionLength += disassembledInstruction.bytes.length;
+ if (disassembledInstruction.instruction == Disassembler.RETURN)
+ this.numSubroutines++;
+ else if (disassembledInstruction.instruction.opcode >= Disassembler.JMP.opcode && disassembledInstruction.instruction.opcode <= Disassembler.JGE.opcode && !disassembledInstruction.warning) {
+ this.averageJumpOffset += disassembledInstruction.referencedAddress - disassembledInstruction.address;
+ this.numJumpInstructions++;
+ }
+ let mnemonic = disassembledInstruction.instruction.mnemonic;
+ if (!(mnemonic in this.instructionCount))
+ this.instructionCount[mnemonic] = 0;
+ this.instructionCount[mnemonic]++;
  }
- let mnemonic = disassembledInstruction.instruction.mnemonic;
- if (!(mnemonic in this.instructionCount))
- this.instructionCount[mnemonic] = 0;
- this.instructionCount[mnemonic]++;
  });
  this.averageInstructionLength /= this.numInstructions;
  this.averageJumpOffset = this.numJumpInstructions ? this.averageJumpOffset / this.numJumpInstructions : 0;