diff options
Diffstat (limited to 'features/org.eclipse.equinox.executable.feature/library/carbon')
9 files changed, 1615 insertions, 0 deletions
diff --git a/features/org.eclipse.equinox.executable.feature/library/carbon/.cvsignore b/features/org.eclipse.equinox.executable.feature/library/carbon/.cvsignore new file mode 100644 index 000000000..f0fdae47c --- /dev/null +++ b/features/org.eclipse.equinox.executable.feature/library/carbon/.cvsignore @@ -0,0 +1,3 @@ +*.o +eclipse +*.so diff --git a/features/org.eclipse.equinox.executable.feature/library/carbon/build.sh b/features/org.eclipse.equinox.executable.feature/library/carbon/build.sh new file mode 100644 index 000000000..ac923d2ff --- /dev/null +++ b/features/org.eclipse.equinox.executable.feature/library/carbon/build.sh @@ -0,0 +1,100 @@ +#!/bin/sh +#******************************************************************************* +# Copyright (c) 2000, 2009 IBM Corporation and others. +# All rights reserved. This program and the accompanying materials +# are made available under the terms of the Eclipse Public License v1.0 +# which accompanies this distribution, and is available at +# http://www.eclipse.org/legal/epl-v10.html +# +# Contributors: +# IBM Corporation - initial API and implementation +# Kevin Cornell (Rational Software Corporation) +#******************************************************************************* +# +# Usage: sh build.sh [<optional switches>] [clean] +# +# where the optional switches are: +# -output <PROGRAM_OUTPUT> - executable filename ("eclipse") +# -os <DEFAULT_OS> - default Eclipse "-os" value +# -arch <DEFAULT_OS_ARCH> - default Eclipse "-arch" value +# -ws <DEFAULT_WS> - default Eclipse "-ws" value +# +# +# This script can also be invoked with the "clean" argument. + +cd `dirname $0` + +# Define default values for environment variables used in the makefiles. +programOutput="eclipse" +defaultOS="macosx" +defaultOSArch="x86" +defaultWS="carbon" +makefile="make_carbon.mak" +if [ "$OS" = "" ]; then + OS=`uname -s` +fi + +# Parse the command line arguments and override the default values. +extraArgs="" +while [ "$1" != "" ]; do + if [ "$1" = "-os" ] && [ "$2" != "" ]; then + defaultOS="$2" + shift + elif [ "$1" = "-arch" ] && [ "$2" != "" ]; then + defaultOSArch="$2" + shift + elif [ "$1" = "-ws" ] && [ "$2" != "" ]; then + defaultWS="$2" + shift + elif [ "$1" = "-output" ] && [ "$2" != "" ]; then + programOutput="$2" + shift + else + extraArgs="$extraArgs $1" + fi + shift +done + +# Set up environment variables needed by the makefiles. +PROGRAM_OUTPUT="$programOutput" +DEFAULT_OS="$defaultOS" +DEFAULT_OS_ARCH="$defaultOSArch" +DEFAULT_WS="$defaultWS" +EXEC_DIR=../../../../../rt.equinox.binaries/org.eclipse.equinox.executable +PPC_OUTPUT_DIR="$EXEC_DIR/bin/$defaultWS/$defaultOS/ppc/Eclipse.app/Contents/MacOS" +X86_OUTPUT_DIR="$EXEC_DIR/bin/$defaultWS/$defaultOS/x86/Eclipse.app/Contents/MacOS" +X86_64_OUTPUT_DIR="$EXEC_DIR/bin/$defaultWS/$defaultOS/x86_64/Eclipse.app/Contents/MacOS" + +if [ "$DEFAULT_WS" == "cocoa" ]; then + makefile="make_cocoa.mak" + export MACOSX_DEPLOYMENT_TARGET=10.5 +else + export MACOSX_DEPLOYMENT_TARGET=10.3 +fi + +if [ "$DEFAULT_OS_ARCH" == "x86_64" ]; then + echo "build x86_64" + ARCHS="-arch x86_64" + PROGRAM_OUTPUT_DIR=$X86_64_OUTPUT_DIR + DEFAULT_OS_ARCH="x86_64" +else + echo "build x86 and ppc" + ARCHS="-arch i386 -arch ppc" + PROGRAM_OUTPUT_DIR=$X86_OUTPUT_DIR +fi + +export PPC_OUTPUT_DIR X86_OUTPUT_DIR X86_64_OUTPUT_DIR PROGRAM_OUTPUT DEFAULT_OS DEFAULT_OS_ARCH DEFAULT_WS ARCHS PROGRAM_OUTPUT_DIR + +# If the OS is supported (a makefile exists) +if [ "$makefile" != "" ]; then + if [ "$extraArgs" != "" ]; then + make -f $makefile $extraArgs + else + echo "Building $OS launcher. Defaults: -os $DEFAULT_OS -arch $DEFAULT_OS_ARCH -ws $DEFAULT_WS" + make -f $makefile clean + make -f $makefile all + make -f $makefile install + fi +else + echo "Unknown OS ($OS) -- build aborted" +fi diff --git a/features/org.eclipse.equinox.executable.feature/library/carbon/build.xml b/features/org.eclipse.equinox.executable.feature/library/carbon/build.xml new file mode 100644 index 000000000..990298e64 --- /dev/null +++ b/features/org.eclipse.equinox.executable.feature/library/carbon/build.xml @@ -0,0 +1,20 @@ +<?xml version="1.0" encoding="UTF-8"?> + +<project default="build_eclipse" basedir="."> + +<target name="build_eclipse"> + <exec dir="." executable="sh"> + <arg line="${basedir}/build.sh"/> + <arg line="install"/> + </exec> +</target> + +<target name="clean"> + <tstamp/> + <exec dir="." executable="sh"> + <arg line="${basedir}/build.sh"/> + <arg line="clean"/> + </exec> +</target> + +</project>
\ No newline at end of file diff --git a/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseCarbon.c b/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseCarbon.c new file mode 100644 index 000000000..29348fc56 --- /dev/null +++ b/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseCarbon.c @@ -0,0 +1,855 @@ +/* + * Copyright (c) 2000, 2010 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + * Andre Weinand (OTI Labs) + * David Green - OpenJDK bsd port integration + */ + +/* MacOS X Carbon specific logic for displaying the splash screen. */ + +#include "eclipseOS.h" +#include "eclipseCommon.h" +#include "eclipseJNI.h" +#include "eclipseUtil.h" + +#include <unistd.h> +#include <sys/stat.h> +#include <CoreServices/CoreServices.h> +#ifdef COCOA +#include <Cocoa/Cocoa.h> +#else +#include <Carbon/Carbon.h> +#include "NgCommon.h" +#include "NgImageData.h" +#include "NgWinBMPFileFormat.h" +#endif +#include <mach-o/dyld.h> +#include <pthread.h> + +#define startupJarName "startup.jar" +#define LAUNCHER "-launcher" +#define SPLASH_LAUNCHER "/Resources/Splash.app/Contents/" + +#define DEBUG 0 + +static _TCHAR* noForkingMsg = _T_ECLIPSE("Internal Error, forking the jvm is not supported on MacOS.\n"); + +char *findCommand(char *command); + +/* Global Variables */ +char* defaultVM = "java"; +char* vmLibrary = "JavaVM"; +char* shippedVMDir = "../../../jre/Contents/Home/jre/bin/"; +int isSUN = 0; + +static void adjustLibraryPath(char * vmLibrary); +static char * findLib(char * command); + +#ifdef i386 +#define JAVA_ARCH "i386" +#define JAVA_HOME_ARCH "i386" +#elif defined(__ppc__) || defined(__powerpc64__) +#define JAVA_ARCH "ppc" +#define JAVA_HOME_ARCH "ppc" +#elif defined(__amd64__) || defined(__x86_64__) +#define JAVA_ARCH "amd64" +#define JAVA_HOME_ARCH "x86_64" +#else +#define JAVA_ARCH DEFAULT_OS_ARCH +#define JAVA_HOME_ARCH DEFAULT_OS_ARCH +#endif + +#define LIB_PATH_VAR _T_ECLIPSE("LD_LIBRARY_PATH") +#define DYLD_FALLBACK_VAR _T_ECLIPSE("DYLD_FALLBACK_LIBRARY_PATH") + +#define MAX_LOCATION_LENGTH 40 /* none of the jvmLocations strings should be longer than this */ +#define MAX_JVMLIB_LENGTH 15 /* none of the jvmLibs strings should be longer than this */ +static const char* jvmLocations[] = { "../lib/" JAVA_ARCH "/client", + "../lib/" JAVA_ARCH "/server", + "../jre/lib/" JAVA_ARCH "/client", + "../jre/lib/" JAVA_ARCH "/server", + "../jre/lib/client", + "../jre/lib/server", NULL }; +static const char* jvmLibs[] = { "libjvm.dylib", "libjvm.jnilib", "libjvm.so", NULL }; + +/* Define the window system arguments for the various Java VMs. */ +static char* argVM_JAVA[] = { "-XstartOnFirstThread", NULL }; + +/* thread stuff */ +typedef struct { + _TCHAR * libPath; + _TCHAR ** vmArgs; + _TCHAR ** progArgs; + _TCHAR * jarFile; + JavaResults* result; +} StartVMArgs; + +#ifdef COCOA +static NSWindow* window = nil; +@interface KeyWindow : NSWindow { } +- (BOOL)canBecomeKeyWindow; +@end + +@implementation KeyWindow +- (BOOL)canBecomeKeyWindow { + return YES; +} + +- (void)close { + [super close]; + window = nil; +} + +@end + +@interface AppleEventDelegate : NSObject +- (void)handleOpenDocuments:(NSAppleEventDescriptor *)event withReplyEvent: (NSAppleEventDescriptor *)replyEvent; +@end +@implementation AppleEventDelegate + NSTimer *timer; + NSMutableArray *files; + +- (void)handleOpenDocuments:(NSAppleEventDescriptor *)event withReplyEvent: (NSAppleEventDescriptor *)replyEvent { + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + int count = [event numberOfItems]; + int index = 1; + + if (!files) { + files = [NSMutableArray arrayWithCapacity:count]; + [files retain]; + } + + for (index = 1; index<=count; index++) { + CFURLRef url = NULL; + NSAppleEventDescriptor *desc = [event descriptorAtIndex:index], *coerceDesc; + if (!desc) continue; + if ((coerceDesc = [desc coerceToDescriptorType: typeFSRef]) != NULL) { + url = CFURLCreateFromFSRef(kCFAllocatorDefault, [[coerceDesc data] bytes]); + } else if ((coerceDesc = [desc coerceToDescriptorType: typeFileURL]) != NULL) { + NSData *data = [coerceDesc data]; + url = CFURLCreateWithBytes(kCFAllocatorDefault, [data bytes], [data length], kCFStringEncodingUTF8, NULL); + } + if (url) { + NSString *pathName = (NSString *)CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle); + [files addObject:pathName]; + [pathName release]; + CFRelease(url); + } + } + + if (!timer) { + timer = [NSTimer scheduledTimerWithTimeInterval: 1.0 + target: self + selector: @selector(handleTimer:) + userInfo: nil + repeats: YES]; + } + [pool release]; +} +- (void) handleTimer: (NSTimer *) timer { + NSObject *delegate = [[NSApplication sharedApplication] delegate]; + if (delegate != NULL && [delegate respondsToSelector: @selector(application:openFiles:)]) { + [delegate performSelector:@selector(application:openFiles:) withObject:[NSApplication sharedApplication] withObject:files]; + [files release]; + [timer invalidate]; + } +} +@end +#endif + +static CFRunLoopRef loopRef = NULL; +static void * startThread(void * init); +static void runEventLoop(CFRunLoopRef ref); +static void dummyCallback(void * info) {} +#ifndef COCOA +static CFMutableArrayRef files; +static EventHandlerRef appHandler; +static int SWT_CLASS = 'SWT-'; +static int SWT_OPEN_FILE_KIND = 1; +static int SWT_OPEN_FILE_PARAM = 'odoc'; +#endif + +int main() { + return -1; +} + +void installAppleEventHandler(); + +int reuseWorkbench(_TCHAR** filePath, int timeout) { + installAppleEventHandler(); + return 0; +} + +#ifdef COCOA + +/* Show the Splash Window + * + * Create the splash window, load the bitmap and display the splash window. + */ +int showSplash( const _TCHAR* featureImage ) +{ + if (window != NULL) + return 0; /*already showing */ + if (featureImage == NULL) + return ENOENT; + + int result = ENOENT; + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + [NSApplication sharedApplication]; + NSImage* image = [[NSImage alloc] initByReferencingFile: [NSString stringWithUTF8String: featureImage]]; + if (image != NULL) { + NSImageRep* imageRep = [image bestRepresentationForDevice: [[NSScreen mainScreen] deviceDescription]]; + NSRect rect = {{0, 0}, {[imageRep pixelsWide], [imageRep pixelsHigh]}}; + [image setSize: NSMakeSize([imageRep pixelsWide], [imageRep pixelsHigh])]; + [image autorelease]; + window = [[KeyWindow alloc] initWithContentRect: rect styleMask: NSBorderlessWindowMask backing: NSBackingStoreBuffered defer: 0]; + if (window != nil) { + [window center]; + [window setBackgroundColor: [NSColor colorWithPatternImage: image]]; + [window makeKeyAndOrderFront: nil]; + dispatchMessages(); + result = 0; + } + } + [pool release]; + return result; +} + +void takeDownSplash() { + if (window != 0) { + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + [window close]; + window = nil; + [pool release]; + } +} + +void dispatchMessages() { + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + NSEvent* event; + NSApplication* application = [NSApplication sharedApplication]; + while ((event = [application nextEventMatchingMask: 0 untilDate: nil inMode: NSDefaultRunLoopMode dequeue: TRUE]) != nil) { + [application sendEvent: event]; + } + [pool release]; +} + +#else +static WindowRef window; +static ControlRef pane = NULL; +static CGImageRef image = NULL; +static CGImageRef loadBMPImage(const char *image); + +typedef CGImageSourceRef (*CGImageSourceCreateWithURL_FUNC) (CFURLRef, CFDictionaryRef); +typedef CGImageRef (*CGImageSourceCreateImageAtIndex_FUNC)(CGImageSourceRef, size_t, CFDictionaryRef); +static CGImageSourceCreateWithURL_FUNC createWithURL = NULL; +static CGImageSourceCreateImageAtIndex_FUNC createAtIndex = NULL; + +static pascal OSErr openDocumentsProc(const AppleEvent *theAppleEvent, AppleEvent *reply, long handlerRefcon); + +static OSStatus drawProc (EventHandlerCallRef eventHandlerCallRef, EventRef eventRef, void * data) { + int result = CallNextEventHandler(eventHandlerCallRef, eventRef); + if (image) { + ControlRef control; + CGContextRef context; + + GetEventParameter(eventRef, kEventParamDirectObject, typeControlRef, NULL, 4, NULL, &control); + GetEventParameter(eventRef, kEventParamCGContextRef, typeCGContextRef, NULL, 4, NULL, &context); + + HIRect rect; + HIViewGetBounds(control, &rect); + HIViewDrawCGImage(context, &rect, image); + } + return result; +} + +static OSStatus disposeProc (EventHandlerCallRef eventHandlerCallRef, EventRef eventRef, void * data) { + window = NULL; + return eventNotHandledErr; +} + +void loadImageFns() +{ + static int initialized = 0; + static CFBundleRef bundle = NULL; + + if (!initialized) { + if (!bundle) bundle = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.Carbon")); + if (bundle) createAtIndex = (CGImageSourceCreateImageAtIndex_FUNC)CFBundleGetFunctionPointerForName(bundle, CFSTR("CGImageSourceCreateImageAtIndex")); + if (bundle) createWithURL = (CGImageSourceCreateWithURL_FUNC)CFBundleGetFunctionPointerForName(bundle, CFSTR("CGImageSourceCreateWithURL")); + initialized = 1; + } +} + +static OSStatus appleEventProc(EventHandlerCallRef inCaller, EventRef theEvent, void* inRefcon) { + EventRecord eventRecord; + Boolean release = false; + EventQueueRef queue; + + queue = GetCurrentEventQueue(); + if (IsEventInQueue (queue, theEvent)) { + RetainEvent (theEvent); + release = true; + RemoveEventFromQueue (queue, theEvent); + } + ConvertEventRefToEventRecord (theEvent, &eventRecord); + AEProcessAppleEvent (&eventRecord); + if (release) ReleaseEvent (theEvent); + return noErr; +} + +static void timerProc(EventLoopTimerRef timer, void *userData) { + EventTargetRef target = GetApplicationEventTarget(); + CFIndex count = CFArrayGetCount (files); + int i; + for (i=0; i<count; i++) { + CFStringRef file = (CFStringRef) CFArrayGetValueAtIndex(files, i); + EventRef event = NULL; + CreateEvent (NULL, SWT_CLASS, SWT_OPEN_FILE_KIND, 0, kEventAttributeNone, &event); + SetEventParameter (event, SWT_OPEN_FILE_PARAM, typeCFStringRef, sizeof(file), &file); + OSStatus status = SendEventToEventTarget(event, target); + ReleaseEvent(event); + if (status == eventNotHandledErr) return; + } + CFRelease(files); + RemoveEventLoopTimer(timer); + RemoveEventHandler(appHandler); + AERemoveEventHandler(kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerUPP(openDocumentsProc), false); +} + +static pascal OSErr openDocumentsProc(const AppleEvent *theAppleEvent, AppleEvent *reply, long handlerRefcon) { + AEDescList docList; + FSRef theFSRef; + long index; + long count = 0; + + AEGetParamDesc(theAppleEvent, keyDirectObject, typeAEList, &docList); + AECountItems(&docList, &count); + for(index = 1; index <= count; index++) { + AEGetNthPtr(&docList, index, typeFSRef, NULL, NULL, &theFSRef, sizeof(FSRef), NULL); + CFURLRef url = CFURLCreateFromFSRef(kCFAllocatorDefault, &theFSRef); + CFStringRef pathName = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle); + if (!files) { + files = CFArrayCreateMutable(kCFAllocatorDefault, count, &kCFTypeArrayCallBacks); + InstallEventLoopTimer(GetMainEventLoop(), 1, 1, NewEventLoopTimerUPP(timerProc), NULL, NULL); + } + CFArrayAppendValue(files, pathName); + CFRelease(pathName); + CFRelease(url); + } + AEDisposeDesc(&docList); + return noErr; +} + +/* Show the Splash Window + * + * Create the splash window, load the bitmap and display the splash window. + */ +int showSplash( const _TCHAR* featureImage ) +{ + Rect wRect; + int w, h, deviceWidth, deviceHeight; + int attributes; + EventTypeSpec draw = {kEventClassControl, kEventControlDraw}; + EventTypeSpec dispose = {kEventClassWindow, kEventWindowDispose}; + ControlRef root; + + if(window != NULL) + return 0; /*already showing */ + if (featureImage == NULL) + return ENOENT; + + loadImageFns(); + if (createWithURL && createAtIndex) { + CFStringRef imageString = CFStringCreateWithCString(kCFAllocatorDefault, featureImage, kCFStringEncodingUTF8); + if(imageString != NULL) { + CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, imageString, kCFURLPOSIXPathStyle, false); + if(url != NULL) { + CGImageSourceRef imageSource = createWithURL(url, NULL); + if(imageSource != NULL) { + image = createAtIndex(imageSource, 0, NULL); + } + CFRelease(url); + } + } + CFRelease(imageString); + } else { + image = loadBMPImage(featureImage); + } + + /*If the splash image data could not be loaded, return an error.*/ + if (image == NULL) + return ENOENT; + + w = CGImageGetWidth(image); + h = CGImageGetHeight(image); + + GetAvailableWindowPositioningBounds(GetMainDevice(), &wRect); + + deviceWidth= wRect.right - wRect.left; + deviceHeight= wRect.bottom - wRect.top; + + wRect.left+= (deviceWidth-w)/2; + wRect.top+= (deviceHeight-h)/3; + wRect.right= wRect.left + w; + wRect.bottom= wRect.top + h; + + attributes = kWindowStandardHandlerAttribute | kWindowCompositingAttribute; + attributes &= GetAvailableWindowAttributes(kSheetWindowClass); + CreateNewWindow(kSheetWindowClass, attributes, &wRect, &window); + if (window != NULL) { + GetRootControl(window, &root); + wRect.left = wRect.top = 0; + wRect.right = w; + wRect.bottom = h; + CreateUserPaneControl(window, &wRect, kControlSupportsEmbedding | kControlSupportsFocus | kControlGetsFocusOnClick, &pane); + HIViewAddSubview(root, pane); + + InstallEventHandler(GetControlEventTarget(pane), (EventHandlerUPP)drawProc, 1, &draw, NULL, NULL); + InstallEventHandler(GetWindowEventTarget(window), (EventHandlerUPP)disposeProc, 1, &dispose, NULL, NULL); + ShowWindow(window); + dispatchMessages(); + } + + return 0; +} + +void takeDownSplash() { + if( window != 0) { + DisposeWindow(window); + window = NULL; + } + if(image){ + CGImageRelease(image); + image = NULL; + } +} + +void dispatchMessages() { + EventRef event; + EventTargetRef target; + + target = GetEventDispatcherTarget(); + while( ReceiveNextEvent(0, NULL, kEventDurationNoWait, true, &event) == noErr ) { + SendEventToEventTarget(event, target); + ReleaseEvent(event); + } +} +#endif + +void installAppleEventHandler() { +#ifdef COCOA + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + AppleEventDelegate *appleEventDelegate = [[AppleEventDelegate alloc] init]; + [NSApplication sharedApplication]; + NSAppleEventManager *manager = [NSAppleEventManager sharedAppleEventManager]; + [manager setEventHandler:appleEventDelegate + andSelector:@selector(handleOpenDocuments:withReplyEvent:) + forEventClass:kCoreEventClass + andEventID:kAEOpenDocuments]; +// [appleEventDelegate release]; + [pool release]; +#else + EventTypeSpec kEvents[] = { {kEventClassAppleEvent, kEventAppleEvent} }; + InstallApplicationEventHandler(NewEventHandlerUPP(appleEventProc), GetEventTypeCount(kEvents), kEvents, 0, &appHandler); + AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerUPP(openDocumentsProc), 0, false); +#endif +} + +jlong getSplashHandle() { + return (jlong)window; +} + +/* Get the window system specific VM arguments */ +char** getArgVM( char* vm ) +{ + char** result; + + /* Use the default arguments for a standard Java VM */ + result = argVM_JAVA; + + return result; +} + +char * getJavaHome() { + FILE *fp; + char path[4096]; + char *result, *start; + sprintf(path, "/usr/libexec/java_home -a %s", JAVA_HOME_ARCH); + fp = popen(path, "r"); + if (fp == NULL) { + return NULL; + } + while (fgets(path, sizeof(path)-1, fp) != NULL) { + } + result = path; + start = strchr(result, '\n'); + if (start) { + start[0] = 0; + } + sprintf(path, "%s/bin/java", result); + pclose(fp); + return strdup(path); +} + +char * findVMLibrary( char* command ) { + char *start, *end; + char *version, *result, *cmd; + int length; + + /*check first to see if command already points to the library */ + if (strcmp(command, JAVA_FRAMEWORK) == 0) { + return JAVA_FRAMEWORK; + } + + /* select a version to use based on the command */ + start = strstr(command, "/Versions/"); + if (start != NULL){ + start += 10; + end = strchr( start, dirSeparator); + if (end != NULL && end > start) { + length = end - start; + version = malloc(length + 1); + strncpy(version, start, length); + version[length] = 0; + + /*only set a version if it starts with a number */ + if(strtol(version, NULL, 10) != 0 || version[0] == '0') { + setenv("JAVA_JVM_VERSION", version, 1); + } + + free(version); + } + } + cmd = command; + if (strstr(cmd, "/JavaVM.framework/") != NULL && (strstr(cmd, "/Current/") != NULL || strstr(cmd, "/A/") != NULL)) { + cmd = getJavaHome(); + } + result = JAVA_FRAMEWORK; + if (strstr(cmd, "/JavaVM.framework/") == NULL) { + char * lib = findLib(cmd); + if (lib != NULL) { + adjustLibraryPath(lib); + result = lib; + } + } + if (cmd != command) free(cmd); + return result; +} + +static char * findLib(char * command) { + int i, q; + int pathLength; + struct stat stats; + char * path; /* path to resulting jvm shared library */ + char * location; /* points to begining of jvmLocations section of path */ + + if (command != NULL) { + /*check first to see if command already points to the library */ + if (isVMLibrary(command)) { + if (stat(command, &stats) == 0 && (stats.st_mode & S_IFREG) != 0) { /* found it */ + return strdup(command); + } + return NULL; + } + + location = strrchr(command, dirSeparator) + 1; + pathLength = location - command; + path = malloc((pathLength + MAX_LOCATION_LENGTH + 1 + MAX_JVMLIB_LENGTH + 1) * sizeof(char)); + strncpy(path, command, pathLength); + location = &path[pathLength]; + + /* + * We are trying base/jvmLocations[*]/vmLibrary + * where base is the directory containing the given java command, normally jre/bin + */ + for (q = 0; jvmLibs[q] != NULL; ++q) { + const char *jvmLib = jvmLibs[q]; + i = -1; + while (jvmLocations[++i] != NULL) { + sprintf(location, "%s%c%s", jvmLocations[i], dirSeparator, jvmLib); + /*fprintf(stderr,"checking path: %s\n",path);*/ + if (stat(path, &stats) == 0 && (stats.st_mode & S_IFREG) != 0) + { /* found it */ + return path; + } + } + } + } + return NULL; +} + +/* adjust the LD_LIBRARY_PATH for the vmLibrary */ +static void adjustLibraryPath(char * vmLibrary) { + char * c; + char * ldPath, *dylibPath; + char * newPath; + int i; + int numPaths = 0; + int length = 0; + int needAdjust = 0, needDylibAdjust = 0; + + char ** paths = getVMLibrarySearchPath(vmLibrary); + + ldPath = (char*) getenv(LIB_PATH_VAR); + if (!ldPath) { + ldPath = _T_ECLIPSE(""); + needAdjust = 1; + } else { + needAdjust = !containsPaths(ldPath, paths); + } + + dylibPath = (char*) getenv(DYLD_FALLBACK_VAR); + if (!dylibPath) { + dylibPath = _T_ECLIPSE(""); + needDylibAdjust = 1; + } else { + needDylibAdjust = !containsPaths(dylibPath, paths); + } + + if (!needAdjust && !needDylibAdjust) { + for (i = 0; paths[i] != NULL; i++) + free(paths[i]); + free(paths); + return; + } + + c = concatStrings(paths); + + /* set the value for LD_LIBRARY_PATH */ + length = strlen(ldPath); + newPath = malloc((_tcslen(c) + length + 1) * sizeof(_TCHAR)); + _stprintf(newPath, _T_ECLIPSE("%s%s"), c, ldPath); + setenv(LIB_PATH_VAR, newPath, 1); + free(newPath); + + /* set the value for DYLD_FALLBACK_LIBRARY_PATH */ + length = strlen(dylibPath); + newPath = malloc((_tcslen(c) + length + 1) * sizeof(_TCHAR)); + _stprintf(newPath, _T_ECLIPSE("%s%s"), c, dylibPath); + setenv(DYLD_FALLBACK_VAR, newPath, 1); + free(newPath); + free(c); + + for (i = 0; i < numPaths; i++) + free(paths[i]); + free(paths); + + /* now we must restart for this to take affect*/ + restartLauncher(initialArgv[0], initialArgv); +} + +void restartLauncher(char* program, char* args[]) { + pid_t pid= fork(); + if (pid == 0) { + /* Child process ... start the JVM */ + execv(program != NULL ? program : args[0], args); + + /* The JVM would not start ... return error code to parent process. */ + _exit(errno); + } else { + exit(0); + } +} + +JavaResults* launchJavaVM( _TCHAR* args[] ) +{ + /*for now always do JNI on Mac, should not come in here */ + JavaResults * results = malloc(sizeof(JavaResults)); + results->launchResult = -1; + results->runResult = 0; + results->errorMessage = _tcsdup(noForkingMsg); + return results; +} + +JavaResults* startJavaVM( _TCHAR* libPath, _TCHAR* vmArgs[], _TCHAR* progArgs[], _TCHAR* jarFile ) +{ + if (secondThread == 0) { + /* Set an environment variable that tells the AWT (if started) we started the JVM on the main thread. */ + char firstThreadEnvVariable[80]; + sprintf(firstThreadEnvVariable, "JAVA_STARTED_ON_FIRST_THREAD_%d", getpid()); + setenv(firstThreadEnvVariable, "1", 1); + return startJavaJNI(libPath, vmArgs, progArgs, jarFile); + } + + /* else, --launcher.secondThread was specified, create a new thread and run the + * vm on it. This main thread will run the CFRunLoop + */ + pthread_t thread; + struct rlimit limit = {0, 0}; + int stackSize = 0; + if (getrlimit(RLIMIT_STACK, &limit) == 0) { + if (limit.rlim_cur != 0) { + stackSize = limit.rlim_cur; + } + } + + /* initialize thread attributes */ + pthread_attr_t attributes; + pthread_attr_init(&attributes); + pthread_attr_setscope(&attributes, PTHREAD_SCOPE_SYSTEM); + pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_DETACHED); + if (stackSize != 0) + pthread_attr_setstacksize(&attributes, stackSize); + + /* arguments to start the vm */ + StartVMArgs args; + args.libPath = libPath; + args.vmArgs = vmArgs; + args.progArgs = progArgs; + args.jarFile = jarFile; + args.result = 0; + + loopRef = CFRunLoopGetCurrent(); + + /* create the thread */ + pthread_create( &thread, &attributes, &startThread, &args); + pthread_attr_destroy(&attributes); + + runEventLoop(loopRef); + + return args.result; +} + +void * startThread(void * init) { + StartVMArgs *args = (StartVMArgs *) init; + args->result = startJavaJNI(args->libPath, args->vmArgs, args->progArgs, args->jarFile); + return NULL; +} + +void runEventLoop(CFRunLoopRef ref) { + CFRunLoopSourceContext sourceContext = { .version = 0, .info = NULL, .retain = NULL, .release = NULL, + .copyDescription = NULL, .equal = NULL, .hash = NULL, + .schedule = NULL, .cancel = NULL, .perform = &dummyCallback }; + + CFRunLoopSourceRef sourceRef = CFRunLoopSourceCreate(NULL, 0, &sourceContext); + CFRunLoopAddSource(ref, sourceRef, kCFRunLoopCommonModes); + + CFRunLoopRun(); + CFRelease(sourceRef); +} + +#ifndef COCOA +void disposeData(void *info, void *data, size_t size) +{ + DisposePtr(data); +} + +/** + * loadBMPImage + * Create a QuickDraw PixMap representing the given BMP file. + * + * bmpPathname: absolute path and name to the bmp file + * + * returned value: the PixMapHandle newly created if successful. 0 otherwise. + */ +static CGImageRef loadBMPImage (const char *bmpPathname) { + ng_stream_t in; + ng_bitmap_image_t image; + ng_err_t err= ERR_OK; + CGImageRef ref; + UBYTE1* data = NULL; + + NgInit(); + + if (NgStreamInit(&in, (char*) bmpPathname) != ERR_OK) { + NgError(ERR_NG, "Error can't open BMP file"); + return 0; + } + + NgBitmapImageInit(&image); + err= NgBmpDecoderReadImage (&in, &image); + NgStreamClose(&in); + + if (err != ERR_OK) { + NgBitmapImageFree(&image); + return 0; + } + + UBYTE4 srcDepth= NgBitmapImageBitCount(&image); + if (srcDepth != 24) { /* We only support image depth of 24 bits */ + NgBitmapImageFree(&image); + NgError (ERR_NG, "Error unsupported depth - only support 24 bit"); + return 0; + } + + int width= (int)NgBitmapImageWidth(&image); + int height= (int)NgBitmapImageHeight(&image); + int rowBytes= width * 4; + int alphainfo = kCGImageAlphaNoneSkipFirst | (NgIsMSB() ? 0 : kCGBitmapByteOrder32Little); + data = (UBYTE1*)NewPtr(rowBytes * height); + CGDataProviderRef provider = CGDataProviderCreateWithData(0, data, rowBytes * height, (CGDataProviderReleaseDataCallback)disposeData); + + ref = CGImageCreate(width, height, 8, 32, width * 4, CGColorSpaceCreateDeviceRGB(), alphainfo, provider, NULL, 1, 0); + CGDataProviderRelease(provider); + + /* 24 bit source to direct screen destination */ + NgBitmapImageBlitDirectToDirect(NgBitmapImageImageData(&image), NgBitmapImageBytesPerRow(&image), width, height, + data, 32, rowBytes, NgIsMSB(), 0xff0000, 0x00ff00, 0x0000ff); + + NgBitmapImageFree(&image); + + return ref; +} +#endif + +#define DOCK_ICON_PREFIX "-Xdock:icon=" +#define DOCK_NAME_PREFIX "-Xdock:name=" +#define APP_ICON_PATTERN "APP_ICON_%d" +#define APP_NAME_PATTERN "APP_NAME_%d" + +void processVMArgs(char **vmargs[] ) +{ + int i = -1; + int pid = 0, pidLength = 1, temp = 0; + char * name = NULL, *icon = NULL; + char * c; + + if( *vmargs == NULL) + return; + + while( (*vmargs)[++i] != NULL ) { + /*-Xdock:icon -> APP_ICON_<pid>*/ + if(_tcsncmp((*vmargs)[i], DOCK_ICON_PREFIX, _tcslen(DOCK_ICON_PREFIX)) == 0) { + icon = (*vmargs)[i] + _tcslen(DOCK_ICON_PREFIX); + } + /*-Xdock:name -> APP_NAME_<pid>*/ + else if(_tcsncmp((*vmargs)[i], DOCK_NAME_PREFIX, _tcslen(DOCK_NAME_PREFIX)) == 0) { + name = (*vmargs)[i] + _tcslen(DOCK_NAME_PREFIX); + } + if (name != NULL && icon != NULL) + break; + } + + if (name == NULL && icon == NULL) + return; /* don't need to do anything */ + + temp = pid = getpid(); + /* how many digits in pid? */ + while (temp > 9) { + pidLength++; + temp /= 10; + } + + if (name != NULL) { + c = malloc( (_tcslen(APP_NAME_PATTERN) + pidLength + 1) * sizeof(char*)); + _stprintf( c, APP_NAME_PATTERN, pid ); + setenv(c, name, 1); + } + + if (icon != NULL) { + c = malloc( (_tcslen(icon) + _tcslen(APP_ICON_PATTERN) + pidLength + 1) * sizeof(char*)); + _stprintf( c, APP_ICON_PATTERN, pid ); + setenv(c, icon, 1); + } +} + +int isSunVM( _TCHAR * javaVM, _TCHAR * jniLib ) { + return isSUN; +} diff --git a/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseCarbonCommon.c b/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseCarbonCommon.c new file mode 100644 index 000000000..2870c62e8 --- /dev/null +++ b/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseCarbonCommon.c @@ -0,0 +1,195 @@ +/******************************************************************************* + * Copyright (c) 2006, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + * Andrew Niefer + *******************************************************************************/ + +#include "eclipseCommon.h" +#include "eclipseOS.h" + +#include <locale.h> +#include <dlfcn.h> +#include <unistd.h> +#include <CoreServices/CoreServices.h> +#ifdef COCOA +#include <Cocoa/Cocoa.h> +#else +#include <Carbon/Carbon.h> +#endif +#include <mach-o/dyld.h> + +char dirSeparator = '/'; +char pathSeparator = ':'; + +static CFBundleRef javaVMBundle = NULL; + +int initialized = 0; + +static void init() { + if (!initialized) { + ProcessSerialNumber psn; + if (GetCurrentProcess(&psn) == noErr) { + TransformProcessType(&psn, kProcessTransformToForegroundApplication); + SetFrontProcess(&psn); + } +#ifdef COCOA + [NSApplication sharedApplication]; +#else + ClearMenuBar(); +#endif + initialized= true; + } +} + + +/* Initialize Window System + * + * Initialize Carbon. + */ +int initWindowSystem( int* pArgc, char* argv[], int showSplash ) +{ + char *homeDir = getProgramDir(); + /*debug("install dir: %s\n", homeDir);*/ + if (homeDir != NULL) + chdir(homeDir); + + if (showSplash) + init(); + + return 0; +} + +/* Display a Message */ +void displayMessage(char *title, char *message) +{ + CFStringRef inError, inDescription= NULL; + + /* try to break the message into a first sentence and the rest */ + char *pos= strstr(message, ". "); + if (pos != NULL) { + char *to, *from, *buffer= calloc(pos-message+2, sizeof(char)); + /* copy and replace line separators with blanks */ + for (to= buffer, from= message; from <= pos; from++, to++) { + char c= *from; + if (c == '\n') c= ' '; + *to= c; + } + inError= CFStringCreateWithCString(kCFAllocatorDefault, buffer, kCFStringEncodingUTF8); + free(buffer); + inDescription= CFStringCreateWithCString(kCFAllocatorDefault, pos+2, kCFStringEncodingUTF8); + } else { + inError= CFStringCreateWithCString(kCFAllocatorDefault, message, kCFStringEncodingUTF8); + } + + init(); + +#ifdef COCOA + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + NSAlert* alert = [NSAlert alertWithMessageText: (NSString*)(inDescription != nil ? inError : nil) defaultButton: nil alternateButton: nil otherButton: nil informativeTextWithFormat: (NSString*)(inDescription != nil ? inDescription : inError)]; + [[alert window] setTitle: [NSString stringWithUTF8String: title]]; + [alert setAlertStyle: NSCriticalAlertStyle]; + [alert runModal]; + [pool release]; +#else + DialogRef outAlert; + OSStatus status= CreateStandardAlert(kAlertStopAlert, inError, inDescription, NULL, &outAlert); + if (status == noErr) { + DialogItemIndex outItemHit; + RunStandardAlert(outAlert, NULL, &outItemHit); + } else { + /*debug("%s: displayMessage: %s\n", title, message);*/ + } +#endif + CFRelease(inError); + if (inDescription != NULL) + CFRelease(inDescription); +} + +static int isLibrary( _TCHAR* vm ){ + _TCHAR *ch = NULL; + if (vm == NULL) return 0; + ch = _tcsrchr( vm, '.' ); + if(ch == NULL) + return 0; + return (_tcsicmp(ch, _T_ECLIPSE(".so")) == 0) || (_tcsicmp(ch, _T_ECLIPSE(".jnilib")) == 0) || (_tcsicmp(ch, _T_ECLIPSE(".dylib")) == 0); +} + +/* Load the specified shared library + */ +void * loadLibrary( char * library ){ + if (!isLibrary(library)) { + CFURLRef url = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (const UInt8 *)library, strlen(library), true); + javaVMBundle = CFBundleCreate(kCFAllocatorDefault, url); + CFRelease(url); + return (void*) &javaVMBundle; + } else { + void * result= dlopen(library, RTLD_NOW); + if(result == 0) + printf("%s\n",dlerror()); + return result; + } +} + +/* Unload the shared library + */ +void unloadLibrary( void * handle ){ + if (handle == &javaVMBundle) + CFRelease(javaVMBundle); + else + dlclose(handle); +} + +/* Find the given symbol in the shared library + */ +void * findSymbol( void * handle, char * symbol ){ + if(handle == &javaVMBundle) { + CFStringRef string = CFStringCreateWithCString(kCFAllocatorDefault, symbol, kCFStringEncodingASCII); + void * ptr = CFBundleGetFunctionPointerForName(javaVMBundle, string); + CFRelease(string); + return ptr; + } else + return dlsym(handle, symbol); +} + +char * resolveSymlinks( char * path ) { + char * result = 0; + CFURLRef url, resolved; + CFStringRef string; + FSRef fsRef; + Boolean isFolder, wasAliased; + + if(path == NULL) + return path; + + string = CFStringCreateWithCString(kCFAllocatorDefault, path, kCFStringEncodingUTF8); + url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, string, kCFURLPOSIXPathStyle, false); + CFRelease(string); + if(url == NULL) + return path; + + if(CFURLGetFSRef(url, &fsRef)) { + if( FSResolveAliasFile(&fsRef, true, &isFolder, &wasAliased) == noErr) { + resolved = CFURLCreateFromFSRef(kCFAllocatorDefault, &fsRef); + if(resolved != NULL) { + string = CFURLCopyFileSystemPath(resolved, kCFURLPOSIXPathStyle); + CFIndex length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(string), kCFStringEncodingUTF8); + char *s = malloc(length); + if (CFStringGetCString(string, s, length, kCFStringEncodingUTF8)) { + result = s; + } else { + free(s); + } + CFRelease(string); + CFRelease(resolved); + } + } + } + CFRelease(url); + return result; +}
\ No newline at end of file diff --git a/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseCarbonMain.c b/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseCarbonMain.c new file mode 100644 index 000000000..51cafc275 --- /dev/null +++ b/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseCarbonMain.c @@ -0,0 +1,237 @@ +/* + * Copyright (c) 2006, 2009 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + * Andrew Niefer + */ + +#include "eclipseCommon.h" + +#include <sys/stat.h> +#include <sys/types.h> +#include <fcntl.h> +#include <ctype.h> +#include <pwd.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <sys/ioctl.h> +#include <unistd.h> + +#include <CoreServices/CoreServices.h> +#include <Carbon/Carbon.h> +#include <mach-o/dyld.h> + + +#define APP_PACKAGE_PATTERN ".app/Contents/MacOS/" +#define APP_PACKAGE "APP_PACKAGE" +#define JAVAROOT "JAVAROOT" + +static void debug(const char *fmt, ...); +static void dumpArgs(char *tag, int argc, char* argv[]); +static char *append(char *buffer, const char *s); +static char *appendc(char *buffer, char c); +static char *expandShell(char *arg, const char *appPackage, const char *javaRoot); +static char *my_strcasestr(const char *big, const char *little); + +static FILE *fgConsoleLog; +static char *fgAppPackagePath; +static int fgPid; + +extern int original_main(int argc, char* argv[]); +int main( int argc, char* argv[] ) { + + SInt32 systemVersion= 0; + if (Gestalt(gestaltSystemVersion, &systemVersion) == noErr) { + systemVersion &= 0xffff; +#ifdef COCOA + if (systemVersion < 0x1050) { + displayMessage("Error", "This application requires Mac OS X 10.5 (Leopard) or greater."); + return 0; + } +#else + if (systemVersion < 0x1020) { + displayMessage("Error", "This application requires Jaguar (Mac OS X >= 10.2)"); + return 0; + } +#endif + } + + fgConsoleLog= fopen("/dev/console", "w"); + fgPid= getpid(); + + dumpArgs("start", argc, argv); + if ( (argc > 1 && strncmp(argv[1], "-psn_", 5) == 0) || argc == 1) { + /* find path to application bundle (ignoring case) */ + char *pos= my_strcasestr(argv[0], APP_PACKAGE_PATTERN); + if (pos != NULL) { + int l= pos-argv[0] + 4; // reserve space for ".app" + fgAppPackagePath= malloc(l+1); + strncpy(fgAppPackagePath, argv[0], l); + fgAppPackagePath[l]= '\0'; // terminate result + } + + /* Get the main bundle for the app */ + CFBundleRef mainBundle= CFBundleGetMainBundle(); + if (mainBundle != NULL) { + + /* Get an instance of the info plist.*/ + CFDictionaryRef bundleInfoDict= CFBundleGetInfoDictionary(mainBundle); + + /* If we succeeded, look for our property. */ + if (bundleInfoDict != NULL) { + CFArrayRef ar= CFDictionaryGetValue(bundleInfoDict, CFSTR("Eclipse")); + if (ar) { + CFIndex size= CFArrayGetCount(ar); + if (size > 0) { + int i; + char **old_argv= argv; + argv= (char**) calloc(size+2, sizeof(char*)); + argc= 0; + argv[argc++]= old_argv[0]; + for (i= 0; i < size; i++) { + CFStringRef sr= (CFStringRef) CFArrayGetValueAtIndex (ar, i); + CFIndex argStringSize= CFStringGetMaximumSizeForEncoding(CFStringGetLength(sr), kCFStringEncodingUTF8); + char *s= malloc(argStringSize); + if (CFStringGetCString(sr, s, argStringSize, kCFStringEncodingUTF8)) { + argv[argc++]= expandShell(s, fgAppPackagePath, NULL); + } else { + fprintf(fgConsoleLog, "can't extract bytes\n"); + } + //free(s); + } + } + } else { + fprintf(fgConsoleLog, "no Eclipse dict found\n"); + } + } else { + fprintf(fgConsoleLog, "no bundle dict found\n"); + } + } else { + fprintf(fgConsoleLog, "no bundle found\n"); + } + } + int exitcode= original_main(argc, argv); + debug("<<<< exit(%d)\n", exitcode); + fclose(fgConsoleLog); + return exitcode; +} + +static void debug(const char *fmt, ...) { +#if DEBUG + va_list ap; + va_start(ap, fmt); + fprintf(fgConsoleLog, "%05d: ", fgPid); + vfprintf(fgConsoleLog, fmt, ap); + va_end(ap); +#endif +} + +static void dumpArgs(char *tag, int argc, char* argv[]) { +#if DEBUG + int i; + if (argc < 0) { + argc= 0; + for (i= 0; argv[i] != NULL; i++) + argc++; + } + debug(">>>> %s:", tag); + for (i= 0; i < argc && argv[i] != NULL; i++) + fprintf(fgConsoleLog, " <%s>", argv[i]); + fprintf(fgConsoleLog, "\n"); +#endif +} + +/* + * Expand $APP_PACKAGE, $JAVA_HOME, and does tilde expansion. + + A word beginning with an unquoted tilde character (~) is + subject to tilde expansion. All the characters up to a + slash (/) or the end of the word are treated as a username + and are replaced with the user's home directory. If the + username is missing (as in ~/foobar), the tilde is + replaced with the value of the HOME variable (the current + user's home directory). + */ +static char *expandShell(char *arg, const char *appPackage, const char *javaRoot) { + + if (index(arg, '~') == NULL && index(arg, '$') == NULL) + return arg; + + char *buffer= strdup(""); + char c, lastChar= ' '; + const char *cp= arg; + while ((c = *cp++) != 0) { + if (isspace(lastChar) && c == '~') { + char name[100], *dir= NULL; + int j= 0; + for (; (c = *cp) != 0; cp++) { + if (! isalnum(c)) + break; + name[j++]= c; + lastChar= c; + } + name[j]= '\0'; + if (j > 0) { + struct passwd *pw= getpwnam(name); + if (pw != NULL) + dir= pw->pw_dir; + } else { + dir= getenv("HOME"); + } + if (dir != NULL) + buffer= append(buffer, dir); + + } else if (c == '$') { + int l= strlen(APP_PACKAGE); + if (appPackage != NULL && strncmp(cp, APP_PACKAGE, l) == 0) { + cp+= l; + buffer= append(buffer, appPackage); + } else { + int l= strlen(JAVAROOT); + if (javaRoot != NULL && strncmp(cp, JAVAROOT, l) == 0) { + cp+= l; + buffer= append(buffer, javaRoot); + } else { + buffer= appendc(buffer, c); + } + } + } else + buffer= appendc(buffer, c); + lastChar= c; + } + return buffer; +} + +static char *my_strcasestr(const char *big, const char *little) { + char *cp, *s, *t; + for (cp= (char*) big; *cp; cp++) { + for (s= cp, t= (char*) little; *s && *t; s++, t++) + if (toupper(*s) != toupper(*t)) + break; + if (*t == '\0') + return cp; + } + return NULL; +} + +static char *append(char *buffer, const char *s) { + int bl= strlen(buffer); + int sl= strlen(s); + buffer= realloc(buffer, bl+sl+1); + strcpy(&buffer[bl], s); + return buffer; +} + +static char *appendc(char *buffer, char c) { + int bl= strlen(buffer); + buffer= realloc(buffer, bl+2); + buffer[bl++]= c; + buffer[bl]= '\0'; + return buffer; +}
\ No newline at end of file diff --git a/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseMain.c b/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseMain.c new file mode 100644 index 000000000..c0eaffa13 --- /dev/null +++ b/features/org.eclipse.equinox.executable.feature/library/carbon/eclipseMain.c @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2000, 2006 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + * Andre Weinand (OTI Labs) + */ + +#define main original_main + +#include "../eclipseMain.c" diff --git a/features/org.eclipse.equinox.executable.feature/library/carbon/make_carbon.mak b/features/org.eclipse.equinox.executable.feature/library/carbon/make_carbon.mak new file mode 100644 index 000000000..34843b739 --- /dev/null +++ b/features/org.eclipse.equinox.executable.feature/library/carbon/make_carbon.mak @@ -0,0 +1,93 @@ +#********************************************************************** +# Copyright (c) 2000, 2008 IBM Corporation and others. +# All rights reserved. This program and the accompanying materials +# are made available under the terms of the Eclipse Public License v1.0 +# which accompanies this distribution, and is available at +# http://www.eclipse.org/legal/epl-v10.html +# +# Contributors: +# Kevin Cornell (Rational Software Corporation) +#********************************************************************** +include ../make_version.mak +# Makefile for creating the Carbon eclipse launcher program. + +# This makefile expects the following environment variables set: +# +# PROGRAM_OUTPUT - the filename of the output executable +# DEFAULT_OS - the default value of the "-os" switch +# DEFAULT_OS_ARCH - the default value of the "-arch" switch +# DEFAULT_WS - the default value of the "-ws" switch + +#default value for PROGRAM_OUTPUT +ifeq ($(PROGRAM_OUTPUT),) + PROGRAM_OUTPUT=eclipse +endif +PROGRAM_LIBRARY=eclipse_$(LIB_VERSION).so + +# Define the object modules to be compiled and flags. +MAIN_OBJS = eclipseMain.o eclipseCarbonMain.o +COMMON_OBJS = eclipseConfig.o eclipseCommon.o eclipseCarbonCommon.o +DLL_OBJS = eclipse.o eclipseCarbon.o eclipseUtil.o eclipseJNI.o eclipseShm.o NgImageData.o NgWinBMPFileFormat.o NgCommon.o + +EXEC = $(PROGRAM_OUTPUT) +DLL = $(PROGRAM_LIBRARY) +LIBS = -framework Carbon +ARCHS = -arch i386 -arch ppc +CFLAGS = -O -s \ + -mmacosx-version-min=10.3 \ + -Wall \ + $(ARCHS) \ + -DMACOSX \ + -DDEFAULT_OS="\"$(DEFAULT_OS)\"" \ + -DDEFAULT_OS_ARCH="\"$(DEFAULT_OS_ARCH)\"" \ + -DDEFAULT_WS="\"$(DEFAULT_WS)\"" \ + -I.. -I../motif -I/System/Library/Frameworks/JavaVM.framework/Headers + +all: $(EXEC) $(DLL) + +eclipse.o: ../eclipse.c ../eclipseOS.h ../eclipseCommon.h ../eclipseJNI.h + $(CC) $(CFLAGS) -c ../eclipse.c -o $@ + +eclipseCarbonMain.o : eclipseCarbonMain.c + $(CC) $(CFLAGS) -c eclipseCarbonMain.c -o $@ + +eclipseMain.o: ../eclipseUnicode.h ../eclipseCommon.h eclipseMain.c ../eclipseMain.c + $(CC) $(CFLAGS) -c eclipseMain.c -o $@ + +eclipseJNI.o: ../eclipseJNI.c ../eclipseCommon.h ../eclipseOS.h ../eclipseJNI.h + $(CC) $(CFLAGS) -c ../eclipseJNI.c -o $@ + +eclipseUtil.o: ../eclipseUtil.c ../eclipseUtil.h ../eclipseOS.h + $(CC) $(CFLAGS) -c ../eclipseUtil.c -o $@ + +eclipseConfig.o: ../eclipseConfig.c ../eclipseConfig.h ../eclipseOS.h + $(CC) $(CFLAGS) -c ../eclipseConfig.c -o $@ + +eclipseCommon.o: ../eclipseCommon.h ../eclipseUnicode.h ../eclipseCommon.c + $(CC) $(CFLAGS) -c ../eclipseCommon.c -o $@ + +eclipseShm.o: ../eclipseShm.h ../eclipseUnicode.h ../eclipseShm.c + $(CC) $(CFLAGS) -c ../eclipseShm.c -o $@ + +NgCommon.o: ../motif/NgCommon.c + $(CC) $(CFLAGS) -c ../motif/NgCommon.c -o $@ + +NgWinBMPFileFormat.o: ../motif/NgWinBMPFileFormat.c + $(CC) $(CFLAGS) -c ../motif/NgWinBMPFileFormat.c -o $@ + +NgImageData.o: ../motif/NgImageData.c + $(CC) $(CFLAGS) -c ../motif/NgImageData.c -o $@ + +$(EXEC): $(MAIN_OBJS) $(COMMON_OBJS) + $(CC) -o $(EXEC) $(ARCHS) $(MAIN_OBJS) $(COMMON_OBJS) $(LIBS) + +$(DLL): $(DLL_OBJS) $(COMMON_OBJS) + $(CC) -bundle -o $(DLL) $(ARCHS) $(DLL_OBJS) $(COMMON_OBJS) $(LIBS) + +install: all + cp $(EXEC) $(PPC_OUTPUT_DIR) + cp $(EXEC) $(X86_OUTPUT_DIR) + rm -f $(EXEC) $(OBJS) + +clean: + rm -f $(EXEC) $(DLL) $(MAIN_OBJS) $(COMMON_OBJS) $(DLL_OBJS) diff --git a/features/org.eclipse.equinox.executable.feature/library/carbon/make_cocoa.mak b/features/org.eclipse.equinox.executable.feature/library/carbon/make_cocoa.mak new file mode 100644 index 000000000..868c34bbf --- /dev/null +++ b/features/org.eclipse.equinox.executable.feature/library/carbon/make_cocoa.mak @@ -0,0 +1,97 @@ +#********************************************************************** +# Copyright (c) 2000, 2008 IBM Corporation and others. +# All rights reserved. This program and the accompanying materials +# are made available under the terms of the Eclipse Public License v1.0 +# which accompanies this distribution, and is available at +# http://www.eclipse.org/legal/epl-v10.html +# +# Contributors: +# Kevin Cornell (Rational Software Corporation) +#********************************************************************** +include ../make_version.mak +# Makefile for creating the Carbon eclipse launcher program. + +# This makefile expects the following environment variables set: +# +# PROGRAM_OUTPUT - the filename of the output executable +# DEFAULT_OS - the default value of the "-os" switch +# DEFAULT_OS_ARCH - the default value of the "-arch" switch +# DEFAULT_WS - the default value of the "-ws" switch + +#default value for PROGRAM_OUTPUT +ifeq ($(PROGRAM_OUTPUT),) + PROGRAM_OUTPUT=eclipse +endif +PROGRAM_LIBRARY=eclipse_$(LIB_VERSION).so + +# Define the object modules to be compiled and flags. +MAIN_OBJS = eclipseMain.o eclipseCarbonMain.o +COMMON_OBJS = eclipseConfig.o eclipseCommon.o eclipseCarbonCommon.o +DLL_OBJS = eclipse.o eclipseCarbon.o eclipseUtil.o eclipseJNI.o eclipseShm.o +#NgImageData.o NgWinBMPFileFormat.o NgCommon.o + +EXEC = $(PROGRAM_OUTPUT) +DLL = $(PROGRAM_LIBRARY) +LIBS = -framework Cocoa + +ifeq ($(ARCHS),) +ARCHS = -arch i386 -arch ppc +endif + +CFLAGS = -O -s \ + -Wall \ + -DCOCOA -xobjective-c \ + $(ARCHS) \ + -DMACOSX \ + -DDEFAULT_OS="\"$(DEFAULT_OS)\"" \ + -DDEFAULT_OS_ARCH="\"$(DEFAULT_OS_ARCH)\"" \ + -DDEFAULT_WS="\"$(DEFAULT_WS)\"" \ + -I.. -I../motif -I/System/Library/Frameworks/JavaVM.framework/Headers + +all: $(EXEC) $(DLL) + +eclipse.o: ../eclipse.c ../eclipseOS.h ../eclipseCommon.h ../eclipseJNI.h + $(CC) $(CFLAGS) -c ../eclipse.c -o $@ + +eclipseCarbonMain.o : eclipseCarbonMain.c + $(CC) $(CFLAGS) -c eclipseCarbonMain.c -o $@ + +eclipseMain.o: ../eclipseUnicode.h ../eclipseCommon.h eclipseMain.c ../eclipseMain.c + $(CC) $(CFLAGS) -c eclipseMain.c -o $@ + +eclipseJNI.o: ../eclipseJNI.c ../eclipseCommon.h ../eclipseOS.h ../eclipseJNI.h + $(CC) $(CFLAGS) -c ../eclipseJNI.c -o $@ + +eclipseUtil.o: ../eclipseUtil.c ../eclipseUtil.h ../eclipseOS.h + $(CC) $(CFLAGS) -c ../eclipseUtil.c -o $@ + +eclipseConfig.o: ../eclipseConfig.c ../eclipseConfig.h ../eclipseOS.h + $(CC) $(CFLAGS) -c ../eclipseConfig.c -o $@ + +eclipseCommon.o: ../eclipseCommon.h ../eclipseUnicode.h ../eclipseCommon.c + $(CC) $(CFLAGS) -c ../eclipseCommon.c -o $@ + +eclipseShm.o: ../eclipseShm.h ../eclipseUnicode.h ../eclipseShm.c + $(CC) $(CFLAGS) -c ../eclipseShm.c -o $@ + +NgCommon.o: ../motif/NgCommon.c + $(CC) $(CFLAGS) -c ../motif/NgCommon.c -o $@ + +NgWinBMPFileFormat.o: ../motif/NgWinBMPFileFormat.c + $(CC) $(CFLAGS) -c ../motif/NgWinBMPFileFormat.c -o $@ + +NgImageData.o: ../motif/NgImageData.c + $(CC) $(CFLAGS) -c ../motif/NgImageData.c -o $@ + +$(EXEC): $(MAIN_OBJS) $(COMMON_OBJS) + $(CC) -o $(EXEC) $(ARCHS) $(MAIN_OBJS) $(COMMON_OBJS) $(LIBS) + +$(DLL): $(DLL_OBJS) $(COMMON_OBJS) + $(CC) -bundle -o $(DLL) $(ARCHS) $(DLL_OBJS) $(COMMON_OBJS) $(LIBS) + +install: all + cp -v $(EXEC) $(PROGRAM_OUTPUT_DIR) + rm -f $(EXEC) $(OBJS) + +clean: + rm -f $(EXEC) $(DLL) $(MAIN_OBJS) $(COMMON_OBJS) $(DLL_OBJS) |