コード例 #1
0
ファイル: external.c プロジェクト: SemiSQ/OpenModelica
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);
}
コード例 #2
0
ファイル: external.c プロジェクト: SemiSQ/OpenModelica
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);
	}
}
コード例 #3
0
DataField getData(const char *varname,const char *filename, unsigned int size, SimulationResult_Globals* srg)
{
  DataField res;
  void *cmpvar,*dataset,*lst,*datasetBackup;
  double *newvars;
  double d;
  unsigned int i;
  unsigned int ncmpvars = 0;
  res.n = 0;
  res.data = NULL;

  /* fprintf(stderr, "getData of Var: %s from file %s\n", varname,filename); */
  cmpvar = mk_nil();
  cmpvar =  mk_cons(mk_scon(varname),cmpvar);
  dataset = SimulationResultsImpl__readDataset(filename,cmpvar,size,srg);
  if (dataset==NULL) {
    /* fprintf(stderr, "getData of Var: %s failed!\n",varname); */
    return res;
  }

  /* fprintf(stderr, "Data of Var: %s\n", varname);
     First calculate the length of the matrix */
  datasetBackup = dataset;
  while (RML_NILHDR != RML_GETHDR(dataset)) {
    lst = RML_CAR(dataset);
    while (RML_NILHDR != RML_GETHDR(lst)) {
      res.n++;
      lst = RML_CDR(lst);
    }
    dataset = RML_CDR(dataset);
  }
  if (res.n == 0) return res;

  /* The allocate and read the values */
  dataset = datasetBackup;
  i = res.n;
  res.data = (double*) malloc(sizeof(double)*res.n);
  while (RML_NILHDR != RML_GETHDR(dataset)) {
    lst = RML_CAR(dataset);
    while (RML_NILHDR != RML_GETHDR(lst)) {
      res.data[--i] = rml_prim_get_real(RML_CAR(lst));
      lst = RML_CDR(lst);
    }
    dataset = RML_CDR(dataset);
  }
  assert(i == 0);

  /* for (i=0;i<res.n;i++)
     fprintf(stderr, "%d: %.6g\n",  i, res.data[i]); */

  return res;
}
コード例 #4
0
/*
 * p_equal.c -- implements polymorphic equality for RML
 * (This is the reason why reference nodes must still be distinguishable
 * from all other values.)
 */
void *rml_prim_equal(void *p, void *q)
{
  tail_recur:
    /* INV: ISIMM(p) <==> ISIMM(q) */
    if( p == q ) {
	/* Identical objects are always equal. */
	return RML_TRUE;
    } else if( RML_ISIMM(p) ) {
	/* Different immediate values. */
	return RML_FALSE;
    } else {
	/* Non-identical boxed values. */
	rml_uint_t phdr = RML_GETHDR(p);
	rml_uint_t qhdr = RML_GETHDR(q);

	if( phdr == qhdr ) {
	    if( phdr == RML_REALHDR ) {
		return (rml_prim_get_real(p) == rml_prim_get_real(q))
		    ? RML_TRUE
		    : RML_FALSE;
	    } else if( RML_HDRISSTRING(phdr) ) {
		if( !memcmp(RML_STRINGDATA(p), RML_STRINGDATA(q), RML_HDRSTRLEN(phdr)) )
		    return RML_TRUE;
		else
		    return RML_FALSE;
	    } else if( RML_HDRISSTRUCT(phdr) ) {
		rml_uint_t slots = RML_HDRSLOTS(phdr);
		void **pp = RML_STRUCTDATA(p);
		void **qq = RML_STRUCTDATA(q);
		if( slots == 0 )
		    return RML_TRUE;
		while( --slots > 0 )
		    if( rml_prim_equal(*pp++, *qq++) == RML_FALSE )
			return RML_FALSE;
		p = *pp;
		q = *qq;
		goto tail_recur;
	    } else {
		/* Non-identical reference nodes. */
		return RML_FALSE;
	    }
	} else {
	    /* Different sized strings, different constructors of some datatype,
	     * or reference nodes with different instantiation states.
	     */
	    return RML_FALSE;
	}
    }
}
コード例 #5
0
ファイル: list.c プロジェクト: choeger/MetaModelica-autotools
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);
}
コード例 #6
0
ファイル: external.c プロジェクト: SemiSQ/OpenModelica
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);
}
コード例 #7
0
ファイル: list.c プロジェクト: choeger/MetaModelica-autotools
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);
}
コード例 #8
0
ファイル: list.c プロジェクト: choeger/MetaModelica-autotools
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);
}
コード例 #9
0
ファイル: list.c プロジェクト: choeger/MetaModelica-autotools
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);
}
コード例 #10
0
ファイル: external.c プロジェクト: SemiSQ/OpenModelica
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);
}
コード例 #11
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);
}
コード例 #12
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);
}
コード例 #13
0
ファイル: external.c プロジェクト: SemiSQ/OpenModelica
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);
}
コード例 #14
0
ファイル: list.c プロジェクト: choeger/MetaModelica-autotools
RML_END_LABEL


/* list-delete.c */
RML_BEGIN_LABEL(RML__list_5fdelete)
{
    rml_sint_t nelts = RML_UNTAGFIXNUM(rmlA1);
    if( nelts < 0 )
	RML_TAILCALLK(rmlFC);
    else if( nelts == 0 ) {
	if( RML_GETHDR(rmlA0) == RML_CONSHDR )
	    rmlA0 = RML_CDR(rmlA0);
	else
	    RML_TAILCALLK(rmlFC);
    } else { /* nelts > 0 */
	void **chunk = (void**)rml_prim_alloc(3*nelts, 1);
	void *lst = rmlA0;
	rmlA0 = RML_TAGPTR(chunk);
	for(;;) {
	    if( RML_GETHDR(lst) == RML_CONSHDR ) {
		if( nelts == 0 ) {
		    chunk[-1] = RML_CDR(lst);
		    break;
		} else {
		    chunk[0] = RML_IMMEDIATE(RML_CONSHDR);
		    chunk[1] = RML_CAR(lst);
		    chunk[2] = RML_TAGPTR(chunk + 3);
		    lst = RML_CDR(lst);
		    chunk += 3;
		    --nelts;
		    continue;
		}
	    } else	/* NIL */
		RML_TAILCALLK(rmlFC);
	}
    }

    /* return resulting list */
    RML_TAILCALLK(rmlSC);
}
コード例 #15
0
ファイル: list.c プロジェクト: choeger/MetaModelica-autotools
RML_END_LABEL


/* list_length.c */
RML_BEGIN_LABEL(RML__list_5flength)
{
    void *lst = rmlA0;
    rml_uint_t len = 0;
    for(; RML_GETHDR(lst) == RML_CONSHDR; ++len, lst = RML_CDR(lst))
	;
    rmlA0 = RML_IMMEDIATE(RML_TAGFIXNUM(len));
    RML_TAILCALLK(rmlSC);
}
コード例 #16
0
RML_END_LABEL

RML_BEGIN_LABEL(BackendDAEEXT__setAssignment)
{
  int nelts=0;
  int nass1 = RML_UNTAGFIXNUM(rmlA0);
  int nass2 = RML_UNTAGFIXNUM(rmlA1);
  int i=0;

  nelts = RML_HDRSLOTS(RML_GETHDR(rmlA2));
  if (nelts > 0) {
    n = nass1;
    if(match) {
      free(match);
    }
    match = (int*) malloc(n * sizeof(int));
    memset(match,-1,n * sizeof(int));
    for(i=0; i<n; ++i) {
      match[i] = RML_UNTAGFIXNUM(RML_STRUCTDATA(rmlA2)[i])-1;
      if (match[i]<0) match[i] = -1;
    }
  }
  nelts = RML_HDRSLOTS(RML_GETHDR(rmlA3));
  if (nelts > 0) {
    m = nass2;
    if(row_match) {
      free(row_match);
    }
    row_match = (int*) malloc(m * sizeof(int));
    memset(row_match,-1,m * sizeof(int));
    for(i=0; i<m; ++i) {
      row_match[i] = RML_UNTAGFIXNUM(RML_STRUCTDATA(rmlA3)[i])-1;
      if (row_match[i]<0) row_match[i] = -1;
    }
  }
  rmlA0 = mk_bcon(1);
  RML_TAILCALLK(rmlSC);
}
コード例 #17
0
ファイル: list.c プロジェクト: choeger/MetaModelica-autotools
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);
}
コード例 #18
0
ファイル: list.c プロジェクト: choeger/MetaModelica-autotools
RML_END_LABEL

/* list-member.c */
RML_BEGIN_LABEL(RML__list_5fmember)
{
    void *x = rmlA0;
    void *ys = rmlA1;
    void *result = RML_FALSE;
    for(; RML_GETHDR(ys) == RML_CONSHDR; ys = RML_CDR(ys)) {
	if( rml_prim_equal(x, RML_CAR(ys)) != RML_FALSE ) {
	    result = RML_TRUE;
	    break;
	}
    }
    rmlA0 = result;
    RML_TAILCALLK(rmlSC);
}
コード例 #19
0
ファイル: list.c プロジェクト: choeger/MetaModelica-autotools
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);
}
コード例 #20
0
ファイル: list.c プロジェクト: choeger/MetaModelica-autotools
RML_END_LABEL


RML_BEGIN_LABEL(RML__list_5fmap)
{
    rml_uint_t nelts;
    void *lst = rmlA0;
    void *function = rmlA1;

    /* count the number of elements in the first list */
    nelts = 0;
    while( RML_GETHDR(lst) == RML_CONSHDR ) {
      lst = RML_CDR(lst);
      ++nelts;
    }
    /* call the relation, to build the second list  */
    if( nelts == 0 )
    { /* do nothing, return nil */ }
    else 
    {
        void **chunk = (void**)rml_prim_alloc(3*nelts, 2);
        lst = rmlA0;
        rmlA0 = RML_TAGPTR(chunk);
        do {
            chunk[0] = RML_IMMEDIATE(RML_CONSHDR);
            rmlA0 = RML_CAR(lst); /* element */;
            RML_TAILCALL(rmlA1 /* fn */,1);
            chunk[1] = rmlA0;
            chunk[2] = RML_TAGPTR(chunk + 3);
            lst = RML_CDR(lst);
            chunk += 3;
        } while( --nelts != 0 );
    }

    /* return resulting list */
    RML_TAILCALLK(rmlSC);
}
コード例 #21
0
/* p_unwind.c */
void rml_prim_unwind_(void **saveTP)	/* PRE: rmlTP < saveTP */
{
    void **TP = rml_state_TP;
    do { RML_GETHDR(*TP) = RML_UNBOUNDHDR; } while( ++TP < saveTP );
    rml_state_TP = TP;
}
コード例 #22
0
ファイル: external.c プロジェクト: SemiSQ/OpenModelica
RML_END_LABEL


RML_BEGIN_LABEL(External__strrplall)
{
	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 = 0;
		/* find where */
		rml_uint_t pos = (int)(strpos - str1);
		rml_uint_t count = 1; /* we already find it once above */
		/* how many times the string is there? */
		strpos += len2; /* advance the position */
		/*
		printf ("str1 [%s], str2[%s], str3[%s]\n", str1, str2, str3);
		printf ("strpos:%s\n", strpos);
		*/
		/* how many times the string is there? */
		while ((strpos = strstr(strpos, str2)) != NULL)
		{
			count++;
			/* printf ("strpos:%s\n", strpos); */
			strpos += len2;
		}
		/* calculate the lenght of the new string */
		len = len1+(len3-len2)*count;
		/* print len
		printf("len:%d, len1:%d, len2:%d, len3:%d, count:%d\n", len, len1, len2, len3, count);
		*/
		/* now 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 */
		/* go to first */
		strpos = strstr(str1, str2);
		pos = (int)(strpos - str1);
		do
		{
			/* until pos, use the first string */
			/* printf("pos1:%d\n", pos); */
			for(i=0; i < pos; i++)
			{
				*snew++ = str1[i];
			}
			for(i=0; i < len3; i++)
			{
				*snew++ = str3[i];
			}
			/* move the str1 pointer after str2 */
			str1 += (pos+len2);
			strpos = strstr(str1, str2);
			if (!strpos)
			{
				/* copy stuff left from str1 */
				for(i=0; i < strlen(str1); i++)
				{
					*snew++ = str1[i];
				}
				break;
			}
			pos = (int)(strpos - str1);
			/* printf("pos2:%d and str1:%s\n", pos, str1); */
		}
		while (1);
		*snew = '\0';
		rmlA0 = RML_TAGPTR(strnew);
		RML_TAILCALLK(rmlSC);
	}
}
コード例 #23
0
RML_END_LABEL


void rmldb_var_print(void *p)
{
	/* printf("[%p]", p); */
	if (!p) { printf ("NIL"); fflush(stdout); return; }
	if( RML_ISIMM(p) ) 
	{
		printf ("%d", RML_UNTAGFIXNUM(p));    
	} 
	else 
	{
		rml_uint_t phdr = RML_GETHDR(p);            
		if( phdr == RML_REALHDR ) 
		{
			printf ("%f", rml_prim_get_real(p));
			fflush(stdout);
		} else 
			if( RML_HDRISSTRING(phdr) ) 
			{
				printf ("\"%s\"", RML_STRINGDATA(p));
				fflush(stdout);
				/* use if neccesarry RML_HDRSTRLEN(phdr) */
			} else 
				if( RML_HDRISSTRUCT(phdr) ) 
				{
					rml_uint_t slots = RML_HDRSLOTS(phdr);
					rml_uint_t constr = RML_HDRCTOR(phdr);
					void **pp = NULL;
					if (slots == 0)
					{
						printf ("{S(%d)[%d]=NIL}", constr, slots);
						fflush(stdout);
						return;
					}
					
					printf ("S(%d)[%d](", constr, slots);

					pp = RML_STRUCTDATA(p);
					fflush(stdout);
					// function definition
					if ((constr == 64 || constr==13) &&
						slots > 1000000) return;
					if( slots != 0 )
					{
						// printf ("\n\t"); 
						while( --slots > 0 )
						{
							rmldb_var_print(*pp++);
							printf (",");
							fflush(stdout);
						}
						p = *pp; 
						rmldb_var_print(*pp); printf (")"); fflush(stdout);
						// goto tail_recur_debug;  
					}					    
				} 
				else 
				{
					printf ("UNKNOWN"); fflush(stdout);
				}
	}
}
コード例 #24
0
void print_scon(FILE *fp, void *scon) {
  fprintf(fp, "%.*s", RML_HDRSTRLEN(RML_GETHDR(scon)), RML_STRINGDATA(scon));
}