{

char *temp;

uint32_t t_four_char_code;

if (!MCStringConvertToCString(p_string, temp))

return false;

memcpy(&t_four_char_code, temp + p_start, 4);

r_four_char_code = MCSwapInt32HostToNetwork(t_four_char_code);

delete temp;

return true;

{

AEEventClass theEventClass;

AEEventID theEventID;

AEEventHandlerProcPtr theHandler;

AEEventHandlerUPP theUPP;

{

// MW-2013-08-07: [[ Bug 10865 ]] If AppleScript is disabled (secureMode) then

// don't handle the event.

if (!MCSecureModeCanAccessAppleScript())

return errAEEventNotHandled;

OSErr err = errAEEventNotHandled; //class, id, sender

DescType rType;

Size rSize;

AEEventClass aeclass;

AEGetAttributePtr(ae, keyEventClassAttr, typeType, &rType, &aeclass, sizeof(AEEventClass), &rSize);

AEEventID aeid;

AEGetAttributePtr(ae, keyEventIDAttr, typeType, &rType, &aeid, sizeof(AEEventID), &rSize);

if (aeclass == kTextServiceClass)

{

err = errAEEventNotHandled;

return err;

}

//trap for the AEAnswer event, let DoAEAnswer() to handle this event

if (aeclass == kCoreEventClass)

{

if (aeid == kAEAnswer)

return errAEEventNotHandled;

}

AEAddressDesc senderDesc;

//

char *p3val = new char[128];

//char *p3val = new char[kNBPEntityBufferSize + 1]; //sender's address 105 + 1

if (AEGetAttributeDesc(ae, keyOriginalAddressAttr,

typeWildCard, &senderDesc) == noErr)

{

getAddressFromDesc(senderDesc, p3val);

AEDisposeDesc(&senderDesc);

}

else

p3val[0] = '\0';

aePtr = ae; //saving the current AE pointer for use in mcs_request_ae()

MCParameter p1, p2, p3;

MCAutoStringRef s1;

MCAutoStringRef s2;

MCAutoStringRef s3;

/* UNCHECKED */ FourCharCodeToStringRef(aeclass, &s1);

/* UNCHECKED */ MCStringCreateWithCString(p3val, &s3);

p1.setvalueref_argument(*s1);

p1.setnext(&p2);

/* UNCHECKED */ FourCharCodeToStringRef(aeid, &s2);

p2.setvalueref_argument(*s2);

p2.setnext(&p3);

p3.setvalueref_argument(*s3);

/*for "appleEvent class, id, sender" message to inform script that

Exec_stat stat = MCdefaultstackptr->getcard()->message(MCM_apple_event, &p1);

if (stat != ES_PASS && stat != ES_NOT_HANDLED)

{ //if AE is handled by MC

if (stat == ES_ERROR)

{ //error in handling AE in MC

err = errAECorruptData;

if (reply->dataHandle != NULL)

{

int16_t e = err;

AEPutParamPtr(reply, keyReplyErr, typeSInt16, (Ptr)&e, sizeof(short));

}

}

else

{ //ES_NORMAL

if (AEReplyMessage == NULL) //no reply, will return no error code

err = noErr;

else

{

if (reply->descriptorType != typeNull && reply->dataHandle != NULL)

{

MCAutoStringRefAsUTF8String t_reply;

/* UNCHECKED */ t_reply.Lock(AEReplyMessage);

err = AEPutParamPtr(reply, replykeyword, typeUTF8Text, *t_reply, t_reply.Size());

if (err != noErr)

{

int16_t e = err;

AEPutParamPtr(reply, keyReplyErr, typeSInt16, (Ptr)&e, sizeof(short));

}

}

}

MCValueRelease(AEReplyMessage);

AEReplyMessage = NULL;

}

}

else

if (aeclass == kAEMiscStandards

&& (aeid == kAEDoScript || aeid == 'eval'))

{

DescType rType;

Size rSize; //actual size returned

if ((err = AEGetParamPtr(aePtr, keyDirectObject, typeUTF8Text, &rType, NULL, 0, &rSize)) == noErr)

{

byte_t *sptr = new byte_t[rSize + 1];

AEGetParamPtr(aePtr, keyDirectObject, typeUTF8Text, &rType, sptr, rSize, &rSize);

MCExecContext ctxt(MCdefaultstackptr -> getcard(), nil, nil);

MCAutoStringRef t_sptr;

/* UNCHECKED */ MCStringCreateWithBytesAndRelease(sptr, rSize, kMCStringEncodingUTF8, false, &t_sptr);

if (aeid == kAEDoScript)

{

MCdefaultstackptr->getcard()->domess(*t_sptr);

MCAutoValueRef t_value;

MCAutoStringRef t_string;

MCAutoStringRefAsUTF8String t_utf8_string;

/* UNCHECKED */ MCresult->eval(ctxt, &t_value);

/* UNCHECKED */ ctxt . ConvertToString(*t_value, &t_string);

/* UNCHECKED */ t_utf8_string.Lock(*t_string);

AEPutParamPtr(reply, '----', typeUTF8Text, *t_utf8_string, t_utf8_string.Size());

}

else

{

MCAutoValueRef t_val;

MCAutoStringRef t_string;

MCAutoStringRefAsUTF8String t_utf8;

MCdefaultstackptr->getcard()->eval(ctxt, *t_sptr, &t_val);

/* UNCHECKED */ ctxt.ConvertToString(*t_val, &t_string);

/* UNCHECKED */ t_utf8.Lock(*t_string);

AEPutParamPtr(reply, '----', typeUTF8Text, *t_utf8, t_utf8.Size());

}

}

}

else

err = errAEEventNotHandled;

// do nothing if the AE is not handled,

// let the standard AE dispacher to dispatch this AE

delete p3val;

return err;

{ //Apple Event for opening documnets, in our use is to open stacks when user

//double clicked on a MC stack icon

// MW-2013-08-07: [[ Bug 10865 ]] If AppleScript is disabled (secureMode) then

// don't handle the event.

if (!MCSecureModeCanAccessAppleScript())

return errAEEventNotHandled;

AEDescList docList; //get a list of alias records for the documents

errno = AEGetParamDesc(theAppleEvent, keyDirectObject, typeAEList, &docList);

if (errno != noErr)

return errno;

long count;

//get the number of docs descriptors in the list

AECountItems(&docList, &count);

if (count < 1) //if there is no doc to be opened

return errno;

AEKeyword rKeyword; //returned keyword

DescType rType; //returned type

FSRef t_doc_fsref;

Size rSize; //returned size, atual size of the docName

long item;

// get a FSSpec record, starts from count==1

for (item = 1; item <= count; item++)

{

errno = AEGetNthPtr(&docList, item, typeFSRef, &rKeyword, &rType, &t_doc_fsref, sizeof(FSRef), &rSize);

if (errno != noErr)

return errno;

// extract FSSpec record's info & form a file name for MC to use

MCAutoStringRef t_full_path_name;

MCS_mac_fsref_to_path(t_doc_fsref, &t_full_path_name);

if (MCModeShouldQueueOpeningStacks())

{

MCU_realloc((char **)&MCstacknames, MCnstacks, MCnstacks + 1, sizeof(MCStringRef));

MCstacknames[MCnstacks++] = MCValueRetain(*t_full_path_name);

}

else

{

MCStack *stkptr; //stack pointer

if (MCdispatcher->loadfile(*t_full_path_name, stkptr) == IO_NORMAL)

stkptr->open();

}

}

AEDisposeDesc(&docList);

return noErr;

{

// MW-2013-08-07: [[ Bug 10865 ]] If AppleScript is disabled (secureMode) then

// don't handle the event.

if (!MCSecureModeCanAccessAppleScript())

return errAEEventNotHandled;

//process the repy(answer) returned from a server app. When MCS_send() with

// a reply, the reply is handled in this routine.

// This is different from MCS_reply()

//check if there is an error code

DescType rType; //returned type

Size rSize;

/*If the handler returns a result code other than noErr, and if the

if (AEGetParamPtr(ae, keyErrorString, typeUTF8Text, &rType, NULL, 0, &rSize) == noErr)

{

byte_t* t_utf8 = new byte_t[rSize + 1];

AEGetParamPtr(ae, keyErrorString, typeUTF8Text, &rType, t_utf8, rSize, &rSize);

/* UNCHECKED */ MCStringCreateWithBytesAndRelease(t_utf8, rSize, kMCStringEncodingUTF8, false, AEAnswerErr);

}

else

{

int16_t e;

if (AEGetParamPtr(ae, keyErrorNumber, typeSInt16, &rType, (Ptr)&e, sizeof(short), &rSize) == noErr

&& e != noErr)

{

/* UNCHECKED */ MCStringFormat(AEAnswerErr, "Got error %d when sending Apple event", e);

}

else

{

if (AEAnswerData != NULL)

{

MCValueRelease(AEAnswerData);

AEAnswerData = NULL;

}

if ((errno = AEGetParamPtr(ae, keyDirectObject, typeUTF8Text, &rType, NULL, 0, &rSize)) != noErr)

{

if (errno == errAEDescNotFound)

{

AEAnswerData = MCValueRetain(kMCEmptyString);

return noErr;

}

/* UNCHECKED */ MCStringFormat(AEAnswerErr, "Got error %d when receiving Apple event", errno);

return errno;

}

byte_t *t_utf8 = new byte_t[rSize + 1];

AEGetParamPtr(ae, keyDirectObject, typeUTF8Text, &rType, t_utf8, rSize, &rSize);

/* UNCHECKED */ MCStringCreateWithBytesAndRelease(t_utf8, rSize, kMCStringEncodingUTF8, false, AEAnswerData);

}

}

return noErr;

{

int t_error;

t_error = 0;

switch(errno)

{

case kLSUnknownErr:

case kLSNotAnApplicationErr:

case kLSLaunchInProgressErr:

case kLSServerCommunicationErr:

#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1040

case kLSAppInTrashErr:

case kLSIncompatibleSystemVersionErr:

case kLSNoLaunchPermissionErr:

case kLSNoExecutableErr:

case kLSNoClassicEnvironmentErr:

case kLSMultipleSessionsNotSupportedErr:

#endif

t_error = 2;

break;

case kLSDataUnavailableErr:

case kLSApplicationNotFoundErr:

case kLSDataErr:

t_error = 3;

break;

}

switch(t_error)

{

case 0:

MCresult -> clear();

break;

case 1:

MCresult -> sets("can't open file");

break;

case 2:

MCresult -> sets("request failed");

break;

case 3:

MCresult -> sets("no association");

break;

}

{

MCshellfd = fd;

size = 0;

while (True)

{

int readsize = 0;

ioctl(fd, FIONREAD, (char *)&readsize);

readsize += READ_PIPE_SIZE;

if (size + readsize > buffersize)

{

MCU_realloc((char **)&buffer, buffersize,

buffersize + readsize + 1, sizeof(char));

buffersize += readsize;

}

errno = 0;

int4 amount = read(fd, &buffer[size], readsize);

if (amount <= 0)

{

if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)

break;

if (!MCS_poll(SHELL_INTERVAL, 0))

if (!MCnoui && MCscreen->wait(SHELL_INTERVAL, False, True))

{

MCshellfd = -1;

return IO_ERROR;

}

}

else

size += amount;

}

MCshellfd = -1;

return IO_NORMAL;

{

for (uindex_t i = 0; i < ELEMENTS(sysfolderlist); i++)

{

if (MCStringIsEqualTo(p_type, MCNameGetString(*(sysfolderlist[i].token)), kMCStringOptionCompareCaseless))

{

r_folder = sysfolderlist[i].mactag;

r_domain = sysfolderlist[i].domain;

return true;

}

}

return false;

{

int baud = 0;

MCAutoStringRef t_property, t_value;

if (MCStringDivideAtChar(setting, '=', kMCCompareExact, &t_property, &t_value))

{

if (MCStringIsEqualToCString(*t_property, "baud", kMCCompareCaseless))

{

integer_t baudrate;

/* UNCHECKED */ MCStringToInteger(*t_value, baudrate);

if (baudrate == 57600)

baud = B57600;

else if (baudrate == 38400)

baud = B38400;

else if (baudrate == 28800)

baud = B28800;

else if (baudrate == 19200)

baud = B19200;

else if (baudrate == 16600)

baud = B16600;

else if (baudrate == 14400)

baud = B14400;

else if (baudrate == 9600)

baud = B9600;

else if (baudrate == 7200)

baud = B7200;

else if (baudrate == 4800)

baud = B4800;

else if (baudrate == 3600)

baud = B4800;

else if (baudrate == 2400)

baud = B2400;

else if (baudrate == 1800)

baud = B1800;

else if (baudrate == 1200)

baud = B1200;

else if (baudrate == 600)

baud = B600;

else if (baudrate == 300)

baud = B300;

cfsetispeed(theTermios, baud);

cfsetospeed(theTermios, baud);

}

else if (MCStringIsEqualToCString(*t_property, "parity", kMCCompareCaseless))

{

char first;

first = MCStringGetNativeCharAtIndex(*t_value, 0);

if (first == 'N' || first == 'n')

theTermios->c_cflag &= ~(PARENB | PARODD);

else if (first == 'O' || first == 'o')

theTermios->c_cflag |= PARENB | PARODD;

else if (first == 'E' || first == 'e')

theTermios->c_cflag |= PARENB;

}

else if (MCStringIsEqualToCString(*t_property, "data", kMCCompareCaseless))

{

integer_t data;

/* UNCHECKED */ MCStringToInteger(*t_value, data);

switch (data)

{

case 5:

theTermios->c_cflag |= CS5;

break;

case 6:

theTermios->c_cflag |= CS6;

break;

case 7:

theTermios->c_cflag |= CS7;

break;

case 8:

theTermios->c_cflag |= CS8;

break;

}

}

else if (MCStringIsEqualToCString(*t_property, "stop", kMCCompareCaseless))

{

double stopbit;

/* UNCHECKED */ MCStringToDouble(*t_value, stopbit);

if (stopbit == 1.0)

theTermios->c_cflag &= ~CSTOPB;

else if (stopbit == 1.5)

theTermios->c_cflag &= ~CSTOPB;

else if (stopbit == 2.0)

theTermios->c_cflag |= CSTOPB;

}

}

{/****************************************************************************

//initialize to the default setting

struct termios theTermios;

if (tcgetattr(sRefNum, &theTermios) < 0)

{

// TODO: handle error appropriately

}

cfsetispeed(&theTermios, B9600);

theTermios.c_cflag = CS8;

// Split the string on the spaces

MCAutoArrayRef t_settings;

/* UNCHECKED */ MCStringSplit(MCserialcontrolsettings, MCSTR(" "), nil, kMCCompareExact, &t_settings);

uindex_t nsettings = MCArrayGetCount(*t_settings);

for (int i = 0 ; i < nsettings ; i++)

{

// Note: 't_settings' is an array of strings

MCValueRef t_settingval = nil;

/* UNCHECKED */ MCArrayFetchValueAtIndex(*t_settings, i + 1, t_settingval);

MCStringRef t_setting = (MCStringRef)t_settingval;

parseSerialControlStr(t_setting, &theTermios);

}

//configure the serial output device

if (tcsetattr(sRefNum, TCSANOW, &theTermios) < 0)

{

// TODO: handle error appropriately

}

return;

{

UnicodeInfoRecord *next;

TextEncoding encoding;

TextToUnicodeInfo info;

{

static UnicodeInfoRecord *s_records = NULL;

UnicodeInfoRecord *t_previous, *t_current;

for(t_previous = NULL, t_current = s_records; t_current != NULL; t_previous = t_current, t_current = t_current -> next)

if (t_current -> encoding == p_encoding)

break;

if (t_current == NULL)

{

UnicodeMapping t_mapping;

t_mapping . unicodeEncoding = CreateTextEncoding(kTextEncodingUnicodeDefault, kUnicodeNoSubset, kUnicode16BitFormat);

t_mapping . otherEncoding = CreateTextEncoding(p_encoding, kTextEncodingDefaultVariant, kTextEncodingDefaultFormat);

t_mapping . mappingVersion = kUnicodeUseLatestMapping;

TextToUnicodeInfo t_info;

OSErr t_err;

t_err = CreateTextToUnicodeInfo(&t_mapping, &t_info);

if (t_err != noErr)

t_info = NULL;

UnicodeInfoRecord *t_record;

t_record = new UnicodeInfoRecord;

t_record -> next = s_records;

t_record -> encoding = p_encoding;

t_record -> info = t_info;

s_records = t_record;

return t_record -> info;

}

if (t_previous != NULL)

{

t_previous -> next = t_current -> next;

t_current -> next = s_records;

s_records = t_current;

}

return s_records -> info;

{

FSRef t_fsref;

// TODO Check whether the double path resolution is an issue

if (MCS_mac_pathtoref(p_new_path, t_fsref) != noErr)

return; // ignore errors

FSCatalogInfo t_catalog;

if (FSGetCatalogInfo(&t_fsref, kFSCatInfoFinderInfo, &t_catalog, NULL, NULL, NULL) == noErr)

{

// Set the creator and filetype of the catalog.

FourCharCodeFromString(MCfiletype, 4, ((FileInfo *) t_catalog . finderInfo) -> fileType);

FourCharCodeFromString(MCfiletype, 0, ((FileInfo *) t_catalog . finderInfo) -> fileCreator);

FSSetCatalogInfo(&t_fsref, kFSCatInfoFinderInfo, &t_catalog);

}

{

kern_return_t kernResult;

CFMutableDictionaryRef classesToMatch;

if ((kernResult = IOMasterPort(0, masterPort)) != KERN_SUCCESS)

return kernResult;

if ((classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue)) == NULL)

return kernResult;

CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey),

CFSTR(kIOSerialBSDRS232Type));

//kIOSerialBSDRS232Type filters KeySpan USB modems use

//kIOSerialBSDModemType to get 'real' serial modems for OSX

//computers with real serial ports - if there are any!

kernResult = IOServiceGetMatchingServices(*masterPort, classesToMatch,

serialIterator);

return kernResult;

char *dest, uint2 destlen)

{

CFTypeRef nameCFstring;

dest[0] = 0;

nameCFstring = IORegistryEntryCreateCFProperty(sObj,

CFStringCreateWithCString(kCFAllocatorDefault, propName,

kCFStringEncodingASCII),

kCFAllocatorDefault, 0);

if (nameCFstring)

{

CFStringGetCString((CFStringRef)nameCFstring, (char *)dest, (long)destlen,

(unsigned long)kCFStringEncodingASCII);

CFRelease(nameCFstring);

}

{

if (texttoutf8info != nil)

return;

memset(unicodeconvertors, 0, sizeof(unicodeconvertors));

UnicodeMapping ucmapping;

ucmapping.unicodeEncoding = CreateTextEncoding(kTextEncodingUnicodeDefault,

kTextEncodingDefaultVariant,

kUnicodeUTF8Format);

ucmapping.otherEncoding = kTextEncodingMacRoman;

ucmapping.mappingVersion = -1;

CreateTextToUnicodeInfo(&ucmapping, &texttoutf8info);

CreateUnicodeToTextInfo(&ucmapping, &utf8totextinfo);

{

MCAutoStringRefAsUTF8String t_new_path;

/* UNCHECKED */ t_new_path . Lock(p_path);

bool t_found;

struct stat buf;

t_found = (stat(*t_new_path, (struct stat *)&buf) == 0);

if (t_found)

if (S_ISDIR(buf . st_mode))

t_found = false;

return t_found;

{

// If the original file exists, do nothing.

if (p_is_file && MCS_file_exists_at_path(p_path))

return false;

uindex_t t_engine_path_length;

if (!MCStringLastIndexOfChar(MCcmd, '/', UINDEX_MAX, kMCStringOptionCompareExact, t_engine_path_length))

t_engine_path_length = MCStringGetLength(MCcmd);

// If the length of the path is less than the folder prefix of the exe, it

// cannot be inside <bundle>/Contents/MacOS/

if (MCStringGetLength(p_path) < t_engine_path_length)

return false;

// If the prefix of path is not the same as MCcmd up to the folder, it

// cannot be inside <bundle>/Contents/MacOS/

if (!MCStringSubstringIsEqualToSubstring(p_path, MCRangeMake(0, t_engine_path_length), MCcmd, MCRangeMake(0, t_engine_path_length), kMCCompareCaseless))

return false;

// If the final component is not MacOS then it is not inside the relevant

// folder.

if (MCStringGetLength(p_path) != t_engine_path_length &&

MCStringGetCodepointAtIndex(p_path, t_engine_path_length) != '/')

return false;

// Construct the new path from the path after MacOS/ inside Resources/_macos.

MCAutoStringRef t_new_path;

MCRange t_cmd_range = MCRangeMake(0, t_engine_path_length - 6);

uindex_t t_path_end = MCStringGetLength(p_path);

bool t_success = true;

if (MCStringGetCodepointAtIndex(p_path, t_path_end) == '/')

t_path_end--;

if (t_engine_path_length == t_path_end)

{

t_success = MCStringFormat(&t_new_path, "%*@/Resources/_MacOS", &t_cmd_range, MCcmd);

}

else

{

MCRange t_path_range = MCRangeMakeMinMax(t_engine_path_length + 1, t_path_end);

// AL-2014-09-19: Range argument to MCStringFormat is a pointer to an MCRange.

t_success = MCStringFormat(&t_new_path, "%*@/Resources/_MacOS/%*@", &t_cmd_range, MCcmd, &t_path_range, p_path);

}

if (!t_success || (p_is_file && !MCS_file_exists_at_path(*t_new_path)))

return false;

r_redirected = MCValueRetain(*t_new_path);

return true;

{

MCHandler handler(HT_MESSAGE);

switch (sig)

{

case SIGUSR1:

MCsiguser1++;

break;

case SIGUSR2:

MCsiguser2++;

break;

case SIGTERM:

switch (MCdefaultstackptr->getcard()->message(MCM_shut_down_request))

{

case ES_NORMAL:

return;

case ES_PASS:

case ES_NOT_HANDLED:

MCdefaultstackptr->getcard()->message(MCM_shut_down);

MCquit = True; //set MC quit flag, to invoke quitting

return;

default:

break;

}

MCS_killall();

exit(-1);

// MW-2009-01-29: [[ Bug 6410 ]] If one of these signals occurs, we need

// to return, so that the OS can CrashReport away.

case SIGILL:

case SIGBUS:

case SIGSEGV:

{

MCAutoStringRefAsUTF8String t_utf8_MCcmd;

/* UNCHECKED */ t_utf8_MCcmd.Lock(MCcmd);

fprintf(stderr, "%s exiting on signal %d\n", *t_utf8_MCcmd, sig);

MCS_killall();

return;

}

case SIGHUP:

case SIGINT:

case SIGQUIT:

case SIGIOT:

if (MCnoui)

exit(1);

MCabortscript = True;

break;

case SIGFPE:

errno = EDOM;

break;

case SIGCHLD:

MCS_checkprocesses();

break;

case SIGALRM: