Rename fletch -> dartino

tools/servicec/lib/src/plugins/java.dart

 // Copyright (c) 2015, the Dartino project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library old_servicec.plugins.java;
 
 import 'dart:core' hide Type;
 import 'dart:io';
 
 import 'package:path/path.dart' show
@@ skipping 19 matching lines @@
 
 const HEADER_MK = """
 # Copyright (c) 2015, the Dartino project authors. Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE.md file.
 
 # Generated file. Do not edit.
 """;
 
 const READER_HEADER = """
-package fletch;
+package dartino;
 """;
 
-const FLETCH_API_JAVA = """
-package fletch;
+const DARTINO_API_JAVA = """
+package dartino;
 
-public class FletchApi {
+public class DartinoApi {
   public static abstract class PrintInterceptor {
     public abstract void Out(String message);
     public abstract void Error(String message);
     private long nativePtr = 0;
   }
   public static native void Setup();
   public static native void TearDown();
   public static native void RunSnapshot(byte[] snapshot);
   public static native void WaitForDebuggerConnection(int port);
   public static native void AddDefaultSharedLibrary(String library);
   public static native void RegisterPrintInterceptor(PrintInterceptor interceptor);
   public static native void UnregisterPrintInterceptor(PrintInterceptor interceptor);
 }
 """;
 
-const FLETCH_SERVICE_API_JAVA = """
-package fletch;
+const DARTINO_SERVICE_API_JAVA = """
+package dartino;
 
-public class FletchServiceApi {
+public class DartinoServiceApi {
   public static native void Setup();
   public static native void TearDown();
 }
 """;
 
-const FLETCH_API_JAVA_IMPL = """
+const DARTINO_API_JAVA_IMPL = """
 #include <jni.h>
 #include <stdlib.h>
 
-#include "fletch_api.h"
+#include "dartino_api.h"
 
 #ifdef ANDROID
   typedef JNIEnv* AttachEnvType;
 #else
   typedef void* AttachEnvType;
 #endif
 
 static JNIEnv* AttachCurrentThreadAndGetEnv(JavaVM* vm) {
   AttachEnvType result = NULL;
   if (vm->AttachCurrentThread(&result, NULL) != JNI_OK) {
     // TODO(zerny): Nicer error recovery?
     exit(1);
   }
   return reinterpret_cast<JNIEnv*>(result);
 }
 
 class JNIPrintInterceptorInfo {
  public:
   JNIPrintInterceptorInfo(JavaVM* vm, jobject obj)
     : vm(vm), obj(obj), interceptor(NULL) {}
   JavaVM* vm;
   jobject obj;
-  FletchPrintInterceptor interceptor;
+  DartinoPrintInterceptor interceptor;
 };
 
 static void JNIPrintInterceptorFunction(
     const char* message, int out, void* raw) {
   JNIPrintInterceptorInfo* info =
       reinterpret_cast<JNIPrintInterceptorInfo*>(raw);
   JNIEnv* env = AttachCurrentThreadAndGetEnv(info->vm);
   jobject obj = info->obj;
   jclass clazz = env->GetObjectClass(obj);
   jmethodID method = NULL;
   const char* methodName = (out == 2) ? "Out" : (out == 3) ? "Error" : NULL;
   const char* methodSig = "(Ljava/lang/String;)V";
   if (methodName == NULL) exit(1);
   method = env->GetMethodID(clazz, methodName, methodSig);
   jstring argument = env->NewStringUTF(message);
   env->CallVoidMethod(obj, method, argument);
   info->vm->DetachCurrentThread();
 }
 
 static void RegisterPrintInterceptor(JNIEnv* env, jobject obj) {
   // TODO(zerny): Associate the Java object and native object in a map.
   jclass clazz = env->GetObjectClass(obj);
   jfieldID nativePtr = env->GetFieldID(clazz, "nativePtr", "J");
   jlong nativePtrValue = env->GetLongField(obj, nativePtr);
   if (nativePtrValue != 0) return;
   obj = env->NewGlobalRef(obj);
   JavaVM* vm = NULL;
   env->GetJavaVM(&vm);
   JNIPrintInterceptorInfo* info = new JNIPrintInterceptorInfo(vm, obj);
-  info->interceptor = FletchRegisterPrintInterceptor(
+  info->interceptor = DartinoRegisterPrintInterceptor(
       JNIPrintInterceptorFunction, reinterpret_cast<void*>(info));
   env->SetLongField(obj, nativePtr, reinterpret_cast<jlong>(info));
 }
 
 static void UnregisterPrintInterceptor(JNIEnv* env, jobject obj) {
   // TODO(zerny): Retrieve the native object from the Java object via a map.
   jclass clazz = env->GetObjectClass(obj);
   jfieldID nativePtr = env->GetFieldID(clazz, "nativePtr", "J");
   jlong nativePtrValue = env->GetLongField(obj, nativePtr);
   if (nativePtrValue == 0) return;
   env->SetLongField(obj, nativePtr, 0);
   JNIPrintInterceptorInfo* info =
       reinterpret_cast<JNIPrintInterceptorInfo*>(nativePtrValue);
-  FletchUnregisterPrintInterceptor(info->interceptor);
+  DartinoUnregisterPrintInterceptor(info->interceptor);
   env->DeleteGlobalRef(info->obj);
   delete info;
 }
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-JNIEXPORT void JNICALL Java_fletch_FletchApi_Setup(JNIEnv*, jclass) {
-  FletchSetup();
+JNIEXPORT void JNICALL Java_dartino_DartinoApi_Setup(JNIEnv*, jclass) {
+  DartinoSetup();
 }
 
-JNIEXPORT void JNICALL Java_fletch_FletchApi_TearDown(JNIEnv*, jclass) {
-  FletchTearDown();
+JNIEXPORT void JNICALL Java_dartino_DartinoApi_TearDown(JNIEnv*, jclass) {
+  DartinoTearDown();
 }
 
-JNIEXPORT void JNICALL Java_fletch_FletchApi_RunSnapshot(JNIEnv* env,
+JNIEXPORT void JNICALL Java_dartino_DartinoApi_RunSnapshot(JNIEnv* env,
                                                          jclass,
                                                          jbyteArray snapshot) {
   int len = env->GetArrayLength(snapshot);
   unsigned char* copy = new unsigned char[len];
   env->GetByteArrayRegion(snapshot, 0, len, reinterpret_cast<jbyte*>(copy));
-  FletchProgram program = FletchLoadSnapshot(copy, len);
+  DartinoProgram program = DartinoLoadSnapshot(copy, len);
   delete[] copy;
-  FletchRunMain(program);
-  FletchDeleteProgram(program);
+  DartinoRunMain(program);
+  DartinoDeleteProgram(program);
 }
 
-JNIEXPORT void JNICALL Java_fletch_FletchApi_WaitForDebuggerConnection(
+JNIEXPORT void JNICALL Java_dartino_DartinoApi_WaitForDebuggerConnection(
     JNIEnv* env, jclass, int port) {
-  FletchWaitForDebuggerConnection(port);
+  DartinoWaitForDebuggerConnection(port);
 }
 
-JNIEXPORT void JNICALL Java_fletch_FletchApi_AddDefaultSharedLibrary(
+JNIEXPORT void JNICALL Java_dartino_DartinoApi_AddDefaultSharedLibrary(
     JNIEnv* env, jclass, jstring str) {
   const char* library = env->GetStringUTFChars(str, 0);
-  FletchAddDefaultSharedLibrary(library);
+  DartinoAddDefaultSharedLibrary(library);
   env->ReleaseStringUTFChars(str, library);
 }
 
-JNIEXPORT void JNICALL Java_fletch_FletchApi_RegisterPrintInterceptor(
+JNIEXPORT void JNICALL Java_dartino_DartinoApi_RegisterPrintInterceptor(
     JNIEnv* env, jclass, jobject obj) {
   RegisterPrintInterceptor(env, obj);
 }
 
-JNIEXPORT void JNICALL Java_fletch_FletchApi_UnregisterPrintInterceptor(
+JNIEXPORT void JNICALL Java_dartino_DartinoApi_UnregisterPrintInterceptor(
     JNIEnv* env, jclass, jobject obj) {
   UnregisterPrintInterceptor(env, obj);
 }
 
 #ifdef __cplusplus
 }
 #endif
 """;
 
-const FLETCH_SERVICE_API_JAVA_IMPL = """
+const DARTINO_SERVICE_API_JAVA_IMPL = """
 #include <jni.h>
 
 #include "service_api.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-JNIEXPORT void JNICALL Java_fletch_FletchServiceApi_Setup(JNIEnv*, jclass) {
+JNIEXPORT void JNICALL Java_dartino_DartinoServiceApi_Setup(JNIEnv*, jclass) {
   ServiceApiSetup();
 }
 
-JNIEXPORT void JNICALL Java_fletch_FletchServiceApi_TearDown(JNIEnv*, jclass) {
+JNIEXPORT void JNICALL Java_dartino_DartinoServiceApi_TearDown(JNIEnv*, jclass) {
   ServiceApiTearDown();
 }
 
 #ifdef __cplusplus
 }
 #endif
 """;
 
 String JNI_UTILS = """
 static JNIEnv* AttachCurrentThreadAndGetEnv(JavaVM* vm) {
@@ skipping 134 matching lines @@
   "MessageBuilder.java",
   "MessageReader.java",
   "Reader.java",
   "Segment.java"
 ];
 
 void generate(String path,
               Unit unit,
               String resourcesDirectory,
               String outputDirectory) {
-  _generateFletchApis(outputDirectory);
+  _generateDartinoApis(outputDirectory);
   _generateServiceJava(path, unit, outputDirectory);
   _generateServiceJni(path, unit, outputDirectory);
   _generateServiceJniMakeFiles(path, unit, resourcesDirectory, outputDirectory);
 
-  resourcesDirectory = join(resourcesDirectory, 'java', 'fletch');
-  String fletchDirectory = join(outputDirectory, 'java', 'fletch');
+  resourcesDirectory = join(resourcesDirectory, 'java', 'dartino');
+  String dartinoDirectory = join(outputDirectory, 'java', 'dartino');
   for (String resource in JAVA_RESOURCES) {
     String resourcePath = join(resourcesDirectory, resource);
     File file = new File(resourcePath);
     String contents = file.readAsStringSync();
-    writeToFile(fletchDirectory, resource, contents);
+    writeToFile(dartinoDirectory, resource, contents);
   }
 }
 
-void _generateFletchApis(String outputDirectory) {
-  String fletchDirectory = join(outputDirectory, 'java', 'fletch');
+void _generateDartinoApis(String outputDirectory) {
+  String dartinoDirectory = join(outputDirectory, 'java', 'dartino');
   String jniDirectory = join(outputDirectory, 'java', 'jni');
 
   StringBuffer buffer = new StringBuffer(HEADER);
   buffer.writeln();
-  buffer.write(FLETCH_API_JAVA);
-  writeToFile(fletchDirectory, 'FletchApi', buffer.toString(),
+  buffer.write(DARTINO_API_JAVA);
+  writeToFile(dartinoDirectory, 'DartinoApi', buffer.toString(),
       extension: 'java');
 
   buffer = new StringBuffer(HEADER);
   buffer.writeln();
-  buffer.write(FLETCH_SERVICE_API_JAVA);
-  writeToFile(fletchDirectory, 'FletchServiceApi', buffer.toString(),
+  buffer.write(DARTINO_SERVICE_API_JAVA);
+  writeToFile(dartinoDirectory, 'DartinoServiceApi', buffer.toString(),
       extension: 'java');
 
   buffer = new StringBuffer(HEADER);
   buffer.writeln();
-  buffer.write(FLETCH_API_JAVA_IMPL);
-  writeToFile(jniDirectory, 'fletch_api_wrapper', buffer.toString(),
+  buffer.write(DARTINO_API_JAVA_IMPL);
+  writeToFile(jniDirectory, 'dartino_api_wrapper', buffer.toString(),
       extension: 'cc');
 
   buffer = new StringBuffer(HEADER);
   buffer.writeln();
-  buffer.write(FLETCH_SERVICE_API_JAVA_IMPL);
-  writeToFile(jniDirectory, 'fletch_service_api_wrapper',
+  buffer.write(DARTINO_SERVICE_API_JAVA_IMPL);
+  writeToFile(jniDirectory, 'dartino_service_api_wrapper',
       buffer.toString(), extension: 'cc');
 }
 
 void _generateServiceJava(String path, Unit unit, String outputDirectory) {
   _JavaVisitor visitor = new _JavaVisitor(path, outputDirectory);
   visitor.visit(unit);
   String contents = visitor.buffer.toString();
-  String directory = join(outputDirectory, 'java', 'fletch');
+  String directory = join(outputDirectory, 'java', 'dartino');
   // TODO(ager): We should generate a file per service here.
   if (unit.services.length > 1) {
     print('Java plugin: multiple services in one file is not supported.');
   }
   String serviceName = unit.services.first.name;
   writeToFile(directory, serviceName, contents, extension: 'java');
 }
 
 void _generateServiceJni(String path, Unit unit, String outputDirectory) {
   _JniVisitor visitor = new _JniVisitor(path);
@@ skipping 132 matching lines @@
   void writeReturnTypeToBuffer(Type node, StringBuffer buffer) {
     buffer.write(getReturnType(node));
   }
 
   void writeListTypeToBuffer(Type node, StringBuffer buffer) {
     buffer.write(getListType(node));
   }
 
   visitUnit(Unit node) {
     writeln(HEADER);
-    writeln('package fletch;');
+    writeln('package dartino;');
     writeln();
     node.structs.forEach(visit);
     node.services.forEach(visit);
     neededListTypes.forEach(writeListReaderImplementation);
     neededListTypes.forEach(writeListBuilderImplementation);
   }
 
   visitService(Service node) {
     writeln('public class ${node.name} {');
     writeln('  public static native void Setup();');
@@ skipping 40 matching lines @@
     writeType(node.type);
     write(' ${node.name}');
   }
 
   visitStruct(Struct node) {
     writeReader(node);
     writeBuilder(node);
   }
 
   void writeReader(Struct node) {
-    String fletchDirectory = join(outputDirectory, 'java', 'fletch');
+    String dartinoDirectory = join(outputDirectory, 'java', 'dartino');
     String name = node.name;
     StructLayout layout = node.layout;
 
     StringBuffer buffer = new StringBuffer(HEADER);
     buffer.writeln();
     buffer.writeln(READER_HEADER);
 
     buffer.writeln('import java.util.List;');
     buffer.writeln();
 
@@ skipping 81 matching lines @@
           int offset = slot.offset;
           buffer.writeln('    $returnType reader = new $returnType();');
           buffer.writeln('    return ($returnType)readStruct(reader, $offset);');
           buffer.writeln('  }');
         }
       }
     }
 
     buffer.writeln('}');
 
-    writeToFile(fletchDirectory, '$name', buffer.toString(),
+    writeToFile(dartinoDirectory, '$name', buffer.toString(),
         extension: 'java');
   }
 
   void writeBuilder(Struct node) {
-    String fletchDirectory = join(outputDirectory, 'java', 'fletch');
+    String dartinoDirectory = join(outputDirectory, 'java', 'dartino');
     String name = '${node.name}Builder';
     StructLayout layout = node.layout;
 
     StringBuffer buffer = new StringBuffer(HEADER);
     buffer.writeln();
     buffer.writeln(READER_HEADER);
 
     buffer.write('import java.util.List;');
     buffer.writeln();
     buffer.writeln('public class $name extends Builder {');
@@ skipping 87 matching lines @@
           buffer.writeln('    $builderType result = new $builderType();');
           buffer.writeln('    newStruct(result, ${slot.offset}, $size);');
           buffer.writeln('    return result;');
         }
         buffer.writeln('  }');
       }
     }
 
     buffer.writeln('}');
 
-    writeToFile(fletchDirectory, '$name', buffer.toString(),
+    writeToFile(dartinoDirectory, '$name', buffer.toString(),
         extension: 'java');
   }
 
   void writeListReaderImplementation(Type type) {
-    String fletchDirectory = join(outputDirectory, 'java', 'fletch');
+    String dartinoDirectory = join(outputDirectory, 'java', 'dartino');
     String name = '${camelize(type.identifier)}List';
     String listType = getListType(type);
 
     StringBuffer buffer = new StringBuffer(HEADER);
     buffer.writeln();
     buffer.writeln(READER_HEADER);
 
     buffer.writeln('public class $name {');
     if (type.isPrimitive) {
       int elementSize = primitives.size(type.primitiveType);
@@ skipping 25 matching lines @@
                      'result, index, $elementSize);');
       buffer.writeln('    return result;');
       buffer.writeln('  }');
     }
 
     buffer.writeln();
     buffer.writeln('  public int size() { return reader.length; }');
 
     buffer.writeln('}');
 
-    writeToFile(fletchDirectory, '$name', buffer.toString(),
+    writeToFile(dartinoDirectory, '$name', buffer.toString(),
         extension: 'java');
   }
 
   void writeListBuilderImplementation(Type type) {
-    String fletchDirectory = join(outputDirectory, 'java', 'fletch');
+    String dartinoDirectory = join(outputDirectory, 'java', 'dartino');
     String name = '${camelize(type.identifier)}ListBuilder';
 
     StringBuffer buffer = new StringBuffer(HEADER);
     buffer.writeln();
     buffer.writeln(READER_HEADER);
 
     buffer.writeln('public class $name {');
     buffer.writeln('  private ListBuilder builder;');
     buffer.writeln();
     buffer.writeln('  public $name(ListBuilder builder) {'
@@ skipping 29 matching lines @@
                      'result, index, $elementSize);');
       buffer.writeln('    return result;');
       buffer.writeln('  }');
     }
 
     buffer.writeln();
     buffer.writeln('  public int size() { return builder.length; }');
 
     buffer.writeln('}');
 
-    writeToFile(fletchDirectory, '$name', buffer.toString(),
+    writeToFile(dartinoDirectory, '$name', buffer.toString(),
         extension: 'java');
   }
 }
 
 class _JniVisitor extends CcVisitor {
   static const int REQUEST_HEADER_SIZE = 48 + 8;
   static const int RESPONSE_HEADER_SIZE = 8;
 
   int methodId = 1;
   String serviceName;
@@ skipping 25 matching lines @@
     writeln('#ifdef ANDROID');
     writeln('  typedef JNIEnv* AttachEnvType;');
     writeln('#else');
     writeln('  typedef void* AttachEnvType;');
     writeln('#endif');
 
     writeln();
     writeln('static ServiceId service_id_ = kNoServiceId;');
 
     writeln();
-    write('JNIEXPORT void JNICALL Java_fletch_');
+    write('JNIEXPORT void JNICALL Java_dartino_');
     writeln('${serviceName}_Setup(JNIEnv*, jclass) {');
     writeln('  service_id_ = ServiceApiLookup("$serviceName");');
     writeln('}');
 
     writeln();
-    write('JNIEXPORT void JNICALL Java_fletch_');
+    write('JNIEXPORT void JNICALL Java_dartino_');
     writeln('${serviceName}_TearDown(JNIEnv*, jclass) {');
     writeln('  ServiceApiTerminate(service_id_);');
     writeln('}');
 
     // TODO(ager): Put this in resources and copy as a file instead.
     writeln();
     writeln(JNI_UTILS);
 
     node.methods.forEach(visit);
 
     writeln();
     writeln('#ifdef __cplusplus');
     writeln('}');
     writeln('#endif');
   }
 
   visitMethod(Method node) {
     String name = node.name;
     String id = '_k${name}Id';
 
     writeln();
     write('static const MethodId $id = ');
     writeln('reinterpret_cast<MethodId>(${methodId++});');
 
     writeln();
     write('JNIEXPORT ');
     writeReturnType(node.returnType);
-    write(' JNICALL Java_fletch_${serviceName}_${name}(');
+    write(' JNICALL Java_dartino_${serviceName}_${name}(');
     write('JNIEnv* _env, jclass');
     if (node.arguments.isNotEmpty) write(', ');
     if (node.inputKind != InputKind.PRIMITIVES) {
       write('jobject ${node.arguments.single.name}');
     } else {
       visitArguments(node.arguments);
     }
     writeln(') {');
     if (node.inputKind != InputKind.PRIMITIVES) {
       visitStructArgumentMethodBody(id, node);
     } else {
       visitMethodBody(id, node);
     }
     writeln('}');
 
     String callback;
     if (node.inputKind == InputKind.STRUCT) {
       Struct struct = node.arguments.single.type.resolved;
       StructLayout layout = struct.layout;
       callback = ensureCallback(node.returnType, layout);
     } else {
       callback =
           ensureCallback(node.returnType, node.inputPrimitiveStructLayout);
     }
 
     writeln();
     write('JNIEXPORT void JNICALL ');
-    write('Java_fletch_${serviceName}_${name}Async(');
+    write('Java_dartino_${serviceName}_${name}Async(');
     write('JNIEnv* _env, jclass');
     if (node.arguments.isNotEmpty) write(', ');
     if (node.inputKind != InputKind.PRIMITIVES) {
       write('jobject ${node.arguments.single.name}');
     } else {
       visitArguments(node.arguments);
     }
     writeln(', jobject _callback) {');
     writeln('  jobject callback = NULL;');
     writeln('  JavaVM* vm = NULL;');
@@ skipping 66 matching lines @@
       write('  ServiceApiInvokeAsync(service_id_, $id, $callback, ');
       writeln('_buffer, kSize);');
     } else {
       writeln('  ServiceApiInvoke(service_id_, $id, _buffer, kSize);');
       if (method.outputKind == OutputKind.STRUCT) {
         Type type = method.returnType;
         writeln('  int64_t result = *${pointerToArgument(0, 0, 'int64_t')};');
         writeln('  char* memory = reinterpret_cast<char*>(result);');
         writeln('  jobject rootSegment = GetRootSegment(_env, memory);');
         writeln('  jclass resultClass = '
-                '_env->FindClass("fletch/${type.identifier}");');
+                '_env->FindClass("dartino/${type.identifier}");');
         writeln('  jmethodID create = _env->GetStaticMethodID('
                 'resultClass, "create", '
-                '"(Ljava/lang/Object;)Lfletch/${type.identifier};");');
+                '"(Ljava/lang/Object;)Ldartino/${type.identifier};");');
         writeln('  jobject resultObject = _env->CallStaticObjectMethod('
                 'resultClass, create, rootSegment);');
         writeln('  return resultObject;');
       } else if (!method.returnType.isVoid) {
         writeln('  return *${pointerToArgument(0, 0, 'int64_t')};');
       }
     }
   }
 
   visitStructArgumentMethodBody(String id,
@@ skipping 25 matching lines @@
       writeln('buffer, size);');
     } else {
       writeln('  ServiceApiInvoke(service_id_, $id, buffer, size);');
       writeln('  int64_t result = *${pointerToArgument(0, 0, 'int64_t')};');
       writeln('  DeleteMessage(buffer);');
       if (method.outputKind == OutputKind.STRUCT) {
         Type type = method.returnType;
         writeln('  char* memory = reinterpret_cast<char*>(result);');
         writeln('  jobject rootSegment = GetRootSegment(_env, memory);');
         writeln('  jclass resultClass = '
-                '_env->FindClass("fletch/${type.identifier}");');
+                '_env->FindClass("dartino/${type.identifier}");');
         writeln('  jmethodID create = _env->GetStaticMethodID('
                 'resultClass, "create", '
-                '"(Ljava/lang/Object;)Lfletch/${type.identifier};");');
+                '"(Ljava/lang/Object;)Ldartino/${type.identifier};");');
         writeln('  jobject resultObject = _env->CallStaticObjectMethod('
                 'resultClass, create, rootSegment);');
         writeln('  return resultObject;');
       } else {
         if (!method.returnType.isVoid) writeln('  return result;');
       }
     }
   }
 
   static const Map<String, String> PRIMITIVE_TYPES = const {
@@ skipping 39 matching lines @@
     'int32' : 'I',
     'int64' : 'J',
 
     'float32' : 'F',
     'float64' : 'D',
   };
 
   String getJNISignatureType(Type type) {
     String name = type.identifier;
     if (type.isPrimitive) return PRIMITIVE_JNI_SIG[name];
-    return 'Lfletch/$name;';
+    return 'Ldartino/$name;';
   }
 
   final Map<String, String> callbacks = {};
   String ensureCallback(Type type,
                         StructLayout layout,
                         {bool cStyle: false}) {
     String key = '${type.identifier}_${layout.size}';
     return callbacks.putIfAbsent(key, () {
       String cast(String type) => CcVisitor.cast(type, cStyle);
       String pointerToArgument(int offset, String type) {
@@ skipping 16 matching lines @@
         writeln('  DeleteMessage(buffer);');
         if (!type.isPrimitive) {
           writeln('  char* memory = reinterpret_cast<char*>(result);');
           writeln('  jobject rootSegment = GetRootSegment(env, memory);');
           write('  jfieldID returnTypeField = env->GetFieldID(');
           writeln('clazz, "returnType", "Ljava/lang/Class;");');
           write('  jclass resultClass = (jclass)');
           writeln('env->GetObjectField(info->callback, returnTypeField);');
           writeln('  jmethodID create = env->GetStaticMethodID('
                   'resultClass, "create", '
-                  '"(Ljava/lang/Object;)Lfletch/${type.identifier};");');
+                  '"(Ljava/lang/Object;)Ldartino/${type.identifier};");');
           writeln('  jobject resultObject = env->CallStaticObjectMethod('
                   'resultClass, create, rootSegment);');
         }
       } else {
         writeln('  DeleteMessage(buffer);');
       }
       write('  jmethodID methodId = env->GetMethodID');
       write('(clazz, "handle", ');
       if (type.isVoid) {
         writeln('"()V");');
@@ skipping 15 matching lines @@
       return name;
     });
   }
 }
 
 void _generateServiceJniMakeFiles(String path,
                                   Unit unit,
                                   String resourcesDirectory,
                                   String outputDirectory) {
   String out = join(outputDirectory, 'java');
-  // TODO(stanm): pass fletch root directly
-  String fletchRoot = join(resourcesDirectory, '..', '..', '..', '..', '..');
-  String fletchLibraryBuildDir = join(fletchRoot,
+  // TODO(stanm): pass dartino root directly
+  String dartinoRoot = join(resourcesDirectory, '..', '..', '..', '..', '..');
+  String dartinoLibraryBuildDir = join(dartinoRoot,
                                       'tools',
                                       'android_build',
                                       'jni');
 
-  String fletchIncludeDir = join(fletchRoot, 'include');
+  String dartinoIncludeDir = join(dartinoRoot, 'include');
 
-  String modulePath = relative(fletchLibraryBuildDir, from: out);
-  String includePath = relative(fletchIncludeDir, from: out);
+  String modulePath = relative(dartinoLibraryBuildDir, from: out);
+  String includePath = relative(dartinoIncludeDir, from: out);
 
   StringBuffer buffer = new StringBuffer(HEADER_MK);
 
   buffer.writeln();
   buffer.writeln('LOCAL_PATH := \$(call my-dir)');
 
   buffer.writeln();
   buffer.writeln('include \$(CLEAR_VARS)');
-  buffer.writeln('LOCAL_MODULE := fletch');
-  buffer.writeln('LOCAL_CFLAGS := -DFLETCH32');
+  buffer.writeln('LOCAL_MODULE := dartino');
+  buffer.writeln('LOCAL_CFLAGS := -DDARTINO32');
   buffer.writeln('LOCAL_LDLIBS := -llog -ldl -rdynamic');
 
   buffer.writeln();
   buffer.writeln('LOCAL_SRC_FILES := \\');
-  buffer.writeln('\tfletch_api_wrapper.cc \\');
-  buffer.writeln('\tfletch_service_api_wrapper.cc \\');
+  buffer.writeln('\tdartino_api_wrapper.cc \\');
+  buffer.writeln('\tdartino_service_api_wrapper.cc \\');
 
   if (unit.services.length > 1) {
     print('Java plugin: multiple services in one file is not supported.');
   }
   String projectName = basenameWithoutExtension(path);
   String file = '${projectName}_wrapper';
 
   buffer.writeln('\t${file}.cc');
 
   buffer.writeln();
   buffer.writeln('LOCAL_C_INCLUDES += \$(LOCAL_PATH)');
   buffer.writeln('LOCAL_C_INCLUDES += ${includePath}');
-  buffer.writeln('LOCAL_STATIC_LIBRARIES := fletch-library');
+  buffer.writeln('LOCAL_STATIC_LIBRARIES := dartino-library');
 
   buffer.writeln();
   buffer.writeln('include \$(BUILD_SHARED_LIBRARY)');
 
   buffer.writeln();
   buffer.writeln('\$(call import-module, ${modulePath})');
 
   writeToFile(join(out, 'jni'), 'Android', buffer.toString(),
       extension: 'mk');
 
   buffer = new StringBuffer(HEADER_MK);
   buffer.writeln('APP_STL := gnustl_static');
   buffer.writeln('APP_ABI := x86 armeabi-v7a');
   // TODO(zerny): Is this the right place and way to ensure ABI >= 8?
   buffer.writeln('APP_PLATFORM := android-8');
   writeToFile(join(out, 'jni'), 'Application', buffer.toString(),
       extension: 'mk');
 }