nilopaim
/
tinycobol
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
tinycobol/lib/pictures.c

545 lines
16 KiB
C
Raw Permalink Blame History

//
// Copyright (C) 2001, 2000, 1999, Rildo Pragana, Jim Noeth,
// Andrew Cameron, David Essex.
// Copyright (C) 1993, 1991 Rildo Pragana.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation; either version 2.1,
// or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; see the file COPYING.LIB. If
// not, write to the Free Software Foundation, Inc., 59 Temple Place,
// Suite 330, Boston, MA 02111-1307 USA
/*---------------------------------------------------------------------------*\
| |
| COBOL Compiler Run Time Library -- Pictures |
| See each function's comments for more detail. |
| Independent of compressed PIC implementation: |
| tcob_picExpand() - Returns an expanded version of the PIC string |
| tcob_picCompLength() - Numeric character count |
| tcob_picEditedCompLength() - Numeric-edited character count |
| tcob_picEditedCompDecimals() - Decimal numeric-edited characters count |
| Dependent on compressed PIC implementation: |
| tcob_picElemVal() - Retrieve character value from a specified element |
| tcob_picElemLen() - Retrieve character count from a specified element |
| tcob_picReqLen() - Determine size to allocate for a new compressed PIC |
| tcob_picCreate() - Start a new compressed PIC string |
| tcob_picAppend() - Continue a compressed PIC string |
| |
\*---------------------------------------------------------------------------*/
#include "htcoblib.h"
#include "screenio.h"
extern int bDecimalComma;
/*------------------------------------------------------------------------*\
| |
| tcob_picExpand |
| expand a picture returning a malloc'ed string |
| from: "XAYBZC" (where X, Y, Z are picture characters and |
| A, B, C are binary counts for each character) |
| to: "XXXXYYYZZZZZ" |
| |
\*------------------------------------------------------------------------*/
char * tcob_picExpand( struct fld_desc *f ) {
char *result, c;
unsigned int i, t, tot;
for (i=0, tot=0; tcob_picElemVal(f->pic,i); i++)
tot += tcob_picElemLen(f->pic,i);
result = malloc(tot+1);
for (i=0, tot=0; (c=tcob_picElemVal(f->pic,i)); i++) {
t = tcob_picElemLen(f->pic,i);
memset (&result[tot], c, t);
tot += t;
}
result[tot] = '\0';
/*
#ifdef PICTURE_TESTING
printf("tcob_picexpand: %s\n", result);
free(result);
return NULL;
#else
return result;
#endif
*/
return result;
}
/*------------------------------------------------------------------------*\
| |
| tcob_picCompLength |
| For numeric types, determine the total number of stored digits. |
| Includes 9's. |
| |
\*------------------------------------------------------------------------*/
unsigned int tcob_picCompLength( struct fld_desc *f ) {
unsigned int len=0, i;
char c;
for (i=0; (c=tcob_picElemVal(f->pic,i)); i++) {
if (c == '9')
len += tcob_picElemLen(f->pic,i);
}
return len;
}
/*------------------------------------------------------------------------*\
| |
| tcob_picEditedCompLength |
| For the numeric-edited type, determine the total number of digits |
| available. Includes 9's, Z's,*'s, and multiples of +, -, and the |
| currency sign. |
| |
\*------------------------------------------------------------------------*/
unsigned int tcob_picEditedCompLength( struct fld_desc *f ) {
unsigned int len=0, i;
unsigned int bSeenPlus=0, bSeenMinus=0, bSeenCurrency=0;
char c;
extern char cCurrencySymbol;
for (i=0; (c=tcob_picElemVal(f->pic,i)); i++) {
unsigned int ilen = tcob_picElemLen(f->pic,i);
if (c == '9' || c == 'Z' || c == '*' ||
(bSeenPlus && (c == '+')) ||
(bSeenMinus && (c == '-')) ||
(bSeenCurrency && (c == cCurrencySymbol)) )
len += ilen;
if (!bSeenPlus && (c == '+')) {
bSeenPlus = 1;
len += ilen - 1;
} else if (!bSeenMinus && (c == '-')) {
bSeenMinus = 1;
len += ilen - 1;
} else if (!bSeenCurrency && (c == cCurrencySymbol)) {
bSeenCurrency = 1;
len += ilen - 1;
}
}
return len;
}
unsigned int tcob_picTotalLen( char *pic ) {
int len=0;
while (*pic) {
len += *(pic+1);
pic+=2;
}
return len;
}
/*------------------------------------------------------------------------*\
| |
| tcob_picSignPosition |
| For the numeric- type, determine the position of the sign |
| |
\*------------------------------------------------------------------------*/
unsigned int tcob_picSignPosition( struct fld_desc *f ) {
unsigned int len=0, i;
char c;
int d = DISPLAYFIELD(f->type);
for (i=0; (c=tcob_picElemVal(f->pic,i)); i++) {
unsigned int ilen = tcob_picElemLen(f->pic,i);
len += ilen;
if ((c == '+' || c == '-') || (c == 'S' && d && i == 0)) {
len -= ilen;
return len;
}
}
return -1;
}
/*------------------------------------------------------------------------*\
| |
| tcob_picDecimalPointPosition |
| For the numeric- type, determine the position of the decimal point |
| |
\*------------------------------------------------------------------------*/
unsigned int tcob_picDecimalPointPosition( struct fld_desc *f ) {
unsigned int len=0, i;
extern int bDecimalComma;
char c, cDecimal = (bDecimalComma) ? ',' : '.';
for (i=0; (c=tcob_picElemVal(f->pic,i)); i++) {
unsigned int ilen = tcob_picElemLen(f->pic,i);
len += ilen;
if (c == cDecimal) {
len -= ilen;
return len;
}
}
return -1;
}
/*------------------------------------------------------------------------*\
| |
| tcob_picEditedCompDecimals |
| For the numeric-edited type, determine the total number of digits |
| available after the decimal point. Includes 9's, Z's,*'s, and |
| multiples of +, -, and the currency sign. |
| |
\*------------------------------------------------------------------------*/
unsigned int tcob_picEditedCompDecimals( struct fld_desc *f ) {
unsigned int len=0, i;
int bSeenDecimal=0, bSeenPlus=0, bSeenMinus=0, bSeenCurrency=0;
extern int bDecimalComma;
extern char cCurrencySymbol;
char c, cDecimal = (bDecimalComma) ? ',' : '.';
for (i=0; (c=tcob_picElemVal(f->pic,i)); i++) {
unsigned int ilen = tcob_picElemLen(f->pic,i);
if (bSeenDecimal && // Must find the decimal point first
(c == '9' || c == 'Z' || c == '*' ||
(bSeenPlus && (c == '+')) ||
(bSeenMinus && (c == '-')) ||
(bSeenCurrency && (c == cCurrencySymbol)) ) )
len += ilen;
if (!bSeenDecimal && (c == cDecimal)) {
bSeenDecimal = 1;
} else if (!bSeenPlus && (c == '+')) {
bSeenPlus = 1;
if (bSeenDecimal)
len += ilen - 1;
} else if (!bSeenMinus && (c == '-')) {
bSeenMinus = 1;
if (bSeenDecimal)
len += ilen - 1;
} else if (!bSeenCurrency && (c == cCurrencySymbol)) {
bSeenCurrency = 1;
if (bSeenDecimal)
len += ilen - 1;
}
}
return len;
}
/*------------------------------------------------------------------------*\
| |
| tcob_picElemLen & tcob_picElemVal |
| Determine the length or value of element i in array p. |
| Each element is composed of an 8-bit character and an 8-bit length. |
| |
\*------------------------------------------------------------------------*/
unsigned int tcob_picElemLen(char *p, unsigned int i) {
return ( (unsigned int)(((unsigned short *)p)[i] >> 8) );
}
char tcob_picElemVal(char *p, unsigned int i) {
return ( ((unsigned short *)p)[i] & 0x0ff );
}
/*------------------------------------------------------------------------*\
| |
| tcob_picReqLen |
| Determine number of bytes to request for holding a compressed PIC |
| string of i elements. |
| |
\*------------------------------------------------------------------------*/
unsigned int tcob_picReqLen(unsigned int i) {
/* Currently using a 1-byte value and a 1-byte length for each
* element, plus a 1-byte NULL to indicate the end */
return ((i*2)+1);
}
/*------------------------------------------------------------------------*\
| |
| tcob_picCreate |
| Create a new PIC string and place in p. |
| |
\*------------------------------------------------------------------------*/
char *tcob_picCreate(char *p, unsigned int len, ...) {
char pc;
unsigned int i=0, ilen;
va_list args;
va_start(args, len);
while ((pc=va_arg(args,int))) {
for (ilen=va_arg(args, int); ilen>255; ilen-=255) {
if (i+1>=len)
break;
p[i] = pc;
p[i+1] = 255;
ilen -= 255;
i += 2;
}
if (i+1>=len)
break;
p[i] = pc;
p[i+1] = ilen;
i += 2;
}
if (i<len)
p[i] = '\0';
else if (i>1)
p[i-2] = '\0';
else if (len==1)
p[0] = '\0';
va_end(args);
return p;
}
/*------------------------------------------------------------------------*\
| |
| tcob_picAppend |
| Continue the PIC string found in p. |
| |
\*------------------------------------------------------------------------*/
char *tcob_picAppend(char *p, unsigned int len, ...) {
char pc;
unsigned int i, ilen;
va_list args;
for (i=0; p[i]; i+=2) ;
va_start(args, len);
while ((pc=va_arg(args,int))) {
for (ilen=va_arg(args, int); ilen>255; ilen-=255) {
if (i+1>=len)
break;
p[i] = pc;
p[i+1] = 255;
ilen -= 255;
i += 2;
}
if (i+1>=len)
break;
p[i] = pc;
p[i+1] = ilen;
i += 2;
}
if (i<len)
p[i] = '\0';
else if (i>1)
p[i-2] = '\0';
else if (len==1)
p[0] = '\0';
va_end(args);
return p;
}
/*------------------------------------------------------------------------*\
| |
| tcob_picChangeChar |
| change the PIC string char in p. |
| |
\*------------------------------------------------------------------------*/
void tcob_picChangeChar(char *p, int i, char c) {
p[i*2]= c;
}
/*-----------------------------------------------------------
* Classify picture type
* receives a compressed pic pointer
* returns picture type
*/
char tcob_classifyPic( char *p ) {
int i;
char type=0;
for (i=0; p[i]; i+=2) {
switch (p[i]) {
case 'A':
if ((type != DTYPE_ALPHANUMERIC && type != DTYPE_EDITED)
|| !type)
type = DTYPE_ALPHA;
break;
case 'X':
if (type == DTYPE_DISPLAY || !type)
type = DTYPE_ALPHANUMERIC;
break;
case 'Z':
type=DTYPE_EDITED;
break;
case '9':
if (!type)
type=DTYPE_DISPLAY;
break;
case 'V':
case 'P':
case 'S':
break;
case '.':
case ',':
case '0':
case 'B':
case '/':
case '+':
case '-':
case '*':
case 'C':
case 'R':
case 'D':
type=DTYPE_EDITED;
break;
}
}
return type;
}
/*********************************************
tcob_isNumEdit
check if a picture stands for a numeric-edited item (true) or
alphanumeric-edited (false).
Standard: ISO/IEC 1989:2001 (pp.323-324)
---------------------------
13.16.38.3 General Rules
...
FORMAT 1
...
7) To define an item as alphanumeric-edited, character-string-1 shall
include:
- at least one symbol 'A' or 'X', and
- at least one of the symbols from the set 'B', '0', '/'.
**********************************************/
int tcob_isNumEdit(char *p) {
char cDecimalChar = '.';
int i,dsep=0;
int axfound=0;
int bzslfound=0;
if (bDecimalComma)
cDecimalChar = ',';
for (i=0; p[i]; i+=2) {
switch (p[i]) {
/* the standard says we must find one of those below, at least,
but for dates (pic 99/99/999) which is visibly not
numeric-edited, there is none 'A' or 'X'. So let's not
require this until someone explains me what to do here. */
case 'A':
case 'X':
axfound=1;
break;
/* don't count a 'B' after 'D' (DB) */
case 'D':
if (p[i+1]==1 && p[i+2]=='B' && p[i+3]==1) {
i+=2;
continue;
}
case '.':
case ',':
if (p[i] == cDecimalChar) {
if (dsep++) {
return 0;
}
/* make sure there are no repetitions here */
if (p[i+1] > 1) {
return 0;
}
}
continue;
case 'B':
case '0':
case '/':
bzslfound=1;
break;
}
}
if (bzslfound && axfound)
return 0;
else
return 1;
}
int tcob_isNumeric(char *p) {
int i;
for (i=0; p[i]; i+=2) {
switch (p[i]) {
case 'S': // walter 13-12-05
continue;
case '9':
continue;
case 'V':
continue;
default:
return 0;
}
}
return 1;
}
int tcob_isZNum(char *p) {
int i;
for (i=0; p[i]; i+=2) {
switch (p[i]) {
case '-':
case ',':
case '.':
case '9':
case 'Z':
continue;
default:
return 0;
}
}
return 1;
}
int tcob_isAlpha(char *p) {
int i;
for (i=0; p[i]; i+=2) {
switch (p[i]) {
case 'A':
case 'X':
return 1;
}
}
return 0;
}
/* check if the picture has any pic Z string */
int tcob_hasZ(char *p) {
int i;
for (i=0; p[i]; i+=2) {
switch (p[i]) {
case 'Z':
return 1;
}
}
return 0;
}
/*********************
how many significative characters (Z,X,A,9,*) there
are in the picture
**********************/
int tcob_picCharLen( unsigned char *pic ) {
int n=0;
while (*pic) {
if (strchr("9ZXA*",*pic)) {
n+=*(pic+1);
}
pic += 2;
}
return n;
}
Reference in New Issue View Git Blame Copy Permalink