newtRef NewtObjClassOf(newtRefArg r)
{
newtObjRef obj;
newtRefVar klass = kNewtRefNIL;
obj = NewtRefToPointer(r);
if (obj != NULL)
{
if (NewtObjIsFrame(obj))
{
// klass = NewtObjGetSlot(obj, NS_CLASS);
klass = NcProtoLookup(r, NS_CLASS);
if (NewtRefIsNIL(klass))
klass = NSSYM0(frame);
}
else
{
klass = obj->as.klass;
if (klass == kNewtSymbolClass)
klass = NSSYM0(symbol);
else if (NewtRefIsNIL(klass))
klass = NewtRefTypeToClass(NewtGetObjectType(obj, true));
}
}
return klass;
}
newtRef protoREGEX_match(newtRefArg rcvr, newtRefArg str)
{
newtRefVar preg;
newtRefVar r;
if (NewtRefIsNIL(rcvr))
return kNewtRefUnbind;
NcSetSlot(rcvr, NSSYM(_matchs), kNewtRefNIL);
preg = NcGetSlot(rcvr, NSSYM(_preg));
if (NewtRefIsNIL(preg))
{
protoREGEX_compile(rcvr);
preg = NcGetSlot(rcvr, NSSYM(_preg));
if (NewtRefIsNIL(preg))
return kNewtRefNIL;
}
r = protoREGEX_regexec(preg, str);
NcSetSlot(rcvr, NSSYM(_matchs), r);
return r;
}
/** Call a function with an array of parameters
*
* @param rcvr [in] レシーバ
* @param func [in] Function
* @param params [in] Parameters
*
* @return Return value
*/
newtRef NsApply(newtRefArg rcvr, newtRefArg func, newtRefArg params)
{
if (! NewtRefIsFunction(func))
{
return NewtThrow(kNErrNotAFunction, func);
}
newtRef ary = NewtRefIsNIL(params) ? NewtMakeArray(kNewtRefUnbind, 0) : params;
return NcCallWithArgArray(func, ary);
}
newtRef protoREGEX_compile(newtRefArg rcvr)
{
newtRefVar preg;
if (NewtRefIsNIL(rcvr))
return kNewtRefUnbind;
preg = protoREGEX_regcomp(NcGetSlot(rcvr, NSSYM(pattern)), NcGetSlot(rcvr, NSSYM(option)));
return NcSetSlot(rcvr, NSSYM(_preg), preg);
}
newtRef NsSubStr(newtRefArg rcvr, newtRefArg r, newtRefArg start, newtRefArg count)
{
char* theString;
char* theBuffer;
int theStart, theEnd;
size_t theLen;
newtRefVar theResult;
(void) rcvr;
/* check parameters */
if (! NewtRefIsString(r))
return NewtThrow(kNErrNotAString, r);
if (! NewtRefIsInteger(start))
return NewtThrow(kNErrNotAnInteger, start);
theString = NewtRefToString(r);
theLen = strlen(theString);
theStart = NewtRefToInteger(start);
if (!NewtRefIsNIL(count))
{
if (!NewtRefIsInteger(count))
{
return NewtThrow(kNErrNotAnInteger, count);
}
theEnd = theStart + NewtRefToInteger(count);
if (theEnd > theLen)
{
return NewtThrow(kNErrOutOfRange, count);
}
} else {
theEnd = theLen;
}
/* new length */
theLen = theEnd - theStart;
/* create a buffer to copy the characters to */
theBuffer = (char*) malloc(theLen + 1);
(void) memcpy(theBuffer, (const char*) &theString[theStart], theLen);
theBuffer[theLen] = 0;
theResult = NewtMakeString(theBuffer, false);
free(theBuffer);
return theResult;
}
void NewtInitARGV(int argc, const char * argv[], int n)
{
newtRefVar exepath = kNewtRefUnbind;
newtRefVar r;
uint16_t j;
uint16_t i;
r = NewtMakeArray(kNewtRefUnbind, argc - n);
NcSetSlot(GLOBALS, NSSYM0(_ARGV_), r);
for (i = n, j = 0; i < argc; i++, j++)
{
NewtSetArraySlot(r, j, NewtMakeString(argv[i], true));
}
#ifdef __WIN32__
{
char sep;
sep = NewtGetFileSeparator();
if (sep != '\\')
{
char * path;
path = strdup(argv[0]);
if (path)
{
replacechr(path, '\\', sep);
exepath = NewtExpandPath(path);
free(path);
}
else
{
exit(errno);
}
}
}
#endif
if (NewtRefIsNIL(exepath))
exepath = NewtExpandPath(argv[0]);
NcSetSlot(GLOBALS, NSSYM0(_EXEDIR_), NcDirName(exepath));
}
newtRef protoREGEX_cleanup(newtRefArg rcvr)
{
newtRefVar preg;
if (NewtRefIsNIL(rcvr))
return kNewtRefUnbind;
NcSetSlot(rcvr, NSSYM(_matchs), kNewtRefNIL);
preg = NcGetSlot(rcvr, NSSYM(_preg));
if (NewtRefIsNotNIL(preg))
{
protoREGEX_regfree(preg);
NcSetSlot(rcvr, NSSYM(_preg), kNewtRefNIL);
}
return kNewtRefNIL;
}
newtRef protoREGEX_regexec(newtRefArg preg, newtRefArg str)
{
newtRefVar substr;
newtRefVar r;
regmatch_t pmatch[10];
size_t nmatch;
char * src;
int eflags = 0;
int err;
int i;
if (NewtRefIsNIL(str))
return kNewtRefNIL;
if (! protoREGEX_refIsPreg(preg))
return kNewtRefUnbind;
if (! NewtRefIsString(str))
return NewtThrow(kNErrNotAString, str);
nmatch = sizeof(pmatch) / sizeof(regmatch_t);
src = NewtRefToString(str);
err = regexec((regex_t*)NewtRefToBinary(preg), src, nmatch, pmatch, eflags);
if (err != 0)
return kNewtRefNIL;
r = NewtMakeArray(kNewtRefUnbind, nmatch);
for (i = 0; i < nmatch; i++)
{
if (pmatch[i].rm_so != -1)
{
substr = NewtMakeString2(src + pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so, false);
NewtSetArraySlot(r, i, substr);
}
}
return r;
}
/** Send a message to a method in a frame by name with an array of parameters, if it is defined (proto inheritance only)
*
* @param rcvr [in] レシーバ
* @param frame [in] Frame
* @param message [in] Message
* @param params [in] Parameters
*
* @return Return value
*/
newtRef NsProtoPerformIfDefined(newtRefArg rcvr, newtRefArg frame, newtRefArg message, newtRefArg params)
{
newtRef ary = NewtRefIsNIL(params) ? NewtMakeArray(kNewtRefUnbind, 0) : params;
return NcSendProtoWithArgArray(frame, message, true, ary);
}
/** Send a message to a method in a frame by name with an array of parameters
*
* @param rcvr [in] レシーバ
* @param frame [in] Frame
* @param message [in] Message
* @param params [in] Parameters
*
* @return Return value
*/
newtRef NsPerform(newtRefArg rcvr, newtRefArg frame, newtRefArg message, newtRefArg params)
{
newtRef ary = NewtRefIsNIL(params) ? NewtMakeArray(kNewtRefUnbind, 0) : params;
return NcSendWithArgArray(frame, message, false, ary);
}
