Exemple #1
0
unsigned char *
cob_external_addr (const char *exname, const int exlength)
{
	static struct cob_external *basext = NULL;

	struct cob_external *eptr;

	for (eptr = basext; eptr; eptr = eptr->next) {
		if (!strcmp (exname, eptr->ename)) {
			if (exlength > eptr->esize) {
				cob_runtime_error ("EXTERNAL item '%s' has size > %d",
						   exname, exlength);
				cob_stop_run (1);
			}
			cob_initial_external = 0;
			return (ucharptr)eptr->ext_alloc;
		}
	}
	eptr = cob_malloc (sizeof (struct cob_external));
	eptr->next = basext;
	eptr->esize = exlength;
	eptr->ename = cob_malloc (strlen (exname) + 1);
	strcpy (eptr->ename, exname);
	eptr->ext_alloc = cob_malloc ((size_t)exlength);
	basext = eptr;
	cob_initial_external = 1;
	return (ucharptr)eptr->ext_alloc;
}
Exemple #2
0
void
cob_display_env_value (cob_field *f)
{
	char	*p;
	char	*env2;
	size_t	len;

	if (!cob_local_env) {
		cob_set_exception (COB_EC_IMP_DISPLAY);
		return;
	}
	if (!*cob_local_env) {
		cob_set_exception (COB_EC_IMP_DISPLAY);
		return;
	}
	env2 = cob_malloc (f->size + 1);
	cob_field_to_string (f, env2);
	len = strlen (cob_local_env) + strlen (env2) + 3;
	p = cob_malloc (len);
	sprintf (p, "%s=%s", cob_local_env, env2);
	if (putenv (p) != 0) {
		cob_set_exception (COB_EC_IMP_DISPLAY);
	}
	free (env2);
}
void
cob_unstring_init (cob_field *src, cob_field *ptr, const size_t num_dlm)
{
	static size_t	udlmcount = 0;

	unstring_src_copy = *src;
	unstring_src = &unstring_src_copy;
	unstring_ptr = NULL;
	if (ptr) {
		unstring_ptr_copy = *ptr;
		unstring_ptr = &unstring_ptr_copy;
	}

	unstring_offset = 0;
	unstring_count = 0;
	unstring_ndlms = 0;
	cob_exception_code = 0;
	if (!dlm_list) {
		if (num_dlm <= DLM_DEFAULT_NUM) {
			dlm_list = cob_malloc (DLM_DEFAULT_NUM * sizeof(struct dlm_struct));
			udlmcount = DLM_DEFAULT_NUM;
		} else {
			dlm_list = cob_malloc (num_dlm * sizeof(struct dlm_struct));
			udlmcount = num_dlm;
		}
	} else {
		if (num_dlm > udlmcount) {
			free (dlm_list);
			dlm_list = cob_malloc (num_dlm * sizeof(struct dlm_struct));
			udlmcount = num_dlm;
		}
	}

	if (unstring_ptr) {
		unstring_offset = cob_get_int (unstring_ptr) - 1;
		if (unstring_offset < 0 || unstring_offset >= (int)unstring_src->size) {
			cob_set_exception (COB_EC_OVERFLOW_UNSTRING);
		}
	}

#ifdef	I18N_UTF8
	/* I18N_UTF8: No offset arrangement needed also in NATIONAL. */
#else /*!I18N_UTF8*/
	if (COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL ||
	    COB_FIELD_TYPE (unstring_src) == COB_TYPE_NATIONAL_EDITED) {
		unstring_offset *= 2;
	}
#endif /*I18N_UTF8*/
}
Exemple #4
0
void
cob_accept_command_line (cob_field *f)
{
	char	*buff;
	size_t	i;
	size_t	size;
	size_t	len;

	if (commlncnt) {
		cob_memcpy (f, commlnptr, (int)commlncnt);
		return;
	}
	buff = cob_malloc (COB_MEDIUM_BUFF);
	size = 0;
	for (i = 1; i < (size_t)cob_argc; ++i) {
		len = strlen (cob_argv[i]);
		if (size + len >= COB_MEDIUM_BUFF) {
			/* overflow */
			break;
		}
		memcpy (buff + size, cob_argv[i], len);
		size += len;
		buff[size++] = ' ';
	}
	cob_memcpy (f, (ucharptr)buff, (int)size);
	free (buff);
}
Exemple #5
0
void
cob_init_strings (void)
{
	inspect_mark = cob_malloc ((size_t)COB_NORMAL_BUFF);
	dlm_list = cob_malloc (DLM_DEFAULT_NUM * sizeof(struct dlm_struct));
	inspect_mark_size = COB_NORMAL_BUFF;
	dlm_list_size = DLM_DEFAULT_NUM;
	figurative_ptr = NULL;
	figurative_size = 0;
	alpha_fld.size = 0;
	alpha_fld.data = NULL;
	alpha_fld.attr = &const_alpha_attr;
	str_cob_low.size = 1;
	str_cob_low.data = (cob_u8_ptr)"\0";
	str_cob_low.attr = &const_strall_attr;
}
Exemple #6
0
static void
alloc_figurative (const cob_field *f1, const cob_field *f2)
{

	unsigned char		*s;
	size_t			size1;
	size_t			size2;
	size_t			n;

	size2 = f2->size;
	if (size2 > figurative_size) {
		if (figurative_ptr) {
			free (figurative_ptr);
		}
		figurative_ptr = cob_malloc (size2);
		figurative_size = size2;
	}
	size1 = 0;
	s = figurative_ptr;
	for (n = 0; n < size2; ++n, ++s) {
		*s = f1->data[size1];
		size1++;
		if (size1 >= f1->size) {
			size1 = 0;
		}
	}
	alpha_fld.size = size2;
	alpha_fld.data = figurative_ptr;
}
Exemple #7
0
void
cob_unstring_init (cob_field *src, cob_field *ptr, const size_t num_dlm)
{
	unstring_src_copy = *src;
	unstring_src = &unstring_src_copy;
	unstring_ptr = NULL;
	if (ptr) {
		unstring_ptr_copy = *ptr;
		unstring_ptr = &unstring_ptr_copy;
	}

	unstring_offset = 0;
	unstring_count = 0;
	unstring_ndlms = 0;
	cob_set_exception (0);
	if (num_dlm > dlm_list_size) {
		free (dlm_list);
		dlm_list = cob_malloc (num_dlm * sizeof(struct dlm_struct));
		dlm_list_size = num_dlm;
	}

	if (unstring_ptr) {
		unstring_offset = cob_get_int (unstring_ptr) - 1;
		if (unstring_offset < 0 || unstring_offset >= (int)unstring_src->size) {
			cob_set_exception (COB_EC_OVERFLOW_UNSTRING);
		}
	}
}
Exemple #8
0
void
cob_allocate (unsigned char **dataptr, cob_field *retptr, cob_field *sizefld)
{
	void			*mptr = NULL;
	struct cob_alloc_cache	*cache_ptr;
	int			fsize;

	cob_exception_code = 0;
	fsize = cob_get_int (sizefld);
	if (fsize > 0) {
		cache_ptr = cob_malloc (sizeof (struct cob_alloc_cache));
		mptr = malloc ((size_t)fsize);
		if (!mptr) {
			cob_set_exception (COB_EC_STORAGE_NOT_AVAIL);
			free (cache_ptr);
		} else {
			memset (mptr, 0, (size_t)fsize);
			cache_ptr->cob_pointer = mptr;
			cache_ptr->size = (size_t)fsize;
			cache_ptr->next = cob_alloc_base;
			cob_alloc_base = cache_ptr;
		}
	}
	if (dataptr) {
		*dataptr = (unsigned char *)mptr;
	}
	if (retptr) {
		*(void **)(retptr->data) = mptr;
	}
}
void
cob_inspect_init (cob_field *var, const int replacing)
{
	size_t		i;
	size_t		digcount;

	inspect_var_copy = *var;
	inspect_var = &inspect_var_copy;
	inspect_replacing = replacing;
	inspect_sign = cob_get_sign (var);
	inspect_size = COB_FIELD_SIZE (var);
	inspect_data = COB_FIELD_DATA (var);
	inspect_start = NULL;
	inspect_end = NULL;
	digcount = inspect_size * sizeof (int);
	if (digcount > lastsize) {
		free (inspect_mark);
		inspect_mark = cob_malloc (digcount);
		lastsize = digcount;
	}
	for (i = 0; i < inspect_size; i++) {
		inspect_mark[i] = -1;
	}
	cob_exception_code = 0;
}
Exemple #10
0
void
cob_display_command_line (cob_field *f)
{
	if (commlnptr) {
		free (commlnptr);
	}
	commlnptr = cob_malloc (f->size);
	commlncnt = f->size;
	memcpy (commlnptr, f->data, commlncnt);
}
Exemple #11
0
void
cob_table_sort_init (const int nkeys, const unsigned char *collating_sequence)
{
	sort_nkeys = 0;
	sort_keys = cob_malloc (nkeys * sizeof (struct cob_file_key));
	if (collating_sequence) {
		sort_collate = collating_sequence;
	} else {
		sort_collate = cob_current_module->collating_sequence;
	}
}
Exemple #12
0
void
cob_display_environment (cob_field *f)
{
	if (!cob_local_env) {
		cob_local_env = cob_malloc (COB_SMALL_BUFF);
	}
	if (f->size > COB_SMALL_MAX) {
		cob_set_exception (COB_EC_IMP_DISPLAY);
		return;
	}
	cob_field_to_string (f, cob_local_env);
}
void
cob_init_strings (void)
{
	inspect_mark = cob_malloc (COB_MEDIUM_BUFF);
	lastsize = COB_MEDIUM_BUFF;
	alpha_attr.type = COB_TYPE_ALPHANUMERIC;
	alpha_attr.digits = 0;
	alpha_attr.scale = 0;
	alpha_attr.flags = 0;
	alpha_attr.pic = NULL;
	alpha_fld.size = 0;
	alpha_fld.data = NULL;
	alpha_fld.attr = &alpha_attr;
}
void
cob_inspect_before (const cob_field *str)
{
	unsigned char	*p;
	unsigned char	*data;
	size_t		size;
	int		sign;
	char		*buf = NULL;
	unsigned char	*p2;
	unsigned int	n;
	int		fig;

	switch (COB_FIELD_TYPE (str)) {
	case COB_TYPE_NUMERIC_DISPLAY:
		data = COB_FIELD_DATA (str);
		size = COB_FIELD_SIZE (str);
		sign = cob_get_sign ((cob_field *)str);
		n = 0;
		fig = 0;
		while (size > 1 && *data == '0') {
			size--;
			data++;
		}
		while (size--) {
			n = n * 10 + cob_d2i (*data++);
			fig++;
		}
		buf = cob_malloc (fig);
		sprintf (buf, "%d", n);
		p2 = (unsigned char *)buf;
		break;
	default:
		fig = str->size;
		p2 = str->data;
		break;
	}

	for (p = inspect_start; p < inspect_end - fig + 1; p++) {
		if (memcmp (p, p2, fig) == 0) {
			inspect_end = p;
			break;
		}
	}

	if (buf) {
		free (buf);
	}
}
Exemple #15
0
void
cob_get_environment (cob_field *envname, cob_field *envval)
{
	const char	*p;
	char		*buff;

	if (envname->size < COB_SMALL_BUFF) {
		buff = cob_malloc (COB_SMALL_BUFF);
		cob_field_to_string (envname, buff);
		p = getenv (buff);
		if (!p) {
			cob_set_exception (COB_EC_IMP_ACCEPT);
			p = " ";
		}
		cob_memcpy (envval, (ucharptr)p, (int) strlen (p));
		free (buff);
	} else {
		cob_set_exception (COB_EC_IMP_ACCEPT);
		p = " ";
		cob_memcpy (envval, (ucharptr)p, (int) strlen (p));
	}
}
Exemple #16
0
int
CBL_ERROR_PROC (unsigned char *x, unsigned char *pptr)
{
	struct handlerlist	*hp = NULL;
	struct handlerlist	*h = hdlrs;
	int			(**p)(char *s) = NULL;

	COB_CHK_PARMS (CBL_ERROR_PROC, 2);

	memcpy (&p, &pptr, sizeof (void *));
	if (!p || !*p) {
		return -1;
	}
	/* remove handler anyway */
	while (h != NULL) {
		if (h->proc == *p) {
			if (hp != NULL) {
				hp->next = h->next;
			} else {
				hdlrs = h->next;
			}
			if (hp) {
				free (hp);
			}
			break;
		}
		hp = h;
		h = h->next;
	}
	if (*x != 0) {	/* remove handler */
		return 0;
	}
	h = cob_malloc (sizeof(struct handlerlist));
	h->next = hdlrs;
	h->proc = *p;
	hdlrs = h;
	return 0;
}
Exemple #17
0
int
SYSTEM (const unsigned char *cmd)
{
	char	*buff;
	int	i;

	COB_CHK_PARMS (SYSTEM, 1);

	if (cob_current_module->cob_procedure_parameters[0]) {
		i = (int)cob_current_module->cob_procedure_parameters[0]->size;
		if (i > COB_MEDIUM_MAX) {
			cob_runtime_error ("Parameter to SYSTEM call is larger than 8192 characters");
			cob_stop_run (1);
		}
		i--;
		for (; i >= 0; i--) {
			if (cmd[i] != ' ' && cmd[i] != 0) {
				break;
			}
		}
		if (i >= 0) {
			buff = cob_malloc ((size_t)(i + 2));
			memcpy (buff, cmd, (size_t)(i + 1));
			if (cob_screen_initialized) {
				cob_screen_set_mode (0);
			}
			i = system (buff);
			free (buff);
			if (cob_screen_initialized) {
				cob_screen_set_mode (1);
			}
			return i;
		}
	}
	return 1;
}
Exemple #18
0
void
cob_check_numeric (cob_field *f, const char *name)
{
	unsigned char	*data;
	char		*p;
	char		*buff;
	size_t		i;

	if (!cob_is_numeric (f)) {
		buff = cob_malloc (COB_SMALL_BUFF);
		p = buff;
		data = f->data;
		for (i = 0; i < f->size; ++i) {
			if (isprint (data[i])) {
				*p++ = data[i];
			} else {
				p += sprintf (p, "\\%03o", data[i]);
			}
		}
		*p = '\0';
		cob_runtime_error ("'%s' not numeric: '%s'", name, buff);
		cob_stop_run (1);
	}
}
Exemple #19
0
void
cob_screen_accept (cob_screen *s, cob_field *line, cob_field *column)
{
	struct cob_inp_struct	*sptr;
	struct cob_inp_struct	*sptr2;
	size_t			idx;
	size_t			n;
	size_t			posu;
	size_t			posd;
	size_t			prevy;
	size_t			firsty;
	int			starty;

	if (!cob_screen_initialized) {
		cob_screen_init ();
	}
	if (!cob_base_inp) {
		cob_base_inp = cob_malloc (COB_INP_SIZE);
	} else {
		memset (cob_base_inp, 0, COB_INP_SIZE);
	}
	cob_exception_code = 0;
	cob_current_y = 0;
	cob_current_x = 0;
	totl_index = 0;
	move (0, 0);
	cob_prep_input (s);
	/* No input fields is an error */
	if (!totl_index) {
		cob_check_pos_status (8000);
		return;
	}
	qsort (cob_base_inp, totl_index, sizeof(struct cob_inp_struct), compare_yx);
	sptr = cob_base_inp;
	starty = sptr->this_y;
	posu = 0;
	posd = 0;
	prevy = 0;
	firsty = 0;
	/* Set up array for Cursor UP/DOWN */
	for (n = 0; n < totl_index; n++) {
		sptr = cob_base_inp + n;
		if (sptr->this_y > starty) {
			if (!firsty) {
				firsty = n;
			}
			starty = sptr->this_y;
			sptr2 = cob_base_inp + posd;
			for (idx = posd; idx < n; idx++, sptr2++) {
				sptr2->down_index = n;
			}
			posu = prevy;
			prevy = n;
			posd = n;
		}
		sptr->up_index = posu;
	}
	sptr = cob_base_inp;
	for (n = 0; n < firsty; n++, sptr++) {
		sptr->up_index = posd;
	}
	curr_index = 0;
	global_return = 0;
	cob_screen_get_all ();
	cob_check_pos_status (global_return);
}
Exemple #20
0
void
cob_init (int argc, char **argv)
{
	char	*s;
	size_t	i;
	char	buff[32];

	if (!cob_initialized) {
		cob_set_signal ();

		cob_argc = argc;
		cob_argv = argv;

		/* Get emergency buffer */
		runtime_err_str = cob_malloc (COB_ERRBUF_SIZE);

#ifdef	HAVE_SETLOCALE
		setlocale (LC_ALL, "");
		setlocale (LC_NUMERIC, "C");
		s = setlocale (LC_ALL, NULL);
		if (s) {
			locale_save = strdup (s);
		}
#endif
#ifdef	ENABLE_NLS
		bindtextdomain (PACKAGE, LOCALEDIR);
		textdomain (PACKAGE);
#endif

/* Dirty hack until we implement something better */
#if defined(_WIN32) && !defined(_MSC_VER)
		_setmode (_fileno (stdin), _O_BINARY);
		_setmode (_fileno (stdout), _O_BINARY);
		_setmode (_fileno (stderr), _O_BINARY);
#endif

		cob_init_numeric ();
		cob_init_strings ();
		cob_init_move ();
		cob_init_intrinsic ();
		cob_init_fileio ();
		cob_init_termio ();
		cob_init_call ();

		for (i = 0; i < 8; ++i) {
			memset (buff, 0, sizeof (buff));
			snprintf (buff, 31, "COB_SWITCH_%d", (int)(i + 1));
			s = getenv (buff);
			if (s && strcasecmp (s, "ON") == 0) {
				cob_switch[i] = 1;
			} else {
				cob_switch[i] = 0;
			}
		}

		s = getenv ("COB_LINE_TRACE");
		if (s && (*s == 'Y' || *s == 'y')) {
			cob_line_trace = 1;
		}

		cob_initialized = 1;
	}
}
Exemple #21
0
static int
ORBITS_ (const int entry)
{
  /* Local variables */
  #include "orbits.c.l.h"

  static int initialized = 0;
  static cob_field *cob_user_parameters[COB_MAX_FIELD_PARAMS];
  static struct cob_module module = { NULL, NULL, NULL, NULL, cob_user_parameters, 0, '.', '$', ',', 1, 1, 1, 0 };

  /* Start of function code */

  /* CANCEL callback handling */
  if (unlikely(entry < 0)) {
  	if (!initialized) {
  		return 0;
  	}
  	cob_close (h_ENTRADA, 0, NULL);
  	cob_close (h_SORTIDA, 0, NULL);
  	mpz_clear (d0.value);
  	d0.scale = 0;
  	mpz_clear (d1.value);
  	d1.scale = 0;
  	mpz_clear (d2.value);
  	d2.scale = 0;
  	mpz_clear (d3.value);
  	d3.scale = 0;
  	mpz_clear (d4.value);
  	d4.scale = 0;
  	initialized = 0;
  	return 0;
  }

  /* Initialize frame stack */
  frame_ptr = &frame_stack[0];
  frame_ptr->perform_through = 0;

  /* Push module stack */
  module.next = cob_current_module;
  cob_current_module = &module;

  /* Initialize program */
  if (unlikely(initialized == 0))
    {
      if (!cob_initialized) {
        cob_fatal_error (COB_FERROR_INITIALIZED);
      }
      cob_check_version (COB_SOURCE_FILE, COB_PACKAGE_VERSION, COB_PATCH_LEVEL);
      /* Initialize decimal numbers */
      cob_decimal_init (&d0);
      cob_decimal_init (&d1);
      cob_decimal_init (&d2);
      cob_decimal_init (&d3);
      cob_decimal_init (&d4);

      (*(int *) (b_1)) = 0;

      if (!h_ENTRADA)
      {
        h_ENTRADA = cob_malloc (sizeof(cob_file));
      }
      h_ENTRADA->select_name = (const char *)"ENTRADA";
      h_ENTRADA->file_status = h_ENTRADA_status;
      memset (h_ENTRADA_status, '0', 2);
      h_ENTRADA->assign = &c_1;
      h_ENTRADA->record = &f_14;
      h_ENTRADA->record_size = NULL;
      h_ENTRADA->record_min = 0;
      h_ENTRADA->record_max = 33;
      h_ENTRADA->nkeys = 0;
      h_ENTRADA->keys = NULL;
      h_ENTRADA->file = NULL;
      h_ENTRADA->organization = 1;
      h_ENTRADA->access_mode = 1;
      h_ENTRADA->lock_mode = 0;
      h_ENTRADA->open_mode = 0;
      h_ENTRADA->flag_optional = 0;
      h_ENTRADA->last_open_mode = 0;
      h_ENTRADA->special = 0;
      h_ENTRADA->flag_nonexistent = 0;
      h_ENTRADA->flag_end_of_file = 0;
      h_ENTRADA->flag_begin_of_file = 0;
      h_ENTRADA->flag_first_read = 0;
      h_ENTRADA->flag_read_done = 0;
      h_ENTRADA->flag_select_features = 0;
      h_ENTRADA->flag_needs_nl = 0;
      h_ENTRADA->flag_needs_top = 0;
      h_ENTRADA->file_version = 0;
      if (!h_SORTIDA)
      {
        h_SORTIDA = cob_malloc (sizeof(cob_file));
      }
      h_SORTIDA->select_name = (const char *)"SORTIDA";
      h_SORTIDA->file_status = h_SORTIDA_status;
      memset (h_SORTIDA_status, '0', 2);
      h_SORTIDA->assign = &c_2;
      h_SORTIDA->record = &f_16;
      h_SORTIDA->record_size = NULL;
      h_SORTIDA->record_min = 0;
      h_SORTIDA->record_max = 80;
      h_SORTIDA->nkeys = 0;
      h_SORTIDA->keys = NULL;
      h_SORTIDA->file = NULL;
      h_SORTIDA->organization = 1;
      h_SORTIDA->access_mode = 1;
      h_SORTIDA->lock_mode = 0;
      h_SORTIDA->open_mode = 0;
      h_SORTIDA->flag_optional = 0;
      h_SORTIDA->last_open_mode = 0;
      h_SORTIDA->special = 0;
      h_SORTIDA->flag_nonexistent = 0;
      h_SORTIDA->flag_end_of_file = 0;
      h_SORTIDA->flag_begin_of_file = 0;
      h_SORTIDA->flag_first_read = 0;
      h_SORTIDA->flag_read_done = 0;
      h_SORTIDA->flag_select_features = 0;
      h_SORTIDA->flag_needs_nl = 0;
      h_SORTIDA->flag_needs_top = 0;
      h_SORTIDA->file_version = 0;

      initialized = 1;
    }

  /* Allocate LOCAL storage */
  b_17 = cob_malloc (24);
  b_21 = cob_malloc (24);
  b_25 = cob_malloc (24);
  b_29 = cob_malloc (24);
  b_33 = cob_malloc (24);
  b_37 = cob_malloc (24);
  b_41 = cob_malloc (24);
  b_45 = cob_malloc (8);
  b_46 = cob_malloc (4);
  b_47 = cob_malloc (8);
  b_48 = cob_malloc (8);
  b_49 = cob_malloc (8);
  b_50 = cob_malloc (8);
  b_51 = cob_malloc (8);
  b_52 = cob_malloc (4);
  b_53 = cob_malloc (1);
  b_55 = cob_malloc (56);
  b_61 = cob_malloc (56);
  b_67 = cob_malloc (56);

  /* Initialialize LOCAL storage */
  {double temp = 0.0; memcpy (b_17, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_17 + 8, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_17 + 16, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_21, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_21 + 8, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_21 + 16, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_25, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_25 + 8, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_25 + 16, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_29, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_29 + 8, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_29 + 16, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_33, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_33 + 8, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_33 + 16, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_37, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_37 + 8, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_37 + 16, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_41, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_41 + 8, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_41 + 16, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_45, (char *)&temp, sizeof(temp));}
  memset (b_46, 0, 4);
  {double temp = 0.0; memcpy (b_47, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_48, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_49, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_50, (char *)&temp, sizeof(temp));}
  {double temp = 0.0; memcpy (b_51, (char *)&temp, sizeof(temp));}
  memset (b_52, 0, 4);
  *(unsigned char *)(b_53) = 32;
  memcpy (b_55, "X", 1);
  memset (b_55 + 1, 32, 17);
  *(unsigned char *)(b_55 + 18) = 32;
  memcpy (b_55 + 19, "Y", 1);
  memset (b_55 + 19 + 1, 32, 17);
  *(unsigned char *)(b_55 + 37) = 32;
  memcpy (b_55 + 38, "Z", 1);
  memset (b_55 + 38 + 1, 32, 17);
  memset (b_61, 61, 18);
  *(unsigned char *)(b_61 + 18) = 32;
  memset (b_61 + 19, 61, 18);
  *(unsigned char *)(b_61 + 37) = 32;
  memset (b_61 + 38, 61, 18);
  memset (b_67, 48, 18);
  *(unsigned char *)(b_67 + 18) = 32;
  memset (b_67 + 19, 48, 18);
  *(unsigned char *)(b_67 + 37) = 32;
  memset (b_67 + 38, 48, 18);

  cob_save_call_params = cob_call_params;

  /* Entry dispatch */
  goto l_2;

  /* PROCEDURE DIVISION */

  /* Entry ORBITS */

  l_2:;

  /* MAIN SECTION */

  /* BEGIN */

  /* orbits.cob:97: DISPLAY */
  {
    cob_display (0, 1, 1, &c_3);
  }
  /* orbits.cob:98: MOVE */
  {
    cob_move (&c_4, (f_45.data = b_45, &f_45));
  }
  /* orbits.cob:99: OPEN */
  {
    cob_exception_code = 0;
    {
      cob_open (h_ENTRADA, 1, 0, NULL);
    }
    if (unlikely(cob_exception_code != 0))
      {
        /* PERFORM Default Error Handler */
        frame_ptr++;
        frame_ptr->perform_through = 1;
        frame_ptr->return_address = &&l_14;
        goto l_1;
        l_14:
        frame_ptr--;
      }
  }