int
clip_CHARAND(ClipMachine * ClipMachineMemory)
{
int l1, l2;
unsigned char *ret, *e, *end, *e2, *end2;
unsigned char *str = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l1);
unsigned char *s = (unsigned char *) _clip_parcl(ClipMachineMemory, 2, &l2);
int rset = (*(char *) (_clip_fetch_item(ClipMachineMemory, HASH_csetref)) == 't');
if (str == NULL || s == NULL)
{
_clip_retc(ClipMachineMemory, "");
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "CHARAND");
}
ret = malloc(l1 + 1);
memcpy(ret, str, l1);
ret[l1] = 0;
end2 = s + l2;
for (e = ret, end = ret + l1; e < end;)
for (e2 = s; e2 < end2 && e < end; e++, e2++)
*e = (*e & *e2);
if (rset && _clip_par_isref(ClipMachineMemory, 1))
_clip_par_assign_str(ClipMachineMemory, 1, (char *) ret, l1);
_clip_retcn_m(ClipMachineMemory, (char *) ret, l1);
return 0;
}
int
clip_FREAD(ClipMachine * ClipMachineMemory)
{
#if 0
int ret, *err, bl;
int fh = _clip_parni(ClipMachineMemory, 1);
char *buf = _clip_parcl(ClipMachineMemory, 2, &bl);
int kol = _clip_parni(ClipMachineMemory, 3);
if (bl < kol)
kol = bl;
ret = read(fh, buf, kol);
err = _clip_fetch_item(ClipMachineMemory, HASH_ferror);
if (ret < 0)
*err = errno;
else
*err = 0;
#else
int *err = _clip_fetch_item(ClipMachineMemory, HASH_ferror);
int fd = _clip_parni(ClipMachineMemory, 1), lenbuf = 0;
char *buf = _clip_parcl(ClipMachineMemory, 2, &lenbuf);
long ret = -1, nb = _clip_parnl(ClipMachineMemory, 3);
C_FILE *cf = _clip_fetch_c_item(ClipMachineMemory, fd, _C_ITEM_TYPE_FILE);
_clip_retnl(ClipMachineMemory, -1);
if (cf == NULL)
{
*err = EBADF;
return 0;
}
if (lenbuf < nb)
nb = lenbuf;
if (nb > 0)
{
if (cf->file_of_C_FILE == NULL || (cf->stat_of_C_FILE & FS_BUFFERED) == 0)
ret = _clip_read(cf, buf, nb);
else
ret = fread(buf, 1, nb, cf->file_of_C_FILE);
}
else
ret = 0;
*err = ret < 0 ? errno : 0;
#endif
_clip_retnl(ClipMachineMemory, ret);
return 0;
}
int
clip_STRSWAP(ClipMachine * ClipMachineMemory)
{
int l1, l2, l, i;
unsigned char ch;
unsigned char *s1 = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l1);
unsigned char *s2 = (unsigned char *) _clip_parcl(ClipMachineMemory, 2, &l2);
if (s1 == NULL || s2 == NULL)
{
_clip_retc(ClipMachineMemory, "");
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "STRSWAP");
}
l = l1 < l2 ? l1 : l2;
for (i = 0; i < l; i++)
{
ch = s1[i];
s1[i] = s2[i];
s2[i] = ch;
}
_clip_retc(ClipMachineMemory, "");
return 0;
}
int
clip_WORDONLY(ClipMachine * ClipMachineMemory)
{
int l1, l2, i = 0;
short *ret, *e1, *end1, *e2, *end2;
short *str1 = (short *) _clip_parcl(ClipMachineMemory, 1, &l1);
short *str2 = (short *) _clip_parcl(ClipMachineMemory, 2, &l2);
if (str1 == NULL || str2 == NULL)
{
_clip_retc(ClipMachineMemory, "");
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "WORDONLY");
}
l1 = l1 >> 1;
l2 = l2 >> 1;
ret = malloc((l2 + 1) * 2);
for (e2 = str2, end2 = str2 + l2; e2 < end2; e2++)
{
for (e1 = str1, end1 = str1 + l1; e1 < end1 && *e2 != *e1; e1++);
if (*e1 != *e2)
continue;
ret[i] = *e2;
i++;
}
ret[i] = 0;
_clip_retcn_m(ClipMachineMemory, (char *) ret, i * 2);
return 0;
}
int
clip_BEFORATNUM(ClipMachine * ClipMachineMemory)
{
int l, l1, l2;
unsigned char *ret, *beg;
unsigned char *sstr = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l1);
unsigned char *str = (unsigned char *) _clip_parcl(ClipMachineMemory, 2, &l2);
int count = _clip_parni(ClipMachineMemory, 3);
int ignore = _clip_parni(ClipMachineMemory, 4);
if (sstr == NULL || str == NULL)
{
_clip_retc(ClipMachineMemory, "");
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "BEFORATNUM");
}
beg = _clip_atmupa(ClipMachineMemory, sstr, l1, str, l2, ignore, count, 1);
l = beg - str;
ret = malloc(l + 1);
memcpy(ret, str, l);
ret[l] = 0;
_clip_retcn_m(ClipMachineMemory, (char *) ret, l);
return 0;
}
int
clip_CHARMIX(ClipMachine * ClipMachineMemory)
{
int l1, l2, i;
unsigned char *ret;
unsigned char *str1 = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l1);
unsigned char *str2 = (unsigned char *) _clip_parcl(ClipMachineMemory, 2, &l2);
if (str1 == NULL || str2 == NULL)
{
_clip_retc(ClipMachineMemory, "");
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "CHARMIX");
}
if (l2 == 0)
{
_clip_retcn(ClipMachineMemory, (char *) str1, l1);
return 0;
}
ret = malloc(l1 * 2 + 1);
for (i = 0; i < l1; i++)
{
ret[i * 2] = str1[i % l1];
ret[i * 2 + 1] = str2[i % l2];
}
ret[l1 * 2] = 0;
_clip_retcn_m(ClipMachineMemory, (char *) ret, l1 * 2);
return 0;
}
int clip_PG_IN_DATETIME(ClipMachine* mp){
PG_ROWSET* rowset = (PG_ROWSET*)_clip_fetch_c_item(
mp,_clip_parni(mp,1),_C_ITEM_TYPE_SQL);
char* date;
long dd,tt;
if(!rowset){
_clip_trap_err(mp,0,0,0,subsys,ER_NOROWSET,er_norowset);
return 1;
}
if(rowset->binary){
double d;
int l;
date = _clip_parcl(mp,2,&l);
d = *(double*)date;
dd = _clip_jdate(1,1,2000)+d/(24*60*60);
tt = ((long long)d*1000) % (24*60*60*1000);
if(tt < 0)
tt += 24*60*60*1000;
_clip_retdtj(mp,dd,tt);
} else {
int l;
date = _clip_parcl(mp,2,&l);
_pg_in_iso_datetime(date,l,&dd,&tt);
_clip_retdtj(mp,dd,tt);
}
return 0;
}
int
clip_CHARREM(ClipMachine * ClipMachineMemory)
{
int l, l1, l2, i;
unsigned char *ret, *e, *end, *s;
unsigned char *str1 = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l1);
unsigned char *str2 = (unsigned char *) _clip_parcl(ClipMachineMemory, 2, &l2);
if (str1 == NULL || str2 == NULL)
{
_clip_retc(ClipMachineMemory, "");
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "CHARREM");
}
l = l2;
ret = malloc(l + 1);
s = calloc(256, 1);
for (e = str1, end = str1 + l1; e < end; e++)
s[(int) (*e)] = 1;
for (i = 0, e = str2, end = str2 + l2; e < end; e++)
{
if (s[(int) (*e)] == 1)
continue;
ret[i] = *e;
i++;
}
free(s);
ret[i] = 0;
_clip_retcn_m(ClipMachineMemory, (char *) ret, i);
return 0;
}
int
clip_COUNTRIGHT(ClipMachine * ClipMachineMemory)
{
int l1, l2, ret = 0;
unsigned char *e;
unsigned char *str = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l1);
unsigned char *s = (unsigned char *) _clip_parcl(ClipMachineMemory, 2, &l2);
int ch = _clip_parni(ClipMachineMemory, 2);
if (str == NULL || l1 == 0)
{
_clip_retni(ClipMachineMemory, 0);
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "COUNTRIGHT");
}
if (s != NULL)
ch = *s;
if (ch == 0)
ch = ' ';
for (ret = 0, e = str + l1 - 1; e > str && *e == ch; e--, ret++);
_clip_retni(ClipMachineMemory, ret);
return 0;
}
int
clip_STRFINDBOL(ClipMachine * ClipMachineMemory)
{
int i, sl;
char *s = _clip_parcl(ClipMachineMemory, 1, &sl);
int begpos = _clip_parni(ClipMachineMemory, 2);
if (s == NULL)
{
_clip_retni(ClipMachineMemory, 0);
return 0;
}
if (begpos < 1 || begpos > sl)
begpos = sl + 1;
begpos--;
if (s[begpos] == '\n')
begpos--;
for (i = begpos; i >= 0; i--)
{
if (s[i] == '\n')
{
i++;
break;
}
}
_clip_retni(ClipMachineMemory, i + 1);
return 0;
}
int
clip_CHARSWAP(ClipMachine * ClipMachineMemory)
{
int l, i;
unsigned char *ret, ch;
unsigned char *str = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l);
int rset = (*(char *) (_clip_fetch_item(ClipMachineMemory, HASH_csetref)) == 't');
if (str == NULL)
{
_clip_retc(ClipMachineMemory, "");
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "CHARSWAP");
}
ret = str;
ret = malloc(l + 1);
for (i = 0; i < l; i += 2)
{
if (i < l - 1)
{
ch = str[i];
ret[i] = str[i + 1];
ret[i + 1] = ch;
}
else
ret[i] = str[i];
}
ret[l] = 0;
if (rset && _clip_par_isref(ClipMachineMemory, 1))
_clip_par_assign_str(ClipMachineMemory, 1, (char *) ret, l);
_clip_retcn_m(ClipMachineMemory, (char *) ret, l);
return 0;
}
int
clip_STRFINDEOL(ClipMachine * ClipMachineMemory)
{
int i, sl;
char *s = _clip_parcl(ClipMachineMemory, 1, &sl);
int begpos = _clip_parni(ClipMachineMemory, 2);
if (s == NULL)
{
_clip_retni(ClipMachineMemory, 0);
return 0;
}
if (begpos < 1)
begpos = 1;
for (i = begpos - 1; i < sl; i++)
{
if (s[i] == '\n')
{
i++;
break;
}
}
_clip_retni(ClipMachineMemory, i + 1);
return 0;
}
int clip_PG_OUT_TIMESTAMP(ClipMachine* mp){
PG_ROWSET* rowset = (PG_ROWSET*)_clip_fetch_c_item(
mp,_clip_parni(mp,1),_C_ITEM_TYPE_SQL);
int totext = _clip_parl(mp,3);
struct tm time;
time_t bindate;
char* date;
int len;
if(!rowset){
_clip_trap_err(mp,0,0,0,subsys,ER_NOROWSET,er_norowset);
return 1;
}
if((!totext)&&rowset->binary){
memset(&time,0,sizeof(time));
_clip_pardc(mp,2,&time.tm_year,&time.tm_mon,&time.tm_mday,&time.tm_wday);
time.tm_year -= 1900;
time.tm_mon--;
bindate = mktime(&time);
_clip_retcn(mp,(char*)(&bindate),4);
} else {
date = _clip_parcl(mp,2,&len);
_clip_retc(mp,date);
// char str[25];
// _pg_out_date(mp,str,rowset->conn->datestyle,rowset->conn->textdate,_clip_pardj(mp,2));
// _clip_retc(mp,str);
}
return 0;
}
int
clip_LEFT(ClipMachine * ClipMachineMemory)
{
int vl = 0;
int i;
char *rp;
char *vp = _clip_parcl(ClipMachineMemory, 1, &vl);
int nl = _clip_parni(ClipMachineMemory, 2);
_clip_retc(ClipMachineMemory, "");
if (vp == NULL)
return 0;
if (nl < 0)
nl = 0;
if (nl > vl)
nl = vl;
rp = malloc(nl + 1);
if (nl > vl)
nl = vl;
for (i = 0; i < nl; i++)
rp[i] = vp[i];
rp[i] = 0;
_clip_retcn_m(ClipMachineMemory, rp, nl);
return 0;
}
int
clip_BITTOC(ClipMachine * mp)
{
unsigned int Num = _clip_parni(mp, 1);
int LenPattern;
char *BitPattern = _clip_parcl(mp, 2, &LenPattern);
char *p, res[] = " ";
unsigned int Mask;
int Len = _clip_parinfo(mp, 0), RealLen;
int t1 = _clip_parinfo(mp, 1);
int t2 = _clip_parinfo(mp, 2);
if (Len < 2 || t1 != NUMERIC_t || t2 != CHARACTER_t)
{
_clip_retc(mp, "");
return _clip_trap_err(mp, EG_ARG, 0, 0, __FILE__, __LINE__, "BITTOC");
}
if (LenPattern > 16)
LenPattern = 16;
if (_clip_parl(mp, 3))
{
for (RealLen = LenPattern, Len = 0, Mask = 1 << (LenPattern - 1); Len < LenPattern; Mask >>= 1, Len++)
if (Num & Mask)
res[Len] = BitPattern[Len];
}
else
{
for (RealLen = 0, p = res, Len = 0, Mask = 1 << (LenPattern - 1); Len < LenPattern; Mask >>= 1, Len++)
int
clip_TRANSLATE_CHARSET(ClipMachine * ClipMachineMemory)
{
int len = 0, r;
char *p1 = _clip_parc(ClipMachineMemory, 1);
char *p2 = _clip_parc(ClipMachineMemory, 2);
unsigned char *str = (unsigned char *) _clip_parcl(ClipMachineMemory, 3, &len);
unsigned char *s;
if (!p1 || !p2 || !str)
return EG_ARG;
if (!strcasecmp(p1, p2))
{
_clip_retcn(ClipMachineMemory, (char *) str, len);
return 0;
}
if (!strcasecmp(p1, "utf-8"))
{
char *result;
if (!_clip_translate_fromutf8(p2, (char *) str, len, &result))
{
_clip_retc(ClipMachineMemory, result);
free(result);
}
else
_clip_retc(ClipMachineMemory, (char *) str);
return 0;
}
if (!strcasecmp(p2, "utf-8"))
{
char *result;
if (!_clip_translate_toutf8(p1, str, len, &result))
{
_clip_retc(ClipMachineMemory, result);
free(result);
}
else
_clip_retc(ClipMachineMemory, (char *) str);
return 0;
}
s = (unsigned char *) malloc(len + 1);
s[len] = 0;
if ((r = _clip_translate_charset(p1, p2, str, s, len)))
return r;
_clip_retcn_m(ClipMachineMemory, (char *) s, len);
return 0;
}
/*
BUNZIP2(cStr) --> cResult
*/
int
clip_BUNZIP2(ClipMachine * mp)
{
int l, r;
unsigned int rl;
char *s, *rp;
s = _clip_parcl(mp, 1, &l);
if (!s || l < 4)
return EG_ARG;
rl = read_ulong(s);
rp = (char *) malloc(rl + 1);
r = BZPREF(bzBuffToBuffDecompress) (rp, &rl, s + 4, l - 4, 0, 0);
if (r != BZ_OK)
{
free(rp);
if (r == BZ_DATA_ERROR)
return EG_ARG;
else
return EG_MEM;
}
_clip_retcn_m(mp, rp, rl);
return 0;
}
int
clip_DISPBOXTERM(ClipMachine * ClipMachineMemory)
{
int Top = _clip_parni(ClipMachineMemory, 1);
int Left = _clip_parni(ClipMachineMemory, 2);
int Bottom = _clip_parni(ClipMachineMemory, 3);
int Right = _clip_parni(ClipMachineMemory, 4);
int cl = 0;
unsigned char *chars = (unsigned char *) _clip_parcl(ClipMachineMemory, 5, &cl);
int chars_n = _clip_parni(ClipMachineMemory, 5);
char *color = _clip_parc(ClipMachineMemory, 6);
if (cl > 0 || !chars)
disp_box(ClipMachineMemory, Top, Left, Bottom, Right, chars, cl, chars_n, color, 0);
else
disp_box(ClipMachineMemory, Top, Left, Bottom, Right, (unsigned char *) (" "), 9, chars_n, color, 0);
return 0;
}
int clip_PG_IN_DATE(ClipMachine* mp){
PG_ROWSET* rowset = (PG_ROWSET*)_clip_fetch_c_item(
mp,_clip_parni(mp,1),_C_ITEM_TYPE_SQL);
char* date;
int len;
if(!rowset){
_clip_trap_err(mp,0,0,0,subsys,ER_NOROWSET,er_norowset);
return 1;
}
if(rowset->binary){
date = _clip_parcl(mp,2,&len);
if(date){
_clip_retdj(mp,*((int*)date)+2451545); // 2451545 - julian date
} // for 01/01/2000
} else {
int m,d,y;
date = _clip_parc(mp,2);
if(date){
y = atoi(date);
m = atoi(date+5);
d = atoi(date+8);
_clip_retdc(mp,y,m,d);
} else {
_clip_retdj(mp,0);
}
}
return 0;
}
int
clip_LIKE(ClipMachine * ClipMachineMemory)
{
int sl, l;
unsigned char *s = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &sl);
unsigned char *str = (unsigned char *) _clip_parcl(ClipMachineMemory, 2, &l);
if (str == 0 || s == 0)
{
_clip_retc(ClipMachineMemory, "");
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "LIKE");
}
_clip_retl(ClipMachineMemory, _clip_glob_match((char *) str, (char *) s, ClipMachineMemory->flags & TRANSLATE_FLAG) > 0);
return 0;
}
int
clip_UDPSENDTO(ClipMachine *mp)
// UDPSENDTO( nCF, cIPaddr, nPort, cMsg, [nLen], [nTimeout] )
{
int fd = _clip_parni(mp, 1);
C_FILE *cf = (C_FILE *) _clip_fetch_c_item(mp, fd, _C_ITEM_TYPE_FILE);
char *ipaddr = _clip_parc(mp, 2);
int port = _clip_parni(mp,3), lenbuf;
char *msg = _clip_parcl(mp,4, &lenbuf);
long len = _clip_parnl(mp,5);
int timeout = _clip_parni(mp,6);
int ret = -1, *err = _clip_fetch_item(mp, HASH_ferror);
struct sockaddr_in sin;
struct timeval tv;
fd_set set;
if (cf == NULL || cf->type != FT_SOCKET)
*err = EBADF;
else
{
if (_clip_parinfo(mp, 5) != NUMERIC_t)
len = lenbuf;
if (len > lenbuf)
len = lenbuf;
if (_clip_parinfo(mp, 6) != NUMERIC_t)
timeout = cf->timeout;
if ( timeout >= 0 ) {
FD_ZERO(&set);
FD_SET(cf->fileno, &set);
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
}
memset( (void *) &sin, 0, sizeof(sin) );
sin.sin_family = PF_INET;
sin.sin_addr.s_addr = inet_addr(ipaddr);
sin.sin_port = htons(port);
if ( timeout < 0 || select( cf->fileno+1, NULL, &set, NULL, &tv ) > 0 )
{
ret = sendto( cf->fileno, msg, len, 0, (struct sockaddr *) &sin, sizeof(sin) );
*err = ret == -1 ? errno : 0;
}
else
#ifdef OS_MINGW
*err = EAGAIN;
#else
*err = ETIMEDOUT;
#endif
}
_clip_retnl(mp, ret);
return 0;
}
int
clip_MLPOS(ClipMachine * ClipMachineMemory)
{
int vl = 0, i, j, len, nstr, ntab, npos = 1, wrap;
char *e, *wrappos = NULL;
char *vp = _clip_parcl(ClipMachineMemory, 1, &vl);
if (vp == NULL)
{
_clip_retni(ClipMachineMemory, 0);
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "MLPOS");
}
len = _clip_parni(ClipMachineMemory, 2);
if (len <= 4)
len = 79;
nstr = _clip_parni(ClipMachineMemory, 3);
if (nstr <= 1)
nstr = 1;
ntab = _clip_parni(ClipMachineMemory, 4);
if (ntab < 1)
ntab = 1;
if (ntab >= len)
ntab = len - 1;
if (_clip_parinfo(ClipMachineMemory, 5) == LOGICAL_type_of_ClipVarType)
wrap = _clip_parl(ClipMachineMemory, 5);
else
wrap = 1;
for (i = 1, j = 1, e = vp; e < vp + vl; e++, j++)
{
if (*e == ' ')
wrappos = e;
if (j >= len || *e == '\n')
{
if (wrap && wrappos != NULL && e < vp + vl - 1 && *e != '\n')
{
if (*(e + 1) == ' ')
e++;
else
e = wrappos;
}
i++;
j = 0;
}
if (*e == '\t')
j += ntab - 1;
if (*e == '\r')
j--;
if (i >= nstr && j >= npos)
break;
}
_clip_retni(ClipMachineMemory, e - vp + 1);
return 0;
}
int
clip_CTOF(ClipMachine * ClipMachineMemory)
{
int SLen;
char *S = _clip_parcl(ClipMachineMemory, 1, &SLen);
_clip_retnd(ClipMachineMemory, *((double *) S));
return 0;
}
int
clip_MLCOUNT(ClipMachine * ClipMachineMemory)
{
int vl = 0, i, j, len, ntab, wrap;
char *e, *wrappos = NULL;
char *vp = _clip_parcl(ClipMachineMemory, 1, &vl);
if (vp == NULL)
{
_clip_retni(ClipMachineMemory, 0);
return 0;
}
len = _clip_parni(ClipMachineMemory, 2);
if (len <= 4)
len = 79;
ntab = _clip_parni(ClipMachineMemory, 3);
if (ntab < 1)
ntab = 1;
if (ntab >= len)
ntab = len - 1;
if (_clip_parinfo(ClipMachineMemory, 5) == LOGICAL_type_of_ClipVarType)
wrap = _clip_parl(ClipMachineMemory, 5);
else
wrap = 1;
for (i = 0, j = 1, e = vp; e < vp + vl; e++, j++)
{
if (*e == ' ')
wrappos = e;
if (j >= len || *e == '\n')
{
if (wrap && wrappos != NULL && e < vp + vl - 1 && *e != '\n')
{
if (*(e + 1) == ' ')
e++;
else
{
e = wrappos;
wrappos = NULL;
}
}
i++;
j = 0;
}
if (*e == '\t')
j += ntab - 1;
if (*e == '\r')
j--;
}
_clip_retni(ClipMachineMemory, i + (j > 1));
return 0;
}
int
clip_SETCLIPBOARDDATA(ClipMachine * mp)
{
int len;
char * data = _clip_parcl(mp,1,&len);
if ( data == NULL )
_clip_retl(mp,0);
else
_clip_retl(mp,to_clipboard((const unsigned char *)data,_clip_parni(mp,2),len));
return 0;
}
int
clip_COLORTON(ClipMachine * ClipMachineMemory)
{
int l, attr = _clip_parni(ClipMachineMemory, 1);
char *s = _clip_parcl(ClipMachineMemory, 1, &l);
if (s != NULL)
attr = _clip_str2attr(s, l);
_clip_retni(ClipMachineMemory, attr);
return 0;
}
int
clip_JUSTRIGHT(ClipMachine * ClipMachineMemory)
{
int l1, l2, i;
unsigned char *e, *ret, *end, *cur;
unsigned char *str = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l1);
int ch = _clip_parni(ClipMachineMemory, 2);
unsigned char *s = (unsigned char *) _clip_parcl(ClipMachineMemory, 2, &l2);
int rset = (*(char *) (_clip_fetch_item(ClipMachineMemory, HASH_csetref)) == 't');
if (s != NULL)
ch = *s;
if (ch == 0)
ch = ' ';
if (str == NULL || l1 == 0)
{
_clip_retc(ClipMachineMemory, "");
return 0;
}
ret = malloc(l1 + 1);
for (e = str + l1 - 1, end = str; e > end && *e == ch; e--);
i = str + l1 - e - 1;
end = str + l1 - i;
for (cur = ret; i > 0; i--, cur++)
*cur = ch;
for (e = str; e < end; e++, cur++)
*cur = *e;
ret[l1] = 0;
if (rset && _clip_par_isref(ClipMachineMemory, 1))
_clip_par_assign_str(ClipMachineMemory, 1, (char *) ret, l1);
_clip_retcn_m(ClipMachineMemory, (char *) ret, l1);
return 0;
}
int clip_ODBC_OUT_TIME(ClipMachine* mp){
int len;
const char* t = _clip_parcl(mp,1,&len);
short int s[3] = {0,0,0};
if(!((_clip_parinfo(mp,1) != CHARACTER_t) || !t || (len < 8))){
s[0] = atoi(t);
s[1] = atoi(t+3);
s[2] = atoi(t+6);
}
_clip_retcn(mp,(char*)s,6);
return 0;
}
int
odbc_createconn(ClipMachine * cm)
{
int dbl,userl,passwdl;
char* db = _clip_parcl(cm,2,&dbl);
char* user = _clip_parcl(cm,3,&userl);
char* passwd = _clip_parcl(cm,4,&passwdl);
ODBC_CONN *conn = NULL;
SQLHDBC tmpconn;
SQLRETURN er;
SQLHENV henv;
char dbms[30];
if(!user)
userl = 0;
if(!passwd)
passwdl = 0;
if((er = SQLAllocEnv(&henv))) goto err;
if((er = SQLAllocConnect(henv,&tmpconn))) goto err;
if((er = SQLConnect(tmpconn,db,dbl,user,userl,passwd,passwdl))) goto err;
/* silly PostgreSQL's ODBC driver */
if((er = SQLGetInfo(tmpconn,SQL_DBMS_NAME,dbms,sizeof(dbms),0)))
goto err;
conn = calloc(sizeof(ODBC_CONN),1);
conn->conn = tmpconn;
conn->vtbl = &vtbl;
conn->henv = henv;
if(strcmp(dbms,"PostgreSQL")==0)
conn->postgres = 1;
return _clip_store_c_item(cm, (void *) conn, _C_ITEM_TYPE_SQL, destroy_odbc_conn);
err:
odbc_error(cm,(conn?conn->loc:0),henv,tmpconn,0,__LINE__,er_connect);
if(conn)
free(conn);
return -1;
}
int
clip_BIN2IPADDR(ClipMachine *mp)
{
int len;
char *addr = _clip_parcl(mp, 1, &len);
if (addr == NULL || len != sizeof(struct in_addr))
_clip_retc(mp, "");
else
_clip_retc(mp, inet_ntoa( *(struct in_addr*)addr));
return 0;
}
