001/*******************************************************************************
002 * Copyright (C) 2009-2011 FuseSource Corp.
003 * Copyright (c) 2003, 2006 IBM Corporation and others.
004 *
005 * All rights reserved. This program and the accompanying materials
006 * are made available under the terms of the Eclipse Public License v1.0
007 * which accompanies this distribution, and is available at
008 * http://www.eclipse.org/legal/epl-v10.html
009 *
010 *******************************************************************************/
011package org.fusesource.hawtjni.generator;
012
013import java.io.*;
014import java.util.*;
015
016/**
017 * Produces the java classes mapping to XPCOM Mozilla objects.
018 * 
019 * @author <a href="http://hiramchirino.com">Hiram Chirino</a>
020 */
021public class MozillaGenerator {
022
023    static boolean DEBUG = false;
024
025    FileReader r = null;
026    FileWriter w = null;
027    int maxLines = 1000;
028    int cntLines = 0;
029    int n = 0;
030    String[] b = null;
031    String body = null;
032    int nMethods = 0;
033    String uuidName;
034    String uuidValue;
035    String className;
036    String parentName;
037    String[] constantNames;
038    String[] constantValues;
039    String[] methodNames;
040    String[][] argTypes;
041    String[][] argNames;
042    String bodyOrder;
043    TreeMap<Integer, TreeSet<String>> vtbls = new TreeMap<Integer, TreeSet<String>>();
044
045
046    // Contains the characters found before a method name
047    // Useful to extract the method name. e.g.
048    // NS_IMETHOD QueryInterface(const nsIID & uuid, void * *result) = 0;
049    // NS_IMETHOD_(nsrefcnt) AddRef(void) = 0;
050    // method name follows: QueryInterface, AddRef etc.
051    static String[] BEFORE_METHOD_NAME = { "  NS_IMETHOD ", "  NS_IMETHOD_(nsrefcnt) ", "  NS_IMETHOD_(void *) ", "  NS_IMETHOD_(void) ", "  NS_IMETHOD_(nsresult) ",
052            "  NS_SCRIPTABLE NS_IMETHOD ", "  NS_SCRIPTABLE NS_IMETHOD_(nsrefcnt) ", "  NS_SCRIPTABLE NS_IMETHOD_(void *) ", "  NS_SCRIPTABLE NS_IMETHOD_(void) ",
053            "  NS_SCRIPTABLE NS_IMETHOD_(nsresult) ", };
054
055    static String NO_SUPER_CLASS = "SWT_NO_SUPER_CLASS";
056
057    static String[][] TYPES_C2JAVA = { { "PRBool *", "int[]" },
058            { "nsIID &", "nsID" },
059            { "nsCID &", "nsID" },
060            { "nsCID * *", "int /*long*/" }, // nsID[] not supported by jnigen
061            { "* *", "int /*long*/[]" }, { "**", "int /*long*/[]" }, { "* &", "int /*long*/[]" }, { "PRUint32 *", "int[]" }, { "PRInt32 *", "int[]" }, { "PRInt64 *", "long[]" },
062            { "PRUnichar *", "char[]" }, { "char *", "byte[]" }, { "float *", "float[]" }, { "PRUint16 *", "short[]" }, { "nativeWindow *", "int /*long*/[]" },
063            { "nsWriteSegmentFun", "int /*long*/" }, { "nativeWindow", "int /*long*/" },
064
065            { "*", "int /*long*/" }, // c type containing one or more * (and any
066                                     // other character, and did not match
067                                     // previous patterns) is a simple pointer
068            { "&", "int /*long*/" },
069
070            { "PRUint32", "int" }, { "PRInt32", "int" }, { "PRInt64", "long" }, { "nsresult", "int" }, { "PRBool", "int" }, { "float", "float" }, { "PRUint16", "short" },
071            { "size_t", "int" }, };
072
073    static String GECKO = "/bluebird/teamhawtjni/hawtjni-builddir/mozilla/1.4/linux_gtk2/mozilla/dist/include/";
074
075    static String TARGET_FOLDER = "/bluebird/teamhawtjni/chrisx/amd64/workspace/org.eclipse.hawtjni/Eclipse SWT Mozilla/common/org/eclipse/hawtjni/internal/mozilla/";
076
077    static String[] XPCOM_HEADERS = { "profile/nsIProfile.h", "widget/nsIAppShell.h", "widget/nsIBaseWindow.h", "xpcom/nsIComponentManager.h", "xpcom/nsIComponentRegistrar.h",
078            "webbrwsr/nsIContextMenuListener.h", "docshell/nsIDocShell.h", "dom/nsIDOMEvent.h", "dom/nsIDOMMouseEvent.h", "dom/nsIDOMUIEvent.h", "dom/nsIDOMWindow.h",
079            "uriloader/nsIDownload.h",
080            "webbrwsr/nsIEmbeddingSiteWindow.h",
081            "xpcom/nsIFactory.h",
082            "xpcom/nsIFile.h",
083            "helperAppDlg/nsIHelperAppLauncherDialog.h",
084            "exthandler/nsIExternalHelperAppService.h", // contains
085                                                        // nsIHelperAppLauncher
086            "xpcom/nsIInputStream.h", "xpcom/nsIInterfaceRequestor.h", "necko/nsIIOService.h", "xpcom/nsILocalFile.h", "xpcom/nsIMemory.h", "progressDlg/nsIProgressDialog.h",
087            "windowwatcher/nsIPromptService.h", "xpcom/nsIServiceManager.h", "xpcom/nsISupports.h", "webbrwsr/nsITooltipListener.h", "necko/nsIURI.h",
088            "uriloader/nsIURIContentListener.h", "xpcom/nsIWeakReference.h", "webbrwsr/nsIWebBrowser.h", "webbrwsr/nsIWebBrowserChrome.h", "webbrwsr/nsIWebBrowserChromeFocus.h",
089            "webbrwsr/nsIWebBrowserFocus.h", "docshell/nsIWebNavigation.h", "uriloader/nsIWebProgress.h", "uriloader/nsIWebProgressListener.h", "embed_base/nsIWindowCreator.h",
090            "windowwatcher/nsIWindowWatcher.h" };
091
092    public static void main(String[] args) {
093        MozillaGenerator x = new MozillaGenerator();
094        for (int i = 0; i < XPCOM_HEADERS.length; i++)
095            x.parse(GECKO + XPCOM_HEADERS[i], TARGET_FOLDER);
096        x.outputVtblCall();
097        System.out.println("done");
098    }
099
100
101    /** Write callbacks */
102    public void write(String data) {
103        if (DEBUG) {
104            System.out.print(data);
105            return;
106        }
107        try {
108            w.write(data);
109        } catch (IOException e) {
110            e.printStackTrace();
111        }
112    }
113
114    public void writeLine() {
115        if (DEBUG) {
116            System.out.println();
117            return;
118        }
119        write("\r\n");
120    }
121
122    public void writeLine(String data) {
123        if (DEBUG) {
124            System.out.println(data);
125            return;
126        }
127        write(data + "\r\n");
128    }
129
130    public void writeCopyrights() {
131        writeLine(COPYRIGHTS);
132    }
133
134    public void writePackageDeclaration() {
135        writeLine(PACKAGE_DECLARATION);
136    }
137
138    public void writeClassDeclaration(String className, String parentName) {
139        String line = "public class " + className;
140        if (!parentName.equals(NO_SUPER_CLASS))
141            line += " extends " + parentName;
142        line += " {";
143        writeLine(line);
144    }
145
146    public void writeLastMethodId(String parentName, int nMethods) {
147        String line = "\tstatic final int LAST_METHOD_ID = ";
148        if (!parentName.equals(NO_SUPER_CLASS))
149            line += parentName + ".LAST_METHOD_ID + " + nMethods + ";";
150        else
151            line += "" + (nMethods - 1) + ";"; // zero indexed
152        writeLine(line);
153    }
154
155    public void writeIID(String uuidName, String uuidValue) {
156        writeLine("\tpublic static final String " + uuidName + " =");
157        writeLine("\t\t\"" + uuidValue + "\";");
158        writeLine();
159        String iid = uuidName.substring(0, uuidName.indexOf("_STR"));
160        writeLine("\tpublic static final nsID " + iid + " =");
161        writeLine("\t\tnew nsID(" + uuidName + ");");
162    }
163
164    public void writeAddressField() {
165        writeLine("\tint /*long*/ address;");
166    }
167
168    public void writeConstructor(String className, String parentName) {
169        writeLine("\tpublic " + className + "(int /*long*/ address) {");
170        if (!parentName.equals(NO_SUPER_CLASS)) {
171            writeLine("\t\tsuper(address);");
172        } else {
173            writeLine("\t\tthis.address = address;");
174        }
175        writeLine("\t}");
176    }
177
178    public void writeAddressGetter() {
179        writeLine("\tpublic int /*long*/ getAddress() {");
180        writeLine("\t\treturn this.address;");
181        writeLine("\t}");
182    }
183
184    public void writeConstant(String name, String value) {
185        writeLine("\tpublic static final int " + name + " = " + value + ";");
186    }
187
188    public void writeMethod(String name, String parentName, int methodIndex, String[] argTypes, String[] argNames) {
189        write("\tpublic int " + name + "(");
190        for (int i = 0; i < argTypes.length; i++) {
191            write(argTypes[i] + " " + argNames[i]);
192            if (i < argTypes.length - 1)
193                write(", ");
194        }
195        write(") {");
196        writeLine();
197        String line = "\t\treturn XPCOM.VtblCall(";
198        if (!parentName.equals(NO_SUPER_CLASS))
199            line += parentName + ".LAST_METHOD_ID + " + (methodIndex + 1) + ", getAddress()";
200        else
201            line += methodIndex + ", getAddress()"; // zero indexed
202        write(line);
203        if (argTypes.length > 0)
204            write(", ");
205        for (int i = 0; i < argTypes.length; i++) {
206            write(argNames[i]);
207            if (i < argTypes.length - 1)
208                write(", ");
209        }
210        writeLine(");");
211        writeLine("\t}");
212    }
213
214    public void writeClassEnd() {
215        write("}");
216    }
217
218    public void logVtblCall(String[] argTypes) {
219        String vtbl = "static final native int VtblCall(int fnNumber, int /*long*/ ppVtbl";
220        if (argTypes.length > 0)
221            vtbl += ", ";
222        for (int i = 0; i < argTypes.length; i++) {
223            vtbl += argTypes[i] + " arg" + i;
224            if (i < argTypes.length - 1)
225                vtbl += ", ";
226        }
227        vtbl += ");";
228        Integer key = new Integer(argTypes.length);
229        TreeSet<String> list = vtbls.get(key);
230        if (list == null) {
231            list = new TreeSet<String>();
232            vtbls.put(key, list);
233        }
234        boolean duplicate = false;
235        
236        for (String s : list) {
237            if (vtbl.equals(s)) {
238                duplicate = true;
239                break;
240            }
241        }
242        if (!duplicate)
243            list.add(vtbl);
244    }
245
246    public void outputVtblCall() {
247        Collection<TreeSet<String>> values = vtbls.values();
248        for (TreeSet<String> elts : values) {
249            for (String elt : elts) {
250                System.out.println(elt);
251            }
252        }
253    }
254
255    /** Parsing invoking write callbacks */
256
257    /*
258     * Convert a C header file into a Java source file matching SWT Mozilla
259     * binding.
260     */
261    public void parse(String src, String destPath) {
262        if (DEBUG)
263            writeLine("*** PARSING <" + src + "> to folder " + destPath);
264        b = new String[maxLines];
265        cntLines = 0;
266        try {
267            r = new FileReader(src);
268            BufferedReader br = new BufferedReader(r);
269            while ((b[cntLines] = br.readLine()) != null) {
270                cntLines++;
271            }
272            br.close();
273        } catch (IOException e) {
274            e.printStackTrace();
275            return;
276        }
277        n = 0;
278        boolean lookForClasses = true;
279        while (lookForClasses) {
280            /* parsing */
281            lookForClasses = parse();
282
283            String destFile = destPath + className + ".java";
284            try {
285                w = new FileWriter(destFile);
286                if (DEBUG)
287                    writeLine("** CREATED JAVA FILE <" + destFile + ">");
288            } catch (IOException e) {
289                e.printStackTrace();
290                return;
291            }
292
293            /* writing */
294            writeCopyrights();
295            writePackageDeclaration();
296            writeLine();
297            writeClassDeclaration(className, parentName);
298            writeLine();
299            writeLastMethodId(parentName, nMethods);
300            writeLine();
301            writeIID(uuidName, uuidValue);
302            writeLine();
303            if (parentName.equals(NO_SUPER_CLASS)) {
304                writeAddressField();
305                writeLine();
306            }
307            writeConstructor(className, parentName);
308            writeLine();
309
310            if (parentName.equals(NO_SUPER_CLASS)) {
311                writeAddressGetter();
312                writeLine();
313            }
314
315            int constantIndex = 0, methodIndex = 0;
316            for (int i = 0; i < bodyOrder.length(); i++) {
317                if (bodyOrder.charAt(i) == 'C') {
318                    writeConstant(constantNames[constantIndex], constantValues[constantIndex]);
319                    if (i < bodyOrder.length() - 1)
320                        writeLine();
321                    constantIndex++;
322                } else if (bodyOrder.charAt(i) == 'M') {
323                    writeMethod(methodNames[methodIndex], parentName, methodIndex, argTypes[methodIndex], argNames[methodIndex]);
324                    if (i < bodyOrder.length() - 1)
325                        writeLine();
326                    methodIndex++;
327                }
328            }
329
330            writeClassEnd();
331
332            try {
333                w.close();
334            } catch (IOException e) {
335                e.printStackTrace();
336            }
337        }
338    }
339
340    public String getPackages() {
341        return "package org.eclipse.hawtjni.internal.mozilla;";
342    }
343
344    public boolean parse() {
345        if (!jumpToUuidDeclaration())
346            return false;
347        uuidName = getUuidName(b[n]);
348        if (DEBUG)
349            System.out.println("UUID name: <" + uuidName + ">");
350        uuidValue = getUuidValue(b[n]);
351        if (DEBUG)
352            System.out.println("UUID value: <" + uuidValue + ">");
353        jumpToInterfaceDeclaration();
354        className = getClassName(b[n]);
355        if (DEBUG)
356            System.out.println("Interface name: <" + className + ">");
357        parentName = getParentName(b[n]);
358        if (DEBUG)
359            System.out.println("parentName: <" + parentName + ">");
360        parseBody();
361        return true;
362    }
363
364    boolean jumpToUuidDeclaration() {
365        // jump to line matching:
366        // "#define NS_IWEBBROWSERCHROME_IID_STR "ba434c60-9d52-11d3-afb0-00a024ffc08c""
367        while (!(b[n].startsWith("#define ") && b[n].indexOf("_IID_STR \"") != -1)) {
368            n++;
369            if (n >= cntLines)
370                return false;
371        }
372        return true;
373    }
374
375    // assume a declaration matching:
376    // "#define NS_IWEBBROWSERCHROME_IID_STR "ba434c60-9d52-11d3-afb0-00a024ffc08c""
377    // returns NS_IWEBBROWSERCHROME_IID_STR
378    String getUuidName(String declaration) {
379        return declaration.substring(declaration.indexOf("#define ") + "#define ".length(), declaration.indexOf(" \""));
380    }
381
382    // assume a declaration matching:
383    // "#define NS_IWEBBROWSERCHROME_IID_STR "ba434c60-9d52-11d3-afb0-00a024ffc08c""
384    // returns ba434c60-9d52-11d3-afb0-00a024ffc08c
385    String getUuidValue(String declaration) {
386        return declaration.substring(declaration.indexOf("_IID_STR \"") + "_IID_STR \"".length(), declaration.lastIndexOf('"'));
387    }
388
389    void jumpToInterfaceDeclaration() {
390        // jump to line matching:
391        // "class NS_NO_VTABLE nsIWebBrowserChrome : public nsISupports {"
392        while (!(b[n].startsWith("class NS_NO_VTABLE "))) {
393            n++;
394        }
395    }
396
397    // Assume a declaration matching:
398    // "class NS_NO_VTABLE nsIWebBrowserChrome : public nsISupports {"
399    // or
400    // "class NS_NO_VTABLE NS_SCRIPTABLE nsIWebBrowserChrome : public nsISupports {"
401    // returns nsIWebBrowserChrome.
402    // Special case for nsISupports that has no super class: class NS_NO_VTABLE
403    // nsISupports {
404    String getClassName(String declaration) {
405        int endIndex = declaration.indexOf(" :");
406        // nsISupports special case (no super class)
407        if (endIndex == -1)
408            endIndex = declaration.indexOf(" {");
409        String searchString = "class NS_NO_VTABLE NS_SCRIPTABLE";
410        int startIndex = declaration.indexOf(searchString);
411        if (startIndex == -1) {
412            searchString = "class NS_NO_VTABLE ";
413            startIndex = declaration.indexOf(searchString);
414        }
415        return declaration.substring(startIndex + searchString.length(), endIndex);
416    }
417
418    // assume a declaration matching:
419    // "class NS_NO_VTABLE nsIWebBrowserChrome : public nsISupports {"
420    // returns nsISupports
421    // special case for nsISupports that has no super class: class NS_NO_VTABLE
422    // nsISupports {
423    String getParentName(String declaration) {
424        if (declaration.indexOf(" :") == -1)
425            return NO_SUPER_CLASS;
426        return declaration.substring(declaration.indexOf(": public ") + ": public ".length(), declaration.indexOf(" {"));
427    }
428
429    // parse methods and constants declarations starting at the current index
430    // out:
431    // .String body - contains the corresponding java content
432    // .n - set to the end of the interface body declaration ( line with the
433    // enclosing "};" )
434    // .nMethods - set to the number of methods parsed
435    void parseBody() {
436        body = "";
437        bodyOrder = "";
438        int nConstants = 0;
439        nMethods = 0;
440
441        int tmp_n = n;
442        while (true) {
443            int type = jumpToNextConstantOrMethod();
444            if (type == CONSTANT)
445                nConstants++;
446            if (type == METHOD)
447                nMethods++;
448            if (type == END_BODY)
449                break;
450            n++;
451        }
452        n = tmp_n;
453        constantNames = new String[nConstants];
454        constantValues = new String[nConstants];
455        methodNames = new String[nMethods];
456        argTypes = new String[nMethods][];
457        argNames = new String[nMethods][];
458        int constantIndex = 0, methodIndex = 0;
459        while (true) {
460            int type = jumpToNextConstantOrMethod();
461            if (type == CONSTANT) {
462                parseConstant(b[n], constantIndex);
463                bodyOrder += "C";
464                constantIndex++;
465            }
466            if (type == METHOD) {
467                parseMethod(b[n], methodIndex);
468                logVtblCall(argTypes[methodIndex]);
469                bodyOrder += "M";
470                methodIndex++;
471            }
472            if (type == END_BODY)
473                return;
474            n++;
475        }
476    }
477
478    static int CONSTANT = 0;
479
480    static int METHOD = 1;
481
482    static int END_BODY = 2;
483
484    boolean isEndOfInterfaceBody() {
485        return b[n].startsWith("};");
486    }
487
488    int jumpToNextConstantOrMethod() {
489        while (!isEndOfInterfaceBody()) {
490            if (b[n].startsWith("  enum { ")) {
491                return CONSTANT;
492            }
493            if (methodNameStartIndexOf(b[n]) != -1) {
494                return METHOD;
495            }
496            n++;
497        }
498        return END_BODY;
499    }
500
501    void parseConstant(String constant, int constantIndex) {
502        String constantName = constant.substring(constant.indexOf(" enum { ") + " enum { ".length(), constant.indexOf(" ="));
503        if (DEBUG)
504            writeLine("constantName <" + constantName + ">");
505        constantNames[constantIndex] = constantName;
506
507        // most constants values have a trailing U
508        // enum { APP_TYPE_UNKNOWN = 0U };
509        int endIndex = constant.indexOf("U };");
510        // a few others don't
511        // enum { ENUMERATE_FORWARDS = 0 };
512        if (endIndex == -1)
513            endIndex = constant.indexOf(" };");
514        String constantValue = constant.substring(constant.indexOf(" = ") + " = ".length(), endIndex);
515        if (DEBUG)
516            writeLine("constantValue <" + constantValue + ">");
517        constantValues[constantIndex] = constantValue;
518    }
519
520    // NS_IMETHOD SetStatus(PRUint32 statusType, const PRUnichar *status) = 0;
521    // identify:
522    // method name: <SetStatus>
523    // Nbr of arguments: 2
524    // Type of argument 0: PRUint32
525    // Name of argument 0: statusType
526    // Type of argument 1: const PRUnichar *
527    // Name of argument 1: status
528    void parseMethod(String line, int methodIndex) {
529        int start = methodNameStartIndexOf(line);
530        int end = methodNameEndIndexOf(line);
531        String methodName = line.substring(start, end);
532        if (DEBUG)
533            writeLine("method name: <" + methodName + ">");
534        methodNames[methodIndex] = methodName;
535        int argStart = end + "(".length();
536        int argEnd = line.indexOf(")", argStart);
537        parseArgs(line.substring(argStart, argEnd), methodIndex);
538    }
539
540    // Given a line, returns the start of the method name or -1
541    // if the line does not contain a method declaration.
542    int methodNameStartIndexOf(String line) {
543        for (int i = 0; i < BEFORE_METHOD_NAME.length; i++) {
544            int index = line.indexOf(BEFORE_METHOD_NAME[i]);
545            if (index != -1)
546                return index + BEFORE_METHOD_NAME[i].length();
547        }
548        return -1;
549    }
550
551    int methodNameEndIndexOf(String line) {
552        int startIndex = methodNameStartIndexOf(line);
553        return line.indexOf("(", startIndex);
554    }
555
556    void parseArgs(String args, int methodIndex) {
557        int nArgs = -1;
558        // methods with no args look like: () or (void)
559        String[] noArgs = new String[] { "", "void" };
560        for (int i = 0; i < noArgs.length; i++) {
561            if (args.equals(noArgs[i])) {
562                nArgs = 0;
563                break;
564            }
565        }
566        if (nArgs == -1)
567            nArgs = count(args, ", ") + 1;
568        String[] argTypes = new String[nArgs];
569        this.argTypes[methodIndex] = argTypes;
570        String[] argNames = new String[nArgs];
571        this.argNames[methodIndex] = argNames;
572        int typeStart = 0;
573
574        // name is separated from its type by either of the following (sorted by
575        // decreasing size to find the most complete pattern */
576        String[] typeNameSep = new String[] { " * *", " **", " * & ", " * ", " *", " & ", " " };
577        for (int i = 0; i < nArgs; i++) {
578            /* get the type */
579            int nextTypeStart = i < nArgs - 1 ? args.indexOf(", ", typeStart) + ", ".length() : args.length();
580            int typeNameSepIndex = 0;
581            int separatorIndex = 0;
582            for (; typeNameSepIndex < typeNameSep.length; typeNameSepIndex++) {
583                separatorIndex = args.indexOf(typeNameSep[typeNameSepIndex], typeStart);
584                if (separatorIndex != -1 && separatorIndex < nextTypeStart)
585                    break;
586            }
587            String separator = typeNameSep[typeNameSepIndex];
588            argTypes[i] = getC2JavaType(args.substring(typeStart, separatorIndex + separator.length()));
589            if (DEBUG)
590                writeLine("arg type" + i + ": <" + argTypes[i] + ">");
591            /* get the name */
592            int nameStart = separatorIndex + separator.length();
593            int nameEnd = i < nArgs - 1 ? args.indexOf(", ", nameStart) : args.length();
594            argNames[i] = args.substring(nameStart, nameEnd);
595            if (DEBUG)
596                writeLine("arg name" + i + ": <" + argNames[i] + ">");
597
598            typeStart = nextTypeStart;
599        }
600    }
601
602    String getC2JavaType(String cType) {
603        for (int i = 0; i < TYPES_C2JAVA.length; i++) {
604            if (cType.indexOf(TYPES_C2JAVA[i][0]) != -1)
605                return TYPES_C2JAVA[i][1];
606        }
607        return "!ERROR UNKNOWN C TYPE <" + cType + ">!";
608    }
609
610    // how many times part can be found in s
611    static int count(String s, String part) {
612        int index = -1, cnt = 0;
613        while ((index = s.indexOf(part, index + 1)) != -1)
614            cnt++;
615        return cnt;
616    }
617
618    static String COPYRIGHTS = "/* ***** BEGIN LICENSE BLOCK *****\r\n" + " * Version: MPL 1.1\r\n" + " *\r\n"
619            + " * The contents of this file are subject to the Mozilla Public License Version\r\n"
620            + " * 1.1 (the \"License\"); you may not use this file except in compliance with\r\n" + " * the License. You may obtain a copy of the License at\r\n"
621            + " * http://www.mozilla.org/MPL/\r\n" + " *\r\n" + " * Software distributed under the License is distributed on an \"AS IS\" basis,\r\n"
622            + " * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License\r\n" + " * for the specific language governing rights and limitations under the\r\n"
623            + " * License.\r\n" + " *\r\n" + " * The Original Code is Mozilla Communicator client code, released March 31, 1998.\r\n" + " *\r\n"
624            + " * The Initial Developer of the Original Code is\r\n" + " * Netscape Communications Corporation.\r\n"
625            + " * Portions created by Netscape are Copyright (C) 1998-1999\r\n" + " * Netscape Communications Corporation.  All Rights Reserved.\r\n" + " *\r\n"
626            + " * Contributor(s):\r\n" + " *\r\n" + " * IBM\r\n" + " * -  Binding to permit interfacing between Mozilla and SWT\r\n"
627            + " * -  Copyright (C) 2003, 2009 IBM Corp.  All Rights Reserved.\r\n" + " *\r\n" + " * ***** END LICENSE BLOCK ***** */";
628
629    static String PACKAGE_DECLARATION = "package org.eclipse.hawtjni.internal.mozilla;";
630
631}