예제 #1
0
파일: NewtFns.c 프로젝트: pablomarx/NEWT0
newtRef NcSetArraySlot(newtRefArg r, newtRefArg p, newtRefArg v)
{
    if (! NewtRefIsInteger(p))
        return NewtThrow(kNErrNotAnInteger, p);

    return NewtSetArraySlot(r, NewtRefToInteger(p), v);
}
예제 #2
0
파일: NewtEnv.c 프로젝트: morgant/NEWT0
newtRef NsDefMagicPointer(newtRefArg rcvr, newtRefArg r, newtRefArg v)
{
	int32_t	table = 0;
	int32_t	index;

	if (NewtRefIsNumberedMP(r))
	{
		table = NewtMPToTable(r);
		index = NewtMPToIndex(r);

		if (table != 0)
		{	// テーブル番号 0 以外は未サポート
			return kNewtRefUnbind;
		}
	}
	else if (NewtRefIsInteger(r))
	{
		index = NewtRefToInteger(r);
	}
	else
	{
#ifdef __NAMED_MAGIC_POINTER__
		return NsDefNamedMP(rcvr, r, v);
#else
		return kNewtRefUnbind;
#endif
	}

	if (NewtLength(MAGIC_POINTERS) <= index)
	{	// テーブルの長さを拡張
		NewtSetLength(MAGIC_POINTERS, index + 1);
	}

	return NewtSetArraySlot(MAGIC_POINTERS, index, v);
}
예제 #3
0
파일: NewtEnv.c 프로젝트: morgant/NEWT0
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));
}
예제 #4
0
파일: protoREGEX.c 프로젝트: da4089/NEWT0
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;
}