Added better printing.

Author: willemneal

lib/parse/assembly/host/index.ts

@@ -3,14 +3,14 @@ export declare function _log<T>(x: T, size: usize): void;
 export declare function _log_str(x: string): void;
 
 
-export function log<T>(item: T, isStr: boolean = false):void {
-  if (isStr){
+export function log<T>(item: T, size:usize = 4, isStr: boolean = false):void {
+  if (isStr) {
     _log_str(changetype<string>(item));
-  }else{
-    _log(item, sizeof<T>());
+  } else {
+    _log<T>(item, size);
   }
 }
 
 export function log_str(item: string): void {
-  log<string>(item, true);
+  log<string>(item, sizeof<string>(), true);
 }

lib/parse/assembly/index.ts

@@ -56,10 +56,13 @@ declare function debug():void;
 
 let type: TypeSection;
 
-export function getType(): TypeSection {
-  return type;
+export function getType(): string {
+  return type.toString();
 }
 
+export function toString(t:TypeSection): string {
+  return t.toString();
+}
 
 export class Parser {
   buf: Buffer;
@@ -118,6 +121,7 @@ export function parse(p: Parser): Module {
   let headers:SectionHeader[] = p.module.getID(SectionId.Type);
   let section = new TypeSection(headers[0]);
   type = (section).parse(p.module.buf);
-
+  log<i32>(offsetof<TypeSection>());
+  log<TypeSection>(type, offsetof<TypeSection>());
   return p.module;
 }

lib/parse/assembly/module/index.ts

@@ -12,6 +12,8 @@ import {Buffer} from '../buffer';
 
 import {log, log_str} from "../host";
 
+import {itoa} from 'internal/number';
+
 type byte = u8;
 
 
@@ -22,6 +24,7 @@ export class Module {
 
   constructor(buf: Buffer){
     this.buf = buf;
+    this.Headers = [];
   }
 
 
@@ -72,6 +75,28 @@ export class Module {
 
 }
 
+function typeName(t: Type): string{
+  switch (t){
+    case 0x7f:
+      return 'i32';
+    case 0x7e:
+      return 'i64';
+    case 0x7d:
+      return 'f32';
+    case 0x7c:
+      return 'f64';
+    case 0x70:
+      return 'anyfunc';
+    case 0x60:
+      return 'func';
+    case 0x40:
+      return 'none';
+    default:
+      unreachable();
+  }
+  return ""
+}
+
 function sectionName(s: SectionId): string {
   switch (s){
     case 0:
@@ -170,7 +195,25 @@ class Section {
 
 
 class FuncType {
-  constructor(public index: u32, public form: i32,  public parameters: i32[],  public returnVals: i32[]){}
+  public parameters: i32[];
+  public returnVals: i32[];
+  constructor(public index: u32, public form: i32){
+    this.parameters = [];
+    this.returnVals = [];
+  }
+
+
+
+  toString(): string {
+    let index = itoa<u32>(this.index);
+    let form = typeName(this.form);
+    let parameters:string[] = [];
+    for (let i = 0; i< this.parameters.length; i++){
+      parameters.push(typeName(this.parameters[i]));
+    }
+    let returnVal = this.returnVals.length == 1 ? typeName(this.returnVals[0]) : "";
+    return "index: " + index + ", " + "form: " + form + ", parameters: " + parameters.join(", ") + " returnVal: " + returnVal;
+  }
 }
 
 export class TypeSection {
@@ -183,22 +226,28 @@ export class TypeSection {
 
   // constructor(public header: SectionHeader){}
   parse(buf: Buffer): TypeSection {
-    log<string>("parsing TypeSection", true);
+    log_str("parsing TypeSection");
     log<usize>(buf.off);
-    log<string>(this.header.name, true);
+    log_str(this.header.name);
     buf.off = this.header.payload_off;
     log<usize>(buf.off);
     let count = buf.readVaruint(32);
     log<usize>(count);
+    // let func: FuncType;
+    let parameters: i32[];
     for (let index: u32 = 0; index < count; ++index) {
       log<u32>(index);
       let form = buf.readVarint(7) & 0x7f;
+      // func = new FuncType(index, form);
       // opt.onType(
       //   index,
       //   form
       // );
       let paramCount = buf.readVaruint(32);
-      let parameters: i32[] = [];
+      log_str("param count.");
+      log<u32>(paramCount);
+      parameters = [];
+      log<u32>(parameters.length);
       for (let paramIndex: u32 = 0; paramIndex < paramCount; ++paramIndex) {
         let paramType = buf.readVarint(7) & 0x7f;
         // opt.onTypeParam(
@@ -208,24 +257,33 @@ export class TypeSection {
         // );
         parameters.push(paramType)
       }
+      log<i32>(parameters.length);
       let returnCount = buf.readVaruint(1); // MVP
-      let returnVals: i32[] = [];
       for (let returnIndex: u32 = 0; returnIndex < returnCount; ++returnIndex) {
         let returnType = buf.readVarint(7) & 0x7f;
         // opt.onTypeReturn(
         //   index,
         //   returnIndex,
         //   returnType
         // );
-        returnVals.push(returnType);
+        // func.returnVals.push(returnType);
       }
-      this.funcs.push(new FuncType(index, form, parameters, returnVals));
+      // log_str(func.toString());
+      // this.funcs.push(func);
     }
     // buf.off = this.end;
-    log<string>("Finished type section",true)
+    log_str("Finished type section");
     return this;
   }
 
+  toString(): string {
+    let strs: string[] = [];
+    for (let i=0; i< this.funcs.length; i++){
+      strs.push(this.funcs[i].toString());
+    }
+    return strs.join('\n');
+  }
+
 }
 
 /*