methods.cpp

GNU ccScript is a C++ class framework for creating a virtual machine execution system for use with a

bool ScriptMethods::scrThrow(void)
{
	const char *cp = getOption(NULL);

	if(!cp)
	{
		error("throw-target-missing");
		return true;
	}

	if(!scriptEvent(++cp))
		advance();
	return true;
}

bool ScriptMethods::scrGoto(void)
{
	unsigned argc = 0;
	Line *line = getLine();
	const char *var, *value;

	while(argc < line->argc)
	{
		var = line->args[argc++];
		if(*var != '=')
			continue;

		++var;
		value = getContent(line->args[argc++]);
		if(!value)
			continue;

		setSymbol(var, value, 0);
	}

	return intGoto();
}

bool ScriptMethods::intGoto(void)
{
	frame[stack].tranflag = false;
	if(image->isRipple() && frame[stack].local == NULL)
	{
		ripple();
		return true;
	}
	return redirect(true);
}

bool ScriptMethods::scrRestart(void)
{
	clearStack();
	branching();

	frame[stack].caseflag = frame[stack].tranflag = false;
	frame[stack].line = frame[stack].first = frame[stack].script->first;
	frame[stack].index = 0;
	if(isFunction(frame[stack].script))
                frame[stack].tranflag = true;

	return true;
}

bool ScriptMethods::scrTimer(void)
{
	const char *err = NULL;
	Symbol *sym;
	time_t now;
	const char *cp;
	const char *off = getKeyword("offset");
	const char *exp = getKeyword("expires");

	time(&now);

	while(NULL != (cp = getOption(NULL)))
	{
		sym = mapSymbol(cp, 23);		
		if(!sym)
		{
err:
			err = "timer-symbol-invalid";
			continue;
		}
		if(sym->type == symINITIAL && sym->size > 22)
			goto set;
		if(sym->type == symTIMER)
			goto set;
		goto err;
set:
		snprintf(sym->data, 12, "%ld", now);
		sym->type = symTIMER;
		if(off)
			commit(sym, off);
		else if(exp && atol(exp) > 0)
			commit(sym, exp);
		else if(exp)
			sym->data[0] = 0;
	}
	if(err)
		error(err);
	else
		skip();
	return true;
}

bool ScriptMethods::scrCounter(void)
{
	unsigned long lval = 0;
	const char *err = NULL;
	const char *cp = getMember();
	Symbol *sym;

	if(cp)
		lval = atol(cp) - 1;

	while(NULL != (cp = getOption(NULL)))
	{
		sym = mapSymbol(cp, 11);		
		if(!sym)
		{
			err = "var-symbol-invalid";
			continue;
		}
		if(sym->type != symINITIAL)
		{
			err = "var-already-defined";
			continue;
		}
		snprintf(sym->data, sym->size + 1, "%ld", lval);
		sym->type = symCOUNTER;
	}
	if(err)
		error(err);
	else
		skip();
	return true;
}

bool ScriptMethods::scrSession(void)
{
	const char *cp = getValue(NULL);
	ScriptInterp *interp;

	if(!cp)
	{
		session = this;
		skip();
		return true;
	}

	interp = getInterp(cp);
	if(interp)
	{
		session = interp;
		skip();
	}
	else
		error("session-invalid-id");
	
	return true;
}

bool ScriptMethods::scrLock(void)
{
	Symbol *sym;
	const char *cp = getOption(NULL);
	ScriptInterp *locker = NULL;
	unsigned long lockseq;
	char evtname[65];

	sym = mapSymbol(cp, 23);
	if(!sym)
	{
		error("lock-symbol-undefined");
		return true;
	}
	if(sym->type == symLOCK)
	{
		cp = strchr(sym->data, ':');
		if(cp)
		{
			locker = getInterp(++cp);
			lockseq = atol(sym->data);
		}
		if(locker && locker == this && lockseq == sequence)
			return true;
		if(locker && locker->getSequence() == lockseq)
		{
			snprintf(evtname, sizeof(evtname), "locked:%s", sym->id);
			if(scriptEvent(evtname))
				return true;
			error("lock-symbol-locked");
			return true;
		}
		sym->type = symINITIAL;
	}
	if(sym->size != 23 || sym->type != symINITIAL)
	{
		error("lock-symbol-invalid");
		return true;
	}
	snprintf(sym->data, sym->size + 1, "%ld:%u", sequence, getId());
	sym->type = symLOCK;
	skip();
	return true;
}

bool ScriptMethods::scrPack(void)
{
	char pack = getPackToken();
	const char *prefix = getKeyword("prefix");
	const char *suffix = getKeyword("suffix");
	const char *cp = getKeyword("token");
	const char *q = getKeyword("quote");
	Symbol *sym;
	unsigned size = symsize;
	char buffer[1024], tokbuf[2];
	ScriptProperty *p;
	bool unpack = false;
	Line *line = getLine();
	char *lp = buffer, *ep;
	unsigned offset = 0;

	if(!stricmp(line->cmd, "unpack"))
		unpack = true;

	if(q && !*q)
		q = NULL;

	if(cp && *cp)
		pack = *cp;

	cp = getKeyword("offset");
	if(!cp)
		cp = getKeyword("field");
	if(cp)
		offset = atoi(cp);

	cp = getKeyword("size");
	if(cp)
		size = atoi(cp);

	cp = getOption(NULL);
	if(unpack)
		sym = mapSymbol(cp);
	else
		sym = mapSymbol(cp, size);

	if(!sym)
	{
		error("symbol-invalid");
		return true;
	}

	if(sym->type == symPROPERTY)
	{
		memcpy(&p, &sym->data, sizeof(p));
		if(p->token())
			pack = p->token();
	}

	tokbuf[0] = 0;
	buffer[0] = 0;

	if(!unpack && prefix)
		setString(buffer, sizeof(buffer), prefix);

	if(unpack)
	{
		cp = extract(sym);
		if(prefix && !strnicmp(cp, prefix, strlen(prefix)))
			cp += strlen(prefix);
		if(cp && *cp)
			setString(buffer, sizeof(buffer), cp);
		else
		{
			skip();
			return true;
		}
		if(suffix && !stricmp(buffer + strlen(buffer) - strlen(suffix), suffix))
			buffer[strlen(buffer) - strlen(suffix)] = 0;

		if(!q)
		{
			if(*lp == '\'')
				q = "'";
			else if(*lp == '"')
				q = "\"";
		}
	}			

	while(unpack && NULL != (cp = getOption(NULL)))
	{
		if(offset)
		{
			sym = NULL;
			--offset;
		}
		else
		{
			sym = mapSymbol(cp, size);
			if(!sym)
			{
				error("symbol-missing");
				return true;
			}
		}
		
		if(*lp == pack)
		{
			commit(sym, "");
			++lp;
			continue;
		}
		
		if(q && !strnicmp(lp, q, strlen(q)))
		{
			lp += strlen(q);
			ep = strstr(lp, q);
			if(!ep)
				ep = lp + strlen(lp);
			else
			{
				*ep = 0;
				ep += strlen(q);
			}
			commit(sym, lp);
			if(*ep == pack)
				++ep;
			if(!*ep)
				break;
			lp = ep;
			continue;
		}
		ep = strchr(lp, pack);
		if(ep)
			*(ep++) = 0;
		if(sym)
			commit(sym, lp);
		if(!ep || !*ep)
			break;
		lp = ep;
	}
				
	while(!unpack)
	{
		if(offset)
		{
			cp = "";
			--offset;
		}
		else
			cp = getValue(NULL);

		if(!cp)
			break;
		if(tokbuf[0])
			addString(buffer, sizeof(buffer), tokbuf);
		tokbuf[0] = pack;
		tokbuf[1] = 0;
		if(q)
			addString(buffer, sizeof(buffer), q);
		addString(buffer, sizeof(buffer), cp);
		if(q)
			addString(buffer, sizeof(buffer), q);
	}
	
	if(!unpack)
	{
		if(suffix)
			addString(buffer, sizeof(buffer), suffix);

		if(!commit(sym, buffer))
		{
			error("symbol-not-packable");
			return true;
		}
	}

	skip();
	return true;
}		

bool ScriptMethods::scrClear(void)
{
	const char *cp;
	Symbol *sym;
	const char *err = NULL;
	ScriptInterp *locker;
	unsigned long lockseq;

	while(NULL != (cp = getOption(NULL)))
	{
		sym = mapSymbol(cp, 0);
		if(!sym)
		{
			err = "clear-symbol-undefined";
			continue;
		}
		if(sym->type == symLOCK)
		{
			locker = NULL;
			cp = strchr(sym->data, ':');
			if(cp)
				locker = getInterp(++cp);
			lockseq = atol(sym->data);
			if(locker && locker != this && lockseq == locker->getSequence())
			{
				err = "clear-symbol-locked";
				continue;
			}
		}
		clear(sym);
	}
	if(err)
		error(err);
	else
		skip();
	return true;
}

bool ScriptMethods::scrType(void)
{
	Symbol *tsym, temp, *sym;
	const char *cp = getOption(NULL);

	tsym = mapSymbol(cp, 0);
	if(!tsym)
	{
		error("symtype-missing");
		return true;
	}

	while(NULL != (cp = getOption(NULL)))
	{
		sym = mapSymbol(cp, tsym->size);
		if(!sym)
			continue;

		if(sym->type != symINITIAL && sym->type != tsym->type)
			continue;

		if(sym->size != tsym->size)
			continue;

		temp.id = sym->id;
		temp.next = sym->next;

		memcpy(sym, tsym, sizeof(Symbol) + tsym->size);
		sym->id = temp.id;
		sym->next = temp.next;
	}

	advance();
	return true;
}

bool ScriptMethods::scrDefine(void)
{
	char var[128];
	char base[65];
        Symbol *sym;
        const char *cp, *pv;
        const char *prefix = getMember();
        unsigned len;
	char *ep;
	Line *line = getLine();
	Name *scr = getName();
	unsigned idx = 0, vlen;

	if(!prefix && !frame[stack].local)
	{
		setString(base, sizeof(base), scr->name);
		ep = strchr(base, ':');
		if(ep)
			*ep = 0;
		prefix = base;
	}

	while(idx < line->argc)
	{
		pv = NULL;
		cp = line->args[idx++];
		if(*cp == '=')
		{
			pv = line->args[idx++];
			++cp;
			if(*pv == '{')
				++pv;
		}
		
		if(prefix && !strchr(cp, '.') && *cp != '%' && *cp != '&')
	                snprintf(var, sizeof(var), "%s.%s", prefix, cp);
		else
			setString(var, sizeof(var), cp);

                ep = strrchr(var, ':');
                if(ep)
                {
                        *(ep++) = 0;
                        len = atoi(ep);
                }
		else if(pv)
			len = 0;
		else
			len = symsize;

		if(!pv)
			pv = "";

		if(!len)
			vlen = (unsigned)strlen(pv);
		else
			vlen = len;

		if(!vlen)
			++vlen;

                sym = mapSymbol(var, vlen);
		if(!sym || sym->type != symINITIAL)
			continue;

		setString(sym->data, sym->size + 1, pv);
		if(len)
			sym->type = symNORMAL;
		else
			sym->type = symCONST;

	}
	advance();
	return true;
}

bool ScriptMethods::scrVar(void)
{
	unsigned short size = symsize;
	const char *cp = getMember();
	Symbol *sym;
	char *errmsg = NULL;
	Line *line = getLine();
	const char *value = getKeyword("value");

	if(!stricmp(line->cmd, "char"))
		size = 1;

	if(cp)
		size = atoi(cp);

	cp = getKeyword("size");
	if(cp)
		size = atoi(cp);

	while(NULL != (cp = getOption(NULL)))
	{
		sym = mapSymbol(cp, size);
		if(!sym)
		{
			errmsg = "var-symbol-invalid";
			continue;
		}

		if(sym->type != symINITIAL || sym->size != size)
		{
			errmsg = "var-already-defined";
			continue;
		}
		if(value)
			commit(sym, value);
	}

	if(errmsg)
		error(errmsg);
	else
		skip();	

	return true;
}

bool ScriptMethods::scrExpr(void)
{
	unsigned prec = 0;
	Symbol *sym;
	const char *mem = getMember();
	const char *opt;
	ScriptProperty *prop = NULL;
	long iNumber, hNumber, lNumber;
	char result[20];
	char presult[65];
	char fmt[13];
	unsigned len;
	Array *a;

	if(mem)
	{
		prop = ScriptProperty::find(mem);
		prec = atoi(mem);
		if(prop)
			prec = prop->prec();
	}

	while(NULL != (opt = getOption(NULL)))
	{
		if(!stricmp(opt, "-eq"))
			break;

		if(*opt == '%' || *opt == '&' || *opt == '@')
		{
			sym = mapSymbol(opt, 0);
			if(!sym)
			{
				error("expr-sym-undefined");
				return true;
			}
			if(sym->type == symNUMBER && !prec && !prop && sym->size > 11)
				prec = sym->size - 12;
			continue;
		}
		
		error("expr-invalid");
		return true;
	}
	if(!opt)
	{
		error("expr-missing");
		return true;
	}

	if(!prec)
		prec = frame[stack].decimal;

	if(numericExpression(&iNumber, 1, prec, prop) != 1)
	{
		error("expr-invalid");
		return true;
	}
	
	snprintf(fmt, sizeof(fmt), "%s%d%s", "%ld.%0", prec, "ld");
	frame[stack].index = 0;
	hNumber = iNumber / tens[prec];
	lNumber = iNumber % tens[prec];
	if(lNumber < 0)
		lNumber = -lNumber;
	if(prec)
		snprintf(result, sizeof(result), fmt, hNumber, lNumber);
	else
		snprintf(result, sizeof(result), "%ld", iNumber);

	while(NULL != (opt = getOption(NULL)))
	{
		if(!stricmp(opt, "-eq"))
			break;

		sym = mapSymbol(opt, 0);

		if(!sym)
			continue;

		if(sym->type == symNUMBER || !prop)
		{
			if(!commit(sym, result))
			{
				error("expr-cannot-assign");
				return true;
			}	
			continue;
		}
		
		a = (Array *)&sym->data;
		switch(sym->type)
		{
		case symINITIAL:
			sym->type = symNORMAL;
		case symNORMAL:
		case symPROPERTY:
			prop->setValue(sym->data, sym->size, iNumber);
			break;
		case symARRAY:
		case symSTACK:
		case symFIFO:
			len = a->rec;
			if(len >= sizeof(presult))
				len = sizeof(presult) - 1;
			prop->setValue(presult, len, iNumber);
			commit(sym, presult);
		default:
			error("expr-cannot-assign");
			return true;
		}				
	}
	skip();
	return true;
}

bool ScriptMethods::scrIndex(void)
{
	Symbol *sym;
	const char *opt;
	long iNumber;

	while(NULL != (opt = getOption(NULL)))
	{
		if(!stricmp(opt, "-eq"))
			break;

		if(*opt == '%' || *opt == '&' || *opt == '@')
		{
			sym = mapSymbol(opt, 0);
			if(!sym)
			{
				error("index-sym-undefined");
				return true;
			}
			switch(sym->type)
			{
			case symARRAY:
			case symFIFO:
			case symSTACK:
				break;
			default:
				error("index-not-array");
				return true;
			}
			continue;
		}
		
		error("index-invalid");
		return true;
	}
	if(!opt)
	{
		error("index-expr-missing");
		return true;
	}

	if(numericExpression(&iNumber, 1, 0, NULL) != 1)
	{
		error("index-invalid");
		return true;
	}
	
	while(NULL != (opt = getOption(NULL)))
	{
		if(!stricmp(opt, "-eq"))
			break;

		sym = mapSymbol(opt, 0);

		if(!sym)
			continue;

		if(iNumber > 0)
			--iNumber;

		symindex(sym, (short)iNumber);
	}
	skip();
	return true;
}

bool ScriptMethods::scrNumber(void)
{
	unsigned short size = 11;
	const char *cp = getMember();
	Symbol *sym;
	char *errmsg = NULL;
	Line *line = getLine();

	if(!strnicmp(line->cmd, "num", 3) && frame[stack].decimal)
		size = 12 + frame[stack].decimal;