Ejemplo n.º 1
0
RML_END_LABEL


RML_BEGIN_LABEL(External__getFirstIdent)
{
	rml_uint_t len = RML_HDRSTRLEN(RML_GETHDR(rmlA0)); /* string lenght */
	rml_uint_t newlen = 0;
	int index = 1, i=0;
	char *str = RML_STRINGDATA(rmlA0);
	if (!isalpha(str[0])) RML_TAILCALLK(rmlFC); /* fail if we don't start with alpha */
	while((isalpha(str[index]) ||
		  (str[index] >= '0' && str[index] <= '9')) &&
		  index < len) index++;
	/* alloc the new string */
	struct rml_string *strnew = rml_prim_mkstring(index, 3);
	str = RML_STRINGDATA(rmlA0);
	unsigned char *snew = (unsigned char*)strnew->data;
	for(i=0; i < index; i++)
	{
		*snew++ = str[i];
	}
	*snew = '\0';
	rmlA0 = RML_TAGPTR(strnew);
	RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 2
0
RML_END_LABEL

RML_BEGIN_LABEL(External__startsWith)
{
    char *str1 = RML_STRINGDATA(rmlA0);
	char *str2 = RML_STRINGDATA(rmlA1);
	int i = 0;
	rml_uint_t len1 = RML_HDRSTRLEN(RML_GETHDR(rmlA0)); /* string lenght1 */
	rml_uint_t len2 = RML_HDRSTRLEN(RML_GETHDR(rmlA1)); /* string lenght1 */
	/* if the second one is longer than the first we return false */
	if (len2 > len1)
	{
		rmlA0 = RML_FALSE;
		RML_TAILCALLK(rmlSC);
	}

	for (; i < len2; i++)
	if (str1[i] != str2[i])
	{
		rmlA0 = RML_FALSE;
		RML_TAILCALLK(rmlSC);
	}
	/* else, everything is dandy */
	rmlA0 = RML_TRUE;
	RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 3
0
RML_END_LABEL


RML_BEGIN_LABEL(External__strrpl)
{
	rml_uint_t len1 = RML_HDRSTRLEN(RML_GETHDR(rmlA0)); /* string lenght */
	rml_uint_t len2 = RML_HDRSTRLEN(RML_GETHDR(rmlA1)); /* string lenght */
	rml_uint_t len3 = RML_HDRSTRLEN(RML_GETHDR(rmlA2)); /* string lenght */
	char *str1 = RML_STRINGDATA(rmlA0);
	char *str2 = RML_STRINGDATA(rmlA1);
	char *str3 = RML_STRINGDATA(rmlA2);
	char *strpos;
	if (len1 == 0 || len2==0)
	{
		rmlA0 = rmlA0; /* return the first string unchanged */
		RML_TAILCALLK(rmlSC);
	}
	if ((strpos = strstr(str1, str2)) == NULL) /* the string is not there */
	{
		rmlA0 = rmlA0; /* return the first string unchanged */
		RML_TAILCALLK(rmlSC);
	}
	else
	{
		/* string is there */
		rml_uint_t len = len1-len2+len3;
		/* find where */
		rml_uint_t pos = (int)(strpos - str1);
		/* alloc the new string */
		struct rml_string *strnew = rml_prim_mkstring(len, 3);
		int i, j, k;
		/* reread the rmlAX, it could have been moved by the GC */
		str1 = RML_STRINGDATA(rmlA0);
		str2 = RML_STRINGDATA(rmlA1);
		str3 = RML_STRINGDATA(rmlA2);
		unsigned char *snew = (unsigned char*)strnew->data;
		/* until pos, use the first string */
		for(i=0; i < pos; i++)
		{
			*snew++ = str1[i];
		}
		/* now use str3 */
		for(i=0; i < len3; i++)
		{
			*snew++ = str3[i];
		}
		/* until end, use the first string again */
		for(i=pos+len2; i < len1; i++)
		{
			*snew++ = str1[i];
		}
		*snew = '\0';
		rmlA0 = RML_TAGPTR(strnew);
		RML_TAILCALLK(rmlSC);
	}
}
Ejemplo n.º 4
0
RML_END_LABEL


RML_BEGIN_LABEL(External__toJavaName)
{
    void *a0 = rmlA0;
    char *str = RML_STRINGDATA(a0);
	int i = 0;
	int j = 1;
	rml_uint_t len = RML_HDRSTRLEN(RML_GETHDR(rmlA0)); /* string lenght */
	if (len < 1) RML_TAILCALLK(rmlSC);
    /* check if are all caps or "_"
	 * if they are, do nothing!
	 */
	for (; i < len;)
    if (str[i] != '_' && str[i] != toupper(str[i]))
		break;
	else i++;
	if (i==len) RML_TAILCALLK(rmlSC); /* all caps or "_"; return the same */
	i = 1;
	char *newstr = (char*)malloc(len+1);
	newstr[0] = tolower(str[0]); /* make the first one lowercase */
	char *freeme = newstr;
	for (; i < len;)
	if (str[i] != '_')
	{
		newstr[j++] = str[i];
		i++;
	}
	else /* is equal */
	{
       if (i+1 < len)
	   {
		    newstr[j++]=toupper(str[i+1]);
			i += 2;
	   }
	   else
	   {
			newstr[j++] = str[i];
			i++;
	   }
	}
	newstr[j] = '\0';
	len = strlen(newstr);
	/* alloc the new string */
	struct rml_string *strnew = rml_prim_mkstring(len, 1);
	unsigned char *snew = (unsigned char*)strnew->data;
	for(; len > 0; --len)
		*snew++ = *newstr++;
	*snew = '\0';
	rmlA0 = RML_TAGPTR(strnew);
	free(freeme);
	RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 5
0
RML_END_LABEL


RML_BEGIN_LABEL(External__sst)
{
	char *s;
	char *str = strdup(RML_STRINGDATA(rmlA0));
	char *delimit = RML_STRINGDATA(rmlA1);
	char *separator = RML_STRINGDATA(rmlA2);
	char *strTmp1 = 0;
	char *strTmp2 = 0;
	int i;
	rml_uint_t lenseparator = strlen(separator);
	rml_uint_t len1 = 0;
	rml_uint_t len2 = 0;
	rml_uint_t len = 0;

	void * res = (void*)mk_nil();
	s=strtok(str,delimit);
	if (s == NULL)
	{
			/* adrpo added 2004-10-27 */
			free(str);
			rmlA0=res; RML_TAILCALLK(rmlFC);
	}
	strTmp1 = strdup(s); /* first token */
	while (s=strtok(NULL,delimit))
	{
		len1 = strlen(strTmp1);
		len2 = strlen(s);
		len = len1+lenseparator+len2;
		strTmp2 = (char*)malloc(len+1);
		strTmp2[0] = '\0';
		strncat(strTmp2,strTmp1,len1);
		strncat(strTmp2,separator,lenseparator);
		strncat(strTmp2,s,len2);
		strTmp2[len] = '\0';
		free(strTmp1);
		strTmp1 = strTmp2;
	}
	/* now we have everything in strTmp2 */
	/* now alloc the new string */
	struct rml_string *strnew = rml_prim_mkstring(len, 3);
	unsigned char *snew = (unsigned char*)strnew->data;
	for(i=0; i < len; i++)
	{
		*snew++ = strTmp2[i];
	}
	*snew = '\0';
	free(strTmp2);
	rmlA0 = RML_TAGPTR(strnew);
	RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 6
0
RML_END_LABEL

/* list-nth.c */
RML_BEGIN_LABEL(RML__list_5fnth)
{
    rml_sint_t i = RML_UNTAGFIXNUM(rmlA1);
    void *lst = rmlA0;
    for(; RML_GETHDR(lst) == RML_CONSHDR; --i, lst = RML_CDR(lst)) {
	if( i == 0 ) {
	    rmlA0 = RML_CAR(lst);
	    RML_TAILCALLK(rmlSC);
	}
    }
    RML_TAILCALLK(rmlFC);
}
Ejemplo n.º 7
0
RML_END_LABEL

/* adrpo added string char list to string */
RML_BEGIN_LABEL(RML__string_5fchar_5flist_5fstring)
{
    rml_uint_t len = 0;

    /* first compute the length of the list */
    {
	void *lst = rmlA0;
	for(; RML_GETHDR(lst) == RML_CONSHDR; ++len, lst = RML_CDR(lst))
	    ;
    }
    /* then allocate and initialize the string */
    {
	struct rml_string *str = rml_prim_mkstring(len, 1);	/* gets len+1 bytes */
	void *lst = rmlA0;
	unsigned char *s = (unsigned char*)str->data;
	rmlA0 = RML_TAGPTR(str);
	for(; len > 0; --len, lst = RML_CDR(lst))
	{
		/* printf ("%c ",RML_STRINGDATA(RML_CAR(lst))[0]) */
	    *s++ = RML_STRINGDATA(RML_CAR(lst))[0];
	}
	*s = '\0';
    }
    RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 8
0
RML_END_LABEL

/* list-str.c */
RML_BEGIN_LABEL(RML__list_5fstring)
{
    rml_uint_t len = 0;

    /* first compute the length of the list */
    {
	void *lst = rmlA0;
	for(; RML_GETHDR(lst) == RML_CONSHDR; ++len, lst = RML_CDR(lst))
	    ;
    }
    /* then allocate and initialize the string */
    {
	struct rml_string *str = rml_prim_mkstring(len, 1);	/* gets len+1 bytes */
	void *lst = rmlA0;
	unsigned char *s = (unsigned char*)str->data;
	rmlA0 = RML_TAGPTR(str);
	for(; len > 0; --len, lst = RML_CDR(lst))
	    *s++ = RML_UNTAGFIXNUM(RML_CAR(lst));
	*s = '\0';
    }
    RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 9
0
RML_END_LABEL


RML_BEGIN_LABEL(External__substring)
{
	rml_uint_t len = RML_HDRSTRLEN(RML_GETHDR(rmlA0)); /* string lenght */
	int index1 = RML_UNTAGFIXNUM(rmlA1);
	int index2 = RML_UNTAGFIXNUM(rmlA2);
	rml_uint_t newlen = 0;
	int i = 0;
	if (index2 < 0) index2 = len-1;
	if (index1 < 0) index1 = 0;
	if (index1 > index2)
	{
		index1 = RML_UNTAGFIXNUM(rmlA2);
		index2 = RML_UNTAGFIXNUM(rmlA1);
	}
	if (index2 >= len) index2 = len-1;
	newlen = index2-index1 + 1;
	/* alloc the new string */
	struct rml_string *strnew = rml_prim_mkstring(newlen, 3);
	char *str = RML_STRINGDATA(rmlA0);
	unsigned char *snew = (unsigned char*)strnew->data;
	for(i=index1; i <= index2; i++)
	{
		*snew++ = str[i];
	}
	*snew = '\0';
	rmlA0 = RML_TAGPTR(strnew);
	RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 10
0
RML_END_LABEL

RML_BEGIN_LABEL(External__strtok)
{
  char *s;
  char *delimit = RML_STRINGDATA(rmlA1);
  char *str = strdup(RML_STRINGDATA(rmlA0));

  void * res = (void*)mk_nil();
  s=strtok(str,delimit);
  if (s == NULL)
  {
          /* adrpo added 2004-10-27 */
          free(str);
          rmlA0=res; RML_TAILCALLK(rmlFC);
  }
  res = (void*)mk_cons(mk_scon(s),res);
  while (s=strtok(NULL,delimit))
  {
    res = (void*)mk_cons(mk_scon(s),res);
  }
  rmlA0=res;

  /* adrpo added 2004-10-27 */
  free(str);

  /* adrpo changed 2004-10-29
  rml_prim_once(RML__list_5freverse);
  RML_TAILCALLK(rmlSC);
  */
  RML_TAILCALLQ(RML__list_5freverse,1);
}
Ejemplo n.º 11
0
RML_END_LABEL


/* list-arr.c */
RML_BEGIN_LABEL(RML__list_5farray)
{
    rml_uint_t nelts = 0;

    /* first compute the length of the list */
    {
	void *lst = rmlA0;
	for(; RML_GETHDR(lst) == RML_CONSHDR; ++nelts, lst = RML_CDR(lst))
	    ;
    }
    /* then allocate and initialize the vector */
    {
	struct rml_struct *vec = (struct rml_struct*)rml_prim_alloc(1+nelts, 1);
	void *lst = rmlA0;
	void **vecp = vec->data;
	vec->header = RML_STRUCTHDR(nelts, 0);
	rmlA0 = RML_TAGPTR(vec);
	for(; nelts > 0; --nelts, lst = RML_CDR(lst))
	    *vecp++ = RML_CAR(lst);
    }
    RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 12
0
RML_END_LABEL

RML_BEGIN_LABEL(BackendDAEEXT__getDifferentiatedEqns)
{
  rmlA0 = BackendDAEEXTImpl__getDifferentiatedEqns();
  RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 13
0
RML_END_LABEL

RML_BEGIN_LABEL(BackendDAEEXT__clearDifferentiated)
{
  BackendDAEEXTImpl__clearDifferentiated();
  RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 14
0
RML_END_LABEL

/* list_reverse.c */
RML_BEGIN_LABEL(RML__list_5freverse)
{
    void *a1;		/* cached A1 */
    struct rml_struct *cons;

    /* A1 := A0; A0 := NIL */
    a1 = rmlA0;
    rmlA0 = RML_TAGPTR(&rml_prim_nil);

    /* while CONSP(A1) do A0 := CONS(CAR(A1), A0); A1 := CDR(A1) end */
    while( RML_GETHDR(a1) == RML_CONSHDR ) {
	rmlA1 = a1;
	cons = (struct rml_struct*)rml_prim_alloc(3, 2);
	a1 = rmlA1;
	cons->header = RML_CONSHDR;
	cons->data[0] = RML_CAR(a1);
	cons->data[1] = rmlA0;
	rmlA0 = RML_TAGPTR(cons);
	a1 = RML_CDR(a1);
    }

    /* return A0 */
    RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 15
0
RML_END_LABEL

RML_BEGIN_LABEL(BackendDAEEXT__getMarkedVariables)
{
  rmlA0 = BackendDAEEXTImpl__getMarkedVariables();
  RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 16
0
RML_END_LABEL

RML_BEGIN_LABEL(External__strstr)
{
	char *str1 = RML_STRINGDATA(rmlA0);
	char *str2 = RML_STRINGDATA(rmlA1);
	char* result = NULL;
	if (strlen(str2) == 0 || (strlen(str1) < strlen(str2))) /* according to strstr */
	{
		rmlA0 = RML_FALSE;
		RML_TAILCALLK(rmlSC);
	}
	result = strstr(str1, str2);
	if (result) rmlA0 = RML_TRUE;
	else rmlA0 = RML_FALSE;
	RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 17
0
RML_END_LABEL

RML_BEGIN_LABEL(BackendDAEEXT__getEMark)
{
  int i = RML_UNTAGFIXNUM(rmlA0);
  rmlA0 = mk_bcon(BackendDAEEXTImpl__getEMark(i));
  RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 18
0
RML_END_LABEL

RML_BEGIN_LABEL(BackendDAEEXT__vMark)
{
  int i = RML_UNTAGFIXNUM(rmlA0);
  BackendDAEEXTImpl__vMark(i);
  RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 19
0
RML_END_LABEL

RML_BEGIN_LABEL(BackendDAEEXT__dumpMarkedVariables)
{
  int nvars = RML_UNTAGFIXNUM(rmlA0);
  BackendDAEEXTImpl__dumpMarkedVariables(nvars);
  RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 20
0
RML_END_LABEL

RML_BEGIN_LABEL(BackendDAEEXT__initNumber)
{
  int nvars = RML_UNTAGFIXNUM(rmlA0);
  BackendDAEEXTImpl__initNumber(nvars);
  RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 21
0
RML_END_LABEL

RML_BEGIN_LABEL(BackendDAEEXT__markDifferentiated)
{
  int i = RML_UNTAGFIXNUM(rmlA0);
  BackendDAEEXTImpl__markDifferentiated(i);
  RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 22
0
RML_END_LABEL

RML_BEGIN_LABEL(BackendDAEEXT__initF)
{
  int size = RML_UNTAGFIXNUM(rmlA0);
  BackendDAEEXTImpl__initF(size);
  RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 23
0
RML_END_LABEL

RML_BEGIN_LABEL(Solver__string_5freal)
{
    char *first_param = RML_STRINGDATA(rmlA0);
    char *endptr = first_param;
    errno = 0;
    double r = strtod(first_param, &endptr);

    if (endptr == first_param || errno != 0) {
	/* printf("Conversion failed %s\n", first_param); */
	RML_TAILCALLK(rmlFC);
    }
    /* printf("Conversion success %s -> %f\n", first_param, r); */
    rmlA0 = mk_rcon(r);
    RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 24
0
RML_END_LABEL

/* lvar_set.c */
RML_BEGIN_LABEL(RML__lvar_5fset)
{
    void *lvar = rmlA0;
    if( RML_GETHDR(lvar) == RML_UNBOUNDHDR ) {
	RML_GETHDR(lvar) = RML_BOUNDHDR;
	RML_REFDATA(lvar) = rmlA1;
	if( rmlTP == &rml_trail[0] ) {
	    (void)fprintf(stderr, "Trail overflow!\n");
	    rml_exit(1);
	}
	*--rmlTP = lvar;
	RML_TAILCALLK(rmlSC);
    } else
	RML_TAILCALLK(rmlFC);
}
Ejemplo n.º 25
0
RML_END_LABEL

RML_BEGIN_LABEL(BackendDAEEXT__setV)
{
  int i = RML_UNTAGFIXNUM(rmlA0);
  int val = RML_UNTAGFIXNUM(rmlA1);
  BackendDAEEXTImpl__setV(i,val);
  RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 26
0
RML_END_LABEL

RML_BEGIN_LABEL(External__string_5freal)
{
	char *str = RML_STRINGDATA(rmlA0);
	double real = atof(str);
	rmlA0 = rml_prim_mkreal(real);
	RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 27
0
RML_END_LABEL

/* misc_print.c */
RML_BEGIN_LABEL(RML__print)
{
    void *str = rmlA0;
    fwrite(RML_STRINGDATA(str), RML_HDRSTRLEN(RML_GETHDR(str)), 1, stdout);
	fflush(stdout);
    RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 28
0
RML_END_LABEL

/* misc_tick.c */
RML_BEGIN_LABEL(RML__tick)
{
    static rml_sint_t counter;
    rmlA0 = RML_IMMEDIATE(RML_TAGFIXNUM(counter));
    ++counter;
    RML_TAILCALLK(rmlSC);
}
Ejemplo n.º 29
0
RML_END_LABEL

/* list-get.c */
RML_BEGIN_LABEL(RML__list_5fget)
{
    rml_sint_t i = RML_UNTAGFIXNUM(rmlA1);
    void *lst = rmlA0;
	i--; /* list_get starts the index at 1 */
	if (i < 0) RML_TAILCALLK(rmlFC);
    for(; RML_GETHDR(lst) == RML_CONSHDR; --i, lst = RML_CDR(lst)) 
	{
		if ( i == 0 ) 
		{
			rmlA0 = RML_CAR(lst);
			RML_TAILCALLK(rmlSC);
		}
    }
    RML_TAILCALLK(rmlFC);
}
Ejemplo n.º 30
0
RML_END_LABEL


RML_BEGIN_LABEL(External__to_5flowercase)
{
    void *a0 = rmlA0;
    char *str = RML_STRINGDATA(a0);
	rmlA0=a0;
	RML_TAILCALLK(rmlSC);
}