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); }
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); }
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); }
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); }
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); }
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); }
void *mk_box1(unsigned ctor, void *x0) { struct rml_struct *p = alloc_words(2); p->header = RML_STRUCTHDR(1, ctor); p->data[0] = x0; return RML_TAGPTR(p); }
void *mk_box2(unsigned ctor, void *x0, void *x1) { struct rml_struct *p = alloc_words(3); p->header = RML_STRUCTHDR(2, ctor); p->data[0] = x0; p->data[1] = x1; return RML_TAGPTR(p); }
void *mk_rcon(double d) { struct rml_real *p = alloc_words(RML_SIZE_DBL/RML_SIZE_INT + 1); rml_prim_set_real(p, d); p->header = RML_REALHDR; return RML_TAGPTR(p); }
void *mk_box3(unsigned ctor, void *x0, void *x1, void *x2) { struct rml_struct *p = alloc_words(4); p->header = RML_STRUCTHDR(3, ctor); p->data[0] = x0; p->data[1] = x1; p->data[2] = x2; return RML_TAGPTR(p); }
void *mk_box4(unsigned ctor, void *x0, void *x1, void *x2, void *x3) { struct rml_struct *p = alloc_words(5); p->header = RML_STRUCTHDR(4, ctor); p->data[0] = x0; p->data[1] = x1; p->data[2] = x2; p->data[3] = x3; return RML_TAGPTR(p); }
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); } }
void *mk_scon(char *s) { unsigned nbytes = strlen(s); unsigned header = RML_STRINGHDR(nbytes); unsigned nwords = RML_HDRSLOTS(header) + 1; struct rml_string *p = alloc_words(nwords); p->header = header; memcpy(p->data, s, nbytes+1); /* including terminating '\0' */ return RML_TAGPTR(p); }
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); }
RML_END_LABEL /* lvar_new.c */ RML_BEGIN_LABEL(RML__lvar_5fnew) { struct rml_ref *lvar = (struct rml_ref*)rml_prim_alloc(2, 0); lvar->header = RML_UNBOUNDHDR; /* lvar->data need not be initialized */ rmlA0 = RML_TAGPTR(lvar); RML_TAILCALLK(rmlSC); }
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); }
void *mk_box6(unsigned ctor, void *x0, void *x1, void *x2, void *x3, void *x4, void *x5) { struct rml_struct *p = alloc_words(7); p->header = RML_STRUCTHDR(6, ctor); p->data[0] = x0; p->data[1] = x1; p->data[2] = x2; p->data[3] = x3; p->data[4] = x4; p->data[5] = x5; return RML_TAGPTR(p); }
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); }
void *mk_scon(char *s) { rml_uint_t nbytes = strlen(s); rml_uint_t header= RML_STRINGHDR(nbytes); rml_uint_t nwords= RML_HDRSLOTS(header) + 1; if (!rml_string_cache_index) /* no string in the cache */ { struct rml_string *p = alloc_words(nwords); p->header = header; memcpy(p->data, s, nbytes+1); /* including terminating '\0' */ if (rml_string_cache_index < RML_STRING_CACHE_MAX && nbytes < RML_SHARED_STRING_MAX) /* add to sharing only if less than RML_SHARED_STRING_MAX */ rml_string_cache[rml_string_cache_index++] = p; return RML_TAGPTR(p); } /* else, try to find if we already have the same string in the heap */ { unsigned int i; struct rml_string *p; for (i = 0; i < rml_string_cache_index; i++) { p = rml_string_cache[i]; if (strcmp(p->data,s) == 0) { rml_total_shared_strings++; rml_total_shared_strings_words += nwords; return RML_TAGPTR(p); } } /* no string found in cache */ { struct rml_string *p = alloc_words(nwords); p->header = header; memcpy(p->data, s, nbytes+1); /* including terminating '\0' */ if (rml_string_cache_index < RML_STRING_CACHE_MAX && nbytes < RML_SHARED_STRING_MAX) /* add to sharing only if less than RML_SHARED_STRING_MAX */ rml_string_cache[rml_string_cache_index++] = p; return RML_TAGPTR(p); } } }
RML_END_LABEL RML_BEGIN_LABEL(External__trimstring) { char *str = RML_STRINGDATA(rmlA0); char *what = RML_STRINGDATA(rmlA1); rml_uint_t len = strlen(str); /* string lenght */ rml_uint_t lenwhat = strlen(what); /* string lenght */ int i = 0; int j = len; int l = 0; if (!lenwhat) RML_TAILCALLK(rmlSC); for (; i < len;) if (!strncmp(str+i,what,lenwhat)) i+=lenwhat; else break; for (; j >= 0; ) if (!strncmp(str+j-lenwhat,what,lenwhat)) j-=lenwhat; else break; /* printf("i=%d, j=%d, lenwhat=%d, len=%d", i, j, lenwhat, len); */ if (j <= i) /* the string is actually only whitespace, return "" */ { /* alloc the new string */ struct rml_string *strnew = rml_prim_mkstring(0, 2); unsigned char *snew = (unsigned char*)strnew->data; snew[0] = '\0'; rmlA0 = RML_TAGPTR(strnew); RML_TAILCALLK(rmlSC); } /* alloc the new string */ struct rml_string *strnew = rml_prim_mkstring(j-i, 2); unsigned char *snew = (unsigned char*)strnew->data; str = RML_STRINGDATA(rmlA0); for(l=i; l < j; l++) *snew++ = str[l]; *snew = '\0'; rmlA0 = RML_TAGPTR(strnew); /* printf("sss:%s|\nstr:%s|\ndlm:%s|\nact:",str, RML_STRINGDATA(rmlA0), RML_STRINGDATA(rmlA1)); fwrite(RML_STRINGDATA(rmlA0), RML_HDRSTRLEN(RML_GETHDR(rmlA0)), 1, stdout); printf("|\n"); */ RML_TAILCALLK(rmlSC); }
void *mk_box8(unsigned ctor, void *x0, void *x1, void *x2, void *x3, void *x4, void *x5, void *x6, void *x7) { struct rml_struct *p = alloc_words(9); p->header = RML_STRUCTHDR(8, ctor); p->data[0] = x0; p->data[1] = x1; p->data[2] = x2; p->data[3] = x3; p->data[4] = x4; p->data[5] = x5; p->data[6] = x6; p->data[7] = x7; return RML_TAGPTR(p); }
RML_END_LABEL RML_BEGIN_LABEL(External__trim) { char *str = RML_STRINGDATA(rmlA0); rml_uint_t len = strlen(str); /* string lenght */ int i = 0; int j = len-1; int l = 0; for (; i < len;) if (isspace(str[i])) i++; else break; for (; j >= 0; ) if (isspace(str[j])) j--; else break; /* printf("i=%d, j=%d", i, j); */ if (j <= i) /* the string is actually only whitespace, return "" */ { /* alloc the new string */ struct rml_string *strnew = rml_prim_mkstring(0, 1); unsigned char *snew = (unsigned char*)strnew->data; snew[0] = '\0'; rmlA0 = RML_TAGPTR(strnew); RML_TAILCALLK(rmlSC); } /* alloc the new string */ struct rml_string *strnew = rml_prim_mkstring(j-i+1, 1); unsigned char *snew = (unsigned char*)strnew->data; str = RML_STRINGDATA(rmlA0); for(l=i; l <= j; l++) *snew++ = str[l]; *snew = '\0'; rmlA0 = RML_TAGPTR(strnew); /* printf("sss:%s|\nstr:%s|\nact:",str, RML_STRINGDATA(rmlA0)); fwrite(RML_STRINGDATA(rmlA0), RML_HDRSTRLEN(RML_GETHDR(rmlA0)), 1, stdout); printf("|\n"); */ RML_TAILCALLK(rmlSC); }
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); }
void *mk_nil(void) { return RML_TAGPTR(&rml_prim_nil); }
RML_END_LABEL RML_BEGIN_LABEL(External__commentEscape) { char *str = RML_STRINGDATA(rmlA0); rml_uint_t len = strlen(str); char *strnew = (char*)malloc(2*len); /* should be enough */ int i=0, j=0, c=0, n=0; rml_uint_t lennew = 0; unsigned char *snew = 0; struct rml_string *rml_strnew = 0; while (1) { if (i >= len) break; c = str[i]; if (c == '\\') { strnew[lennew] = c; lennew++; i++; if (i >= len) break; c = str[i]; switch (c) { /* case 'n': strnew[lennew] = '\n'; break; case 't': strnew[lennew] = '\t'; break; case 'r': strnew[lennew] = '\r'; break; */ case '\\': strnew[lennew] = '\\'; break; case '"': /* already escaped */ strnew[lennew] = '"'; break; default: /* don't know the escape sequence, escape the \ */ strnew[lennew] = '\\'; lennew++; strnew[lennew] = c; } lennew++; } else if(c == '"' || c == '\'') { strnew[lennew++] = '\\'; strnew[lennew++] = c; } else { strnew[lennew++] = c; } i++; } strnew[lennew]='\0'; /* now alloc the new string */ rml_strnew = rml_prim_mkstring(lennew, 1); snew = (unsigned char*)rml_strnew->data; for(i = 0; i < lennew; i++) { *snew++ = strnew[i]; } *snew = '\0'; free(strnew); rmlA0 = RML_TAGPTR(rml_strnew); RML_TAILCALLK(rmlSC); }
RML_END_LABEL RML_BEGIN_LABEL(External__stringEscape) { char *str = RML_STRINGDATA(rmlA0); rml_uint_t len = strlen(str); char *strnew = (char*)malloc(2*len); /* should be enough */ int i=0, j=0, c=0, n=0; rml_uint_t lennew = 0; unsigned char *snew = 0; struct rml_string *rml_strnew = 0; while (1) { if (i >= len) break; c = str[i]; if (c == '\\') { strnew[lennew] = c; lennew++; i++; if (i >= len) break; c = str[i]; switch (c) { case 'f': strnew[lennew] = '\f'; break; case 'b': strnew[lennew] = '\b'; break; case 'e': strnew[lennew] = 033; break; case 'v': strnew[lennew] = '\v'; break; case 'a': strnew[lennew] = '\a'; break; case '?': strnew[lennew] = '\?'; break; case 'n': strnew[lennew] = '\n'; break; case 't': strnew[lennew] = '\t'; break; case 'r': strnew[lennew] = '\r'; break; case '"': strnew[lennew] = '\"'; break; default: strnew[lennew] = '\\'; lennew++; strnew[lennew] = c; } lennew++; } else if(c == '"' || c == '\'') { strnew[lennew++] = '\\'; strnew[lennew++] = c; } else /* leave the char as it is */ { strnew[lennew++] = c; } i++; } strnew[lennew]='\0'; /* now alloc the new string */ rml_strnew = rml_prim_mkstring(lennew, 1); snew = (unsigned char*)rml_strnew->data; for(i = 0; i < lennew; i++) { *snew++ = strnew[i]; } *snew = '\0'; free(strnew); rmlA0 = RML_TAGPTR(rml_strnew); RML_TAILCALLK(rmlSC); }
void *mk_box0(unsigned ctor) { struct rml_struct *p = alloc_words(1); p->header = RML_STRUCTHDR(0, ctor); return RML_TAGPTR(p); }
void *mk_none(void) { static struct rml_header none = { RML_STRUCTHDR(0, 0) }; return RML_TAGPTR(&none); }
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); } }