static VALUE
get_value(ValueStruct *val)
{
if (val == NULL)
return Qnil;
if (IS_VALUE_NIL(val))
return Qnil;
switch (ValueType(val)) {
case GL_TYPE_BOOL:
return ValueBool(val) ? Qtrue : Qfalse;
case GL_TYPE_INT:
return INT2NUM(ValueInteger(val));
case GL_TYPE_FLOAT:
return rb_float_new(ValueFloat(val));
case GL_TYPE_NUMBER:
return bigdecimal_new(val);
case GL_TYPE_CHAR:
case GL_TYPE_VARCHAR:
case GL_TYPE_DBCODE:
case GL_TYPE_TEXT:
return rb_str_new2(ValueToString(val, codeset));
case GL_TYPE_BYTE:
case GL_TYPE_BINARY:
if (ValueByte(val) == NULL) {
return Qnil;
}
else {
return rb_str_new(ValueByte(val), ValueByteLength(val));
}
case GL_TYPE_OBJECT:
return INT2NUM(ValueObjectId(val));
case GL_TYPE_ARRAY:
return aryval_new(val, 0);
case GL_TYPE_RECORD:
return recval_new(val, 0);
case GL_TYPE_TIMESTAMP:
return timestamp_new(val);
case GL_TYPE_DATE:
return date_new(val);
default:
rb_raise(rb_eArgError, "unsupported ValueStruct type");
break;
}
return Qnil; /* not reached */
}
static int
value_equal(ValueStruct *val, VALUE obj)
{
if (val == NULL)
return 0;
if (IS_VALUE_NIL(val))
return NIL_P(obj);
switch (ValueType(val)) {
case GL_TYPE_BOOL:
if (ValueBool(val)) {
return obj == Qtrue;
}
else {
return obj == Qfalse;
}
case GL_TYPE_INT:
return ValueInteger(val) == NUM2INT(obj);
case GL_TYPE_FLOAT:
return ValueFloat(val) == NUM2DBL(obj);
case GL_TYPE_NUMBER:
{
VALUE bd = bigdecimal_new(val);
return RTEST(rb_funcall(bd, rb_intern("=="), 1, obj));
}
case GL_TYPE_CHAR:
case GL_TYPE_VARCHAR:
case GL_TYPE_DBCODE:
case GL_TYPE_TEXT:
return strcmp(ValueToString(val, codeset), StringValuePtr(obj)) == 0;
case GL_TYPE_BYTE:
case GL_TYPE_BINARY:
return memcmp(ValueByte(val), StringValuePtr(obj),
ValueByteLength(val)) == 0;
case GL_TYPE_OBJECT:
return ValueInteger(val) == NUM2INT(obj);
default:
return 0;
}
}
extern LargeByteString *
ValueToLBS(
ValueStruct *val,
char *codeset)
{
byte work[SIZE_NUMBUF+1];
byte work2[SIZE_NUMBUF+2];
byte *p
, *q;
int i;
int size;
LargeByteString *ret;
ENTER_FUNC;
if ( val == NULL ) {
ret = NULL;
} else {
dbgprintf("type = %X\n",(int)ValueType(val));
if ( ValueStr(val) == NULL ) {
ValueStr(val) = NewLBS();
}
LBS_EmitStart(ValueStr(val));
if ( IS_VALUE_NIL(val) ) {
LBS_EmitChar(ValueStr(val),CHAR_NIL);
} else
switch (ValueType(val)) {
case GL_TYPE_CHAR:
case GL_TYPE_VARCHAR:
case GL_TYPE_TEXT:
case GL_TYPE_SYMBOL:
case GL_TYPE_DBCODE:
if ( ValueString(val) != NULL ) {
RewindLBS(ValueStr(val));
if ( IS_VALUE_EXPANDABLE(val) ) {
LBS_EmitStringCodeset(ValueStr(val),ValueString(val),
ValueStringSize(val),
ValueStringLength(val),codeset);
if ( ( size = ValueStringLength(val) - ValueSize(val) ) > 0 ) {
for ( ; size > 0 ; size -- ) {
LBS_EmitChar(ValueStr(val),0);
}
}
} else {
LBS_EmitStringCodeset(ValueStr(val),ValueString(val),
ValueStringSize(val),
0,codeset);
}
}
break;
case GL_TYPE_BYTE:
case GL_TYPE_BINARY:
#ifdef BINARY_IS_BASE64
size = ( ( ValueByteLength(val) + 2 ) / 3 ) * 4;
p = (char *)xmalloc(size);
size = EncodeBase64(p,size,ValueByte(val),ValueByteLength(val));
LBS_ReserveSize(ValueStr(val),size+1);
strcpy(ValueStrBody(val),p);
xfree(p);
#else
p = ValueByte(val);
for ( i = 0 ; i < ValueByteLength(val) ; i ++ , p ++ ) {
switch (*p) {
case '\\':
LBS_EmitChar(ValueStr(val),'\\');
LBS_EmitChar(ValueStr(val),'\\');
break;
case '"':
LBS_EmitChar(ValueStr(val),'\\');
LBS_EmitChar(ValueStr(val),'"');
break;
case '/':
LBS_EmitChar(ValueStr(val),'\\');
LBS_EmitChar(ValueStr(val),'/');
break;
case '\b':
LBS_EmitChar(ValueStr(val),'\\');
LBS_EmitChar(ValueStr(val),'b');
break;
case '\f':
LBS_EmitChar(ValueStr(val),'\\');
LBS_EmitChar(ValueStr(val),'f');
break;
case '\n':
LBS_EmitChar(ValueStr(val),'\\');
LBS_EmitChar(ValueStr(val),'n');
break;
case '\r':
LBS_EmitChar(ValueStr(val),'\\');
LBS_EmitChar(ValueStr(val),'r');
break;
case '\t':
LBS_EmitChar(ValueStr(val),'\\');
LBS_EmitChar(ValueStr(val),'t');
break;
default:
if ( isprint(*p) ) {
LBS_EmitChar(ValueStr(val),*p);
} else {
sprintf(work,"\\u%02X",(int)*p);
LBS_EmitString(ValueStr(val),work);
}
break;
}
}
if ( ( size = ValueStringLength(val) - ValueSize(val) ) > 0 ) {
for ( ; size > 0 ; size -- ) {
LBS_EmitByte(ValueStr(val),0);
}
}
#endif
break;
case GL_TYPE_NUMBER:
strcpy(work,ValueFixedBody(val));
p = work;
q = work2;
if ( *p >= 0x70 ) {
*q ++ = '-';
*p ^= 0x40;
}
strcpy(q,p);
if ( ValueFixedSlen(val) > 0 ) {
p = work2 + strlen(work2);
*(p + 1) = 0;
q = p - 1;
for ( i = 0 ; i < ValueFixedSlen(val) ; i ++ ) {
*p -- = *q --;
}
*p = '.';
}
LBS_EmitString(ValueStr(val),work2);
break;
case GL_TYPE_INT:
sprintf(work,"%d",ValueInteger(val));
LBS_EmitString(ValueStr(val),work);
break;
case GL_TYPE_OBJECT:
sprintf(work,"%d",(int)ValueObjectId(val));
LBS_EmitString(ValueStr(val),work);
break;
case GL_TYPE_FLOAT:
sprintf(work,"%g",ValueFloat(val));
LBS_EmitString(ValueStr(val),work);
break;
case GL_TYPE_BOOL:
sprintf(work,"%s",ValueBool(val) ? "TRUE" : "FALSE");
LBS_EmitString(ValueStr(val),work);
break;
case GL_TYPE_TIMESTAMP:
sprintf(work,"%04d%02d%02d%02d%02d%02d",
ValueDateTimeYear(val),
ValueDateTimeMon(val) + 1,
ValueDateTimeMDay(val),
ValueDateTimeHour(val),
ValueDateTimeMin(val),
ValueDateTimeSec(val));
LBS_EmitString(ValueStr(val),work);
break;
case GL_TYPE_DATE:
sprintf(work,"%04d%02d%02d",
ValueDateTimeYear(val),
ValueDateTimeMon(val) + 1,
ValueDateTimeMDay(val));
LBS_EmitString(ValueStr(val),work);
break;
case GL_TYPE_TIME:
sprintf(work,"%02d%02d%02d",
ValueDateTimeHour(val),
ValueDateTimeMin(val),
ValueDateTimeSec(val));
LBS_EmitString(ValueStr(val),work);
break;
default:
break;
}
LBS_EmitEnd(ValueStr(val));
ret = ValueStr(val);
}
LEAVE_FUNC;
return (ret);
}
extern byte *
ValueToBinary(
ValueStruct *val)
{
byte *ret;
ENTER_FUNC;
if ( val == NULL ) {
ret = NULL;
} else {
dbgprintf("type = %X\n",(int)ValueType(val));
if ( ValueStr(val) == NULL ) {
ValueStr(val) = NewLBS();
}
LBS_EmitStart(ValueStr(val));
if ( IS_VALUE_NIL(val) ) {
LBS_EmitChar(ValueStr(val),CHAR_NIL);
} else {
switch (ValueType(val)) {
case GL_TYPE_CHAR:
case GL_TYPE_VARCHAR:
case GL_TYPE_DBCODE:
case GL_TYPE_TEXT:
case GL_TYPE_SYMBOL:
if ( ValueString(val) != NULL ) {
LBS_ReserveSize(ValueStr(val),strlen(ValueString(val))+1,FALSE);
strcpy(ValueStrBody(val),ValueString(val));
} else {
LBS_EmitChar(ValueStr(val),CHAR_NIL);
}
break;
case GL_TYPE_BYTE:
case GL_TYPE_BINARY:
LBS_ReserveSize(ValueStr(val),ValueByteLength(val),FALSE);
memcpy(ValueStrBody(val),ValueByte(val),ValueByteLength(val));
break;
case GL_TYPE_NUMBER:
LBS_ReserveSize(ValueStr(val),sizeof(Fixed),FALSE);
memcpy(ValueStrBody(val),&ValueFixed(val),sizeof(Fixed));
break;
case GL_TYPE_INT:
LBS_ReserveSize(ValueStr(val),sizeof(int),FALSE);
memcpy(ValueStrBody(val),&ValueInteger(val),sizeof(int));
break;
case GL_TYPE_OBJECT:
LBS_ReserveSize(ValueStr(val),sizeof(MonObjectType),FALSE);
memcpy(ValueStrBody(val),&ValueObject(val),sizeof(MonObjectType));
break;
case GL_TYPE_FLOAT:
LBS_ReserveSize(ValueStr(val),sizeof(double),FALSE);
memcpy(ValueStrBody(val),&ValueFloat(val),sizeof(double));
break;
case GL_TYPE_BOOL:
LBS_ReserveSize(ValueStr(val),sizeof(Bool),FALSE);
memcpy(ValueStrBody(val),&ValueBool(val),sizeof(Bool));
break;
case GL_TYPE_TIMESTAMP:
case GL_TYPE_DATE:
case GL_TYPE_TIME:
LBS_ReserveSize(ValueStr(val),sizeof(int)*9,FALSE);
memcpy(ValueStrBody(val),&ValueDateTime(val),sizeof(int)*9);
break;
default:
break;
}
}
ret = ValueStrBody(val);
}
LEAVE_FUNC;
return (ret);
}
static size_t _XML_PackValue2(CONVOPT *opt, unsigned char *p, char *name,
ValueStruct *value) {
char num[SIZE_NAME + 1];
int i;
unsigned char *pp;
if (IS_VALUE_NIL(value))
return (0);
pp = p;
if (value != NULL) {
opt->nIndent++;
p += IndentLine(opt, p);
switch (ValueType(value)) {
case GL_TYPE_ARRAY:
if (opt->recname != NULL) {
p += sprintf(p, "<%s:%s type=\"array\"", opt->recname, name);
} else {
p += sprintf(p, "<%s type=\"array\"", name);
}
p += sprintf(p, " count=\"%d\">", (int)ValueArraySize(value));
p += PutCR(opt, p);
for (i = 0; i < ValueArraySize(value); i++) {
sprintf(num, "%s", name);
p += _XML_PackValue2(opt, p, num, ValueArrayItem(value, i));
}
p += IndentLine(opt, p);
if (opt->recname != NULL) {
p += sprintf(p, "</%s:%s>", opt->recname, name);
} else {
p += sprintf(p, "</%s>", name);
}
break;
case GL_TYPE_ROOT_RECORD:
case GL_TYPE_RECORD:
if (opt->recname != NULL) {
p += sprintf(p, "<%s:%s type=\"record\"", opt->recname, name);
} else {
p += sprintf(p, "<%s type=\"record\"", name);
}
p += sprintf(p, " size=\"%d\">", (int)ValueRecordSize(value));
p += PutCR(opt, p);
for (i = 0; i < ValueRecordSize(value); i++) {
p += _XML_PackValue2(opt, p, ValueRecordName(value, i),
ValueRecordItem(value, i));
}
p += IndentLine(opt, p);
if (opt->recname != NULL) {
p += sprintf(p, "</%s:%s>", opt->recname, name);
} else {
p += sprintf(p, "</%s>", name);
}
break;
case GL_TYPE_ALIAS:
if (opt->recname != NULL) {
p += sprintf(p, "<%s:%s type=\"alias\">", opt->recname, name);
} else {
p += sprintf(p, "<%s type=\"alias\">", name);
}
p += sprintf(p, "%s", ValueAliasName(value));
if (opt->recname != NULL) {
p += sprintf(p, "</%s:%s>", opt->recname, name);
} else {
p += sprintf(p, "</%s>", name);
}
break;
default:
if (opt->recname != NULL) {
p += sprintf(p, "<%s:%s", opt->recname, name);
} else {
p += sprintf(p, "<%s", name);
}
p += sprintf(p, " type=");
switch (ValueType(value)) {
case GL_TYPE_INT:
p += sprintf(p, "\"int\"");
break;
case GL_TYPE_BOOL:
p += sprintf(p, "\"bool\"");
break;
case GL_TYPE_BYTE:
p += sprintf(p, "\"byte\" size=\"%d\"", (int)ValueByteLength(value));
break;
case GL_TYPE_BINARY:
p += sprintf(p, "\"binary\" size=\"%d\"", (int)ValueByteLength(value));
break;
case GL_TYPE_CHAR:
p += sprintf(p, "\"char\" size=\"%d\"", (int)ValueStringLength(value));
break;
case GL_TYPE_VARCHAR:
p += sprintf(p, "\"varchar\" size=\"%d\"",
(int)ValueStringLength(value));
break;
case GL_TYPE_TEXT:
p += sprintf(p, "\"text\" size=\"%d\"", (int)ValueStringLength(value));
break;
case GL_TYPE_SYMBOL:
p +=
sprintf(p, "\"symbol\" size=\"%d\"", (int)ValueStringLength(value));
break;
case GL_TYPE_DBCODE:
p +=
sprintf(p, "\"dbcode\" size=\"%d\"", (int)ValueStringLength(value));
break;
case GL_TYPE_NUMBER:
p += sprintf(p, "\"number\" size=\"%d\" ssize=\"%d\"",
(int)ValueFixedLength(value), (int)ValueFixedSlen(value));
break;
case GL_TYPE_FLOAT:
p += sprintf(p, "\"float\"");
break;
case GL_TYPE_OBJECT:
p += sprintf(p, "\"object\"");
break;
case GL_TYPE_TIMESTAMP:
p += sprintf(p, "\"timestamp\"");
break;
case GL_TYPE_DATE:
p += sprintf(p, "\"date\"");
break;
case GL_TYPE_TIME:
p += sprintf(p, "\"time\"");
break;
default:
break;
}
p += sprintf(p, ">");
if (!IS_VALUE_NIL(value)) {
p += XML_Encode(ValueToString(value, ConvCodeset(opt)), p);
}
if (opt->recname != NULL) {
p += sprintf((char *)p, "</%s:%s>", opt->recname, name);
} else {
p += sprintf((char *)p, "</%s>", name);
}
break;
}
p += PutCR(opt, (char *)p);
opt->nIndent--;
}
return (p - pp);
}
static size_t _XML_SizeValue2(CONVOPT *opt, char *name, ValueStruct *value,
char *buff) {
char num[SIZE_NAME + 1];
int i;
size_t size;
size = 0;
if (value != NULL) {
if (IS_VALUE_NIL(value))
return (0);
opt->nIndent++;
size += IndentLine(opt, NULL);
switch (ValueType(value)) {
case GL_TYPE_ARRAY:
if (opt->recname != NULL) {
size += sprintf(buff, "<%s:%s type=\"array\" count=\"%d\">",
opt->recname, name, (int)ValueArraySize(value));
} else {
size += sprintf(buff, "<%s type=\"array\" count=\"%d\">", name,
(int)ValueArraySize(value));
}
size += PutCR(opt, buff);
for (i = 0; i < ValueArraySize(value); i++) {
sprintf(num, "%s:%d", name, i);
size += _XML_SizeValue2(opt, num, ValueArrayItem(value, i), buff);
}
size += IndentLine(opt, NULL);
if (opt->recname != NULL) {
size += sprintf(buff, "</%s:%s>", opt->recname, name);
} else {
size += sprintf(buff, "</%s>", name);
}
break;
case GL_TYPE_ROOT_RECORD:
case GL_TYPE_RECORD:
if (opt->recname != NULL) {
size += sprintf(buff, "<%s:%s type=\"record\" size=\"%d\">",
opt->recname, name, (int)ValueRecordSize(value));
} else {
size += sprintf(buff, "<%s type=\"record\" size=\"%d\">", name,
(int)ValueRecordSize(value));
}
size += PutCR(opt, buff);
for (i = 0; i < ValueRecordSize(value); i++) {
size += _XML_SizeValue2(opt, ValueRecordName(value, i),
ValueRecordItem(value, i), buff);
}
size += IndentLine(opt, NULL);
if (opt->recname != NULL) {
size += sprintf(buff, "</%s:%s>", opt->recname, name);
} else {
size += sprintf(buff, "</%s>", name);
}
break;
default:
if (opt->recname != NULL) {
size += sprintf(buff, "<%s:%s", opt->recname, name);
} else {
size += sprintf(buff, "<%s", name);
}
size += 6; // " type="
switch (ValueType(value)) {
case GL_TYPE_INT:
size += 5; // "int"
break;
case GL_TYPE_BOOL:
size += 6; // "bool"
break;
case GL_TYPE_BYTE:
size +=
sprintf(buff, "\"byte\" size=\"%d\"", (int)ValueByteLength(value));
break;
case GL_TYPE_BINARY:
size += sprintf(buff, "\"binary\" size=\"%d\"",
(int)ValueByteLength(value));
break;
case GL_TYPE_CHAR:
size += sprintf(buff, "\"char\" size=\"%d\"",
(int)ValueStringLength(value));
break;
case GL_TYPE_VARCHAR:
size += sprintf(buff, "\"varchar\" size=\"%d\"",
(int)ValueStringLength(value));
break;
case GL_TYPE_TEXT:
size += sprintf(buff, "\"text\" size=\"%d\"",
(int)ValueStringLength(value));
break;
case GL_TYPE_SYMBOL:
size += sprintf(buff, "\"symbol\" size=\"%d\"",
(int)ValueStringLength(value));
break;
case GL_TYPE_DBCODE:
size += sprintf(buff, "\"dbcode\" size=\"%d\"",
(int)ValueStringLength(value));
break;
case GL_TYPE_NUMBER:
size +=
sprintf(buff, "\"number\" size=\"%d\" ssize=\"%d\"",
(int)ValueFixedLength(value), (int)ValueFixedSlen(value));
break;
case GL_TYPE_FLOAT:
size += 7; // "float"
break;
case GL_TYPE_OBJECT:
size += 8; // "object"
break;
case GL_TYPE_TIMESTAMP:
size += 9; // "timestamp"
break;
case GL_TYPE_DATE:
size += 4; // "date"
break;
case GL_TYPE_TIME:
size += 8; // "time"
break;
case GL_TYPE_ALIAS:
default:
break;
}
size += 1; // ">"
if (!IS_VALUE_NIL(value)) {
size += XML_EncodeSize(ValueToString(value, ConvCodeset(opt)));
}
if (opt->recname != NULL) {
size += sprintf(buff, "</%s:%s>", opt->recname, name);
} else {
size += sprintf(buff, "</%s>", name);
}
break;
}
size += PutCR(opt, buff);
opt->nIndent--;
}
return (size);
}
extern size_t OpenCOBOL_PackValue(CONVOPT *opt, unsigned char *p,
ValueStruct *value) {
int i;
size_t size;
unsigned char *pp;
pp = p;
if (value != NULL) {
switch (ValueType(value)) {
case GL_TYPE_INT:
*(int32_t *)p = (int32_t)ValueInteger(value);
IntegerC2Cobol(opt, (int32_t *)p);
p += sizeof(int32_t);
break;
case GL_TYPE_FLOAT:
*(double *)p = ValueFloat(value);
p += sizeof(double);
break;
case GL_TYPE_BOOL:
*(char *)p = ValueBool(value) ? 'T' : 'F';
p++;
break;
case GL_TYPE_BYTE:
memcpy(p, ValueByte(value), ValueByteLength(value));
p += ValueByteLength(value);
break;
case GL_TYPE_BINARY:
memclear(p, opt->textsize);
size = (opt->textsize < ValueByteLength(value)) ? opt->textsize
: ValueByteLength(value);
memcpy(p, ValueToBinary(value), size);
p += opt->textsize;
break;
case GL_TYPE_TEXT:
case GL_TYPE_SYMBOL:
size = (opt->textsize < ValueStringLength(value))
? opt->textsize
: ValueStringLength(value);
memcpy(p, ValueToString(value, ConvCodeset(opt)), size);
StringC2Cobol(p, opt->textsize);
p += opt->textsize;
break;
case GL_TYPE_CHAR:
case GL_TYPE_VARCHAR:
case GL_TYPE_DBCODE:
if (IS_VALUE_NIL(value)) {
memclear(p, ValueStringLength(value)); /* LOW-VALUE */
} else {
strncpy(p, ValueToString(value, ConvCodeset(opt)),
ValueStringLength(value));
StringC2Cobol(p, ValueStringLength(value));
}
p += ValueStringLength(value);
break;
case GL_TYPE_NUMBER:
memcpy(p, ValueFixedBody(value), ValueFixedLength(value));
FixedC2Cobol(p, ValueFixedLength(value));
p += ValueFixedLength(value);
break;
case GL_TYPE_OBJECT:
memcpy(p, ValueBody(value), SIZE_UUID);
StringC2Cobol(p, SIZE_UUID);
p += SIZE_UUID;
break;
case GL_TYPE_TIMESTAMP:
p += sprintf(p, "%04d%02d%02d%02d%02d%02d", ValueDateTimeYear(value),
ValueDateTimeMon(value) + 1, ValueDateTimeMDay(value),
ValueDateTimeHour(value), ValueDateTimeMin(value),
ValueDateTimeSec(value));
break;
case GL_TYPE_DATE:
p += sprintf(p, "%04d%02d%02d", ValueDateTimeYear(value),
ValueDateTimeMon(value) + 1, ValueDateTimeMDay(value));
break;
case GL_TYPE_TIME:
p += sprintf(p, "%02d%02d%02d", ValueDateTimeHour(value),
ValueDateTimeMin(value), ValueDateTimeSec(value));
break;
case GL_TYPE_ARRAY:
for (i = 0; i < ValueArraySize(value); i++) {
p += OpenCOBOL_PackValue(opt, p, ValueArrayItem(value, i));
}
break;
case GL_TYPE_ROOT_RECORD:
case GL_TYPE_RECORD:
for (i = 0; i < ValueRecordSize(value); i++) {
p += OpenCOBOL_PackValue(opt, p, ValueRecordItem(value, i));
}
break;
default:
break;
}
}
return (p - pp);
}
