add support for long const

src/de/inetsoftware/jwebassembly/binary/BinaryModuleWriter.java

@@ -93,16 +93,16 @@ public class BinaryModuleWriter extends ModuleWriter implements InstructionOpcod
             WasmOutputStream stream = new WasmOutputStream();
             stream.writeVaruint32( count );
             for( FunctionType type : functionTypes ) {
-                stream.writeVarint32( ValueType.func.getCode() );
+                stream.writeVarint( ValueType.func.getCode() );
                 stream.writeVaruint32( type.params.size() );
                 for( ValueType valueType : type.params ) {
-                    stream.writeVarint32( valueType.getCode() );
+                    stream.writeVarint( valueType.getCode() );
                 }
                 if( type.result == null ) {
                     stream.writeVaruint32( 0 );
                 } else {
                     stream.writeVaruint32( 1 );
-                    stream.writeVarint32( type.result.getCode() );
+                    stream.writeVarint( type.result.getCode() );
                 }
             }
             wasm.writeSection( SectionType.Type, stream, null );
@@ -217,7 +217,7 @@ public class BinaryModuleWriter extends ModuleWriter implements InstructionOpcod
         localsStream.writeVaruint32( locals.size() );
         for( ValueType valueType : locals ) {
             localsStream.writeVaruint32( 1 ); // TODO optimize, write the count of same types.
-            localsStream.writeVarint32( valueType.getCode() );
+            localsStream.writeVarint( valueType.getCode() );
         }
         functionsStream.writeVaruint32( localsStream.size() + codeStream.size() + 1 );
         localsStream.writeTo( functionsStream );
@@ -231,7 +231,16 @@ public class BinaryModuleWriter extends ModuleWriter implements InstructionOpcod
     @Override
     protected void writeConstInt( int value ) throws IOException {
         codeStream.write( I32_CONST );
-        codeStream.writeVarint32( value );
+        codeStream.writeVarint( value );
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void writeConstLong( long value ) throws IOException {
+        codeStream.write( I64_CONST );
+        codeStream.writeVarint( value );
     }
 
     /**

src/de/inetsoftware/jwebassembly/binary/WasmOutputStream.java

@@ -90,9 +90,9 @@ class WasmOutputStream extends FilterOutputStream {
      * @throws IOException
      *             if an I/O error occurs.
      */
-    void writeVarint32( int value ) throws IOException {
+    void writeVarint( long value ) throws IOException {
         while( true ) {
-            int b = value & 0x7F;
+            int b = (int)value & 0x7F;
             value >>= 7;
 
             /* sign bit of byte is second high order bit (0x40) */

src/de/inetsoftware/jwebassembly/module/ModuleWriter.java

@@ -28,6 +28,7 @@ import de.inetsoftware.classparser.Annotations;
 import de.inetsoftware.classparser.ClassFile;
 import de.inetsoftware.classparser.Code;
 import de.inetsoftware.classparser.CodeInputStream;
+import de.inetsoftware.classparser.ConstantPool;
 import de.inetsoftware.classparser.LineNumberTable;
 import de.inetsoftware.classparser.MethodInfo;
 import de.inetsoftware.jwebassembly.WasmException;
@@ -93,11 +94,11 @@ public abstract class ModuleWriter implements Closeable {
                                     i + 1 == lineNumberTable.size() ? code.getCodeSize()
                                                     : lineNumberTable.getStartOffset( i + 1 );
                     CodeInputStream byteCode = code.getByteCode( offset, nextOffset - offset );
-                    writeCodeChunk( byteCode, lineNumber );
+                    writeCodeChunk( byteCode, lineNumber, method.getConstantPool() );
                 }
             } else {
                 CodeInputStream byteCode = code.getByteCode();
-                writeCodeChunk( byteCode, -1 );
+                writeCodeChunk( byteCode, -1, method.getConstantPool() );
             }
             for( int i = Math.min( paramCount, locals.size() ); i > 0; i-- ) {
                 locals.remove( 0 );
@@ -237,7 +238,7 @@ public abstract class ModuleWriter implements Closeable {
      * @throws WasmException
      *             if some Java code can't converted
      */
-    private void writeCodeChunk( CodeInputStream byteCode, int lineNumber ) throws WasmException {
+    private void writeCodeChunk( CodeInputStream byteCode, int lineNumber, ConstantPool constantPool  ) throws WasmException {
         try {
             while( byteCode.available() > 0 ) {
                 int op = byteCode.readUnsignedByte();
@@ -248,6 +249,9 @@ public abstract class ModuleWriter implements Closeable {
                     case 16: //bipush
                         writeConstInt( byteCode.readByte() );
                         break;
+                    case 20: //ldc2_w
+                        writeConstLong( (Long)constantPool.get( byteCode.readUnsignedShort() ) );
+                        break;
                     case 26: // iload_0
                     case 27: // iload_1
                     case 28: // iload_2
@@ -264,6 +268,7 @@ public abstract class ModuleWriter implements Closeable {
                         writeAddInt();
                         break;
                     case 172: // ireturn
+                    case 173: // lreturn
                     case 177: // return void
                         writeReturn();
                         break;
@@ -286,6 +291,30 @@ public abstract class ModuleWriter implements Closeable {
      */
     protected abstract void writeConstInt( int value ) throws IOException;
 
+    /**
+     * Write a constant long value
+     * 
+     * @param value
+     *            the value
+     * @throws IOException
+     *             if any I/O error occur
+     */
+    protected abstract void writeConstLong( long value ) throws IOException;
+
+    /**
+     * Write or Load a local variable.
+     * 
+     * @param load
+     *            true: if load
+     * @param valueType
+     *            the type of the variable
+     * @param idx
+     *            the idx of the variable
+     * @throws WasmException
+     *             occur a if a variable was used for a different type
+     * @throws IOException
+     *             if any I/O error occur
+     */
     private void writeLoadStore( boolean load, @Nonnull ValueType valueType, @Nonnegative int idx ) throws WasmException, IOException {
         while( locals.size() <= idx ) {
             locals.add( null );

src/de/inetsoftware/jwebassembly/text/TextModuleWriter.java

@@ -111,6 +111,15 @@ public class TextModuleWriter extends ModuleWriter {
         methodOutput.append( "i32.const " ).append( Integer.toString( value ) );
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void writeConstLong( long value ) throws IOException {
+        newline( methodOutput );
+        methodOutput.append( "i64.const " ).append( Long.toString( value ) );
+    }
+
     /**
      * {@inheritDoc}
      */