static ekRegex * ekRegexCreate(ekContext * E, ekValue * subject, ekValue * pattern, ekValue * options)
{
ekS32 regexFlags = 0;
const char * regexError;
ekS32 regexErrorOffset;
ekRegex * regex = calloc(1, sizeof(ekRegex));
regex->subject = subject;
regex->offset = 0;
regex->global = ekFalse;
if (options) {
const char * c = ekValueSafeStr(options);
for (; *c; c++) {
switch (*c) {
case 'x': regexFlags |= PCRE_EXTENDED; break;
case 'i': regexFlags |= PCRE_CASELESS; break;
case 's': regexFlags |= PCRE_DOTALL; break;
case 'm': regexFlags |= PCRE_MULTILINE; break;
case 'g': regex->global = ekTrue; break;
}
}
}
regex->regex = pcre_compile(ekValueSafeStr(pattern), regexFlags, ®exError, ®exErrorOffset, NULL);
if (!regex->regex) {
// Regex compilation errors are fatal for now. I think this is good.
ekContextSetError(E, EVE_RUNTIME, "regex compilation error: %s", regexError);
ekRegexDestroy(E, regex);
regex = NULL;
}
return regex;
}
static int switchState(struct ekContext *E, ekFile *file, int newState)
{
const char *mode = NULL;
if(file->state == newState)
{
return 0;
}
if(file->permanent)
{
ekContextSetError(E, EVE_RUNTIME, "attempting to change file state on a permanent file: file.%s", ekValueSafeStr(file->filename));
return 0; // never change the state on a permanent file!
}
if(file->handle)
{
fclose(file->handle);
file->handle = NULL;
}
switch(newState)
{
case EFS_CLOSED:
// do nothing, we already closed it
break;
case EFS_READ:
mode = "rb";
break;
case EFS_WRITE:
mode = "wb";
break;
case EFS_APPEND:
mode = "ab";
break;
}
if(mode)
{
file->handle = fopen(ekValueSafeStr(file->filename), mode);
}
file->state = newState;
return 1;
}
struct ekValue *ekValueTypeGetIntrinsic(struct ekContext *E, ekU32 type, struct ekValue *index, ekBool lvalue)
{
ekMap *map = E->types[type]->intrinsics;
if(map && index && (index->type == EVT_STRING))
{
ekMapEntry *mapEntry = ekMapGetS(E, map, ekValueSafeStr(index), ekFalse);
if(mapEntry && mapEntry->valuePtr)
{
if(lvalue)
{
ekContextSetError(E, EVE_RUNTIME, "cannot use intrinsic %s function as an lvalue", ekValueTypeName(E, type));
}
else
{
return ekValueCreateCFunction(E, mapEntry->valuePtr);
}
}
}
return NULL;
}
static struct ekValue * floatFuncArithmetic(struct ekContext * E, struct ekValue * a, struct ekValue * b, ekValueArithmeticOp op)
{
b = ekValueToFloat(E, b);
switch (op) {
case EVAO_ADD:
a = ekValueCreateFloat(E, a->floatVal + b->floatVal);
break;
case EVAO_SUB:
a = ekValueCreateFloat(E, a->floatVal - b->floatVal);
break;
case EVAO_MUL:
a = ekValueCreateFloat(E, a->floatVal * b->floatVal);
break;
case EVAO_DIV:
if (b->floatVal == 0.0f) {
ekContextSetError(E, EVE_RUNTIME, "divide by zero!");
} else {
a = ekValueCreateFloat(E, a->floatVal / b->floatVal);
}
break;
}
return a;
}
static struct ekValue * intFuncArithmetic(struct ekContext * E, struct ekValue * a, struct ekValue * b, ekValueArithmeticOp op)
{
ekValue * c = NULL;
b = ekValueToInt(E, b);
switch (op) {
case EVAO_ADD:
c = ekValueCreateInt(E, a->intVal + b->intVal);
break;
case EVAO_SUB:
c = ekValueCreateInt(E, a->intVal - b->intVal);
break;
case EVAO_MUL:
c = ekValueCreateInt(E, a->intVal * b->intVal);
break;
case EVAO_DIV:
if (!b->intVal) {
ekContextSetError(E, EVE_RUNTIME, "divide by zero!");
} else {
c = ekValueCreateInt(E, a->intVal / b->intVal);
}
break;
}
return c;
}