From 9fa49beb4eb8ba7edab1ac1215cf63e6fc62f3f8 Mon Sep 17 00:00:00 2001 From: Jakub Bogusz Date: Thu, 5 Dec 2002 21:30:25 +0000 Subject: [PATCH] - only builds (Classic version for now) Changed files: Firebird-bootkit-missing.patch -> 1.1 Firebird-fix.patch -> 1.1 Firebird-isc4.gbak -> 1.1 Firebird-ksh.patch -> 1.1 Firebird.spec -> 1.1 --- Firebird-bootkit-missing.patch | 1391 ++++++++++++++++++++++++++++++++ Firebird-fix.patch | 83 ++ Firebird-isc4.gbak | Bin 0 -> 3072 bytes Firebird-ksh.patch | 14 + Firebird.spec | 138 ++++ 5 files changed, 1626 insertions(+) create mode 100644 Firebird-bootkit-missing.patch create mode 100644 Firebird-fix.patch create mode 100644 Firebird-isc4.gbak create mode 100644 Firebird-ksh.patch create mode 100644 Firebird.spec diff --git a/Firebird-bootkit-missing.patch b/Firebird-bootkit-missing.patch new file mode 100644 index 0000000..2916707 --- /dev/null +++ b/Firebird-bootkit-missing.patch @@ -0,0 +1,1391 @@ +--- firebird-1.0.0.796/porting/pyxis/save.c.orig Thu Jan 1 01:00:00 1970 ++++ firebird-1.0.0.796/porting/pyxis/save.c Wed Dec 4 23:34:54 2002 +@@ -0,0 +1,1388 @@ ++/*********** Preprocessed module -- do not edit ***************/ ++/*********** Preprocessed module -- do not edit ***************/ ++/*********** Preprocessed module -- do not edit ***************/ ++/*********** Preprocessed module -- do not edit ***************/ ++/*********** Preprocessed module -- do not edit ***************/ ++/***************** gpre version LI-T6.2.796 Firebird 1.0 **********************/ ++/* ++ * PROGRAM: PYXIS Form Package ++ * MODULE: save.e ++ * DESCRIPTION: Form dump/load code. ++ * ++ * The contents of this file are subject to the Interbase Public ++ * License Version 1.0 (the "License"); you may not use this file ++ * except in compliance with the License. You may obtain a copy ++ * of the License at http://www.Inprise.com/IPL.html ++ * ++ * Software distributed under the License is distributed on an ++ * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express ++ * or implied. See the License for the specific language governing ++ * rights and limitations under the License. ++ * ++ * The Original Code was created by Inprise Corporation ++ * and its predecessors. Portions created by Inprise Corporation are ++ * Copyright (C) Inprise Corporation. ++ * ++ * All Rights Reserved. ++ * Contributor(s): ______________________________________. ++ */ ++ ++#include "../jrd/gds.h" ++#include "../pyxis/pyxis.h" ++ ++#define HANDLES 10 ++#define PYXIS_RELATION "PYXIS$FORMS" ++#define BUF_LEN 256 ++ ++extern PIC PICSTR_analyze(); ++extern OBJ PYXIS_create_object(), PYXIS_clone(), PYXIS_get_attribute_value(); ++extern ATT PYXIS_get_attribute(), PYXIS_put_attribute(), ++ PYXIS_find_object(); ++ ++/*DATABASE ++ DB = STATIC "yachts.lnk";*/ ++/**** GDS Preprocessor Definitions ****/ ++#ifndef _JRD_IBASE_H_ ++#include ++#endif ++ ++static ISC_QUAD ++ isc_blob_null = {0,0}; /* initializer for blobs */ ++static long *gds__null = 0; /* dummy status vector */ ++static isc_db_handle ++ DB = 0; /* database handle */ ++ ++static isc_tr_handle ++ gds__trans = 0; /* default transaction handle */ ++static long ++ isc_status [20], /* status vector */ ++ isc_status2 [20]; /* status vector */ ++static long ++ isc_array_length, /* array return size */ ++ SQLCODE; /* SQL status code */ ++static char ++ isc_tpb_0 [4] = {1,9,2,6}; ++ ++static short ++ isc_1l = 73; ++static char ++ isc_1 [] = { ++ 4,2,4,0,2,0,9,0,40,32,0,12,0,15,'J',11,'P','Y','X','I','S','$', ++ 'F','O','R','M','S',0,2,1,25,0,0,0,23,0,10,'P','Y','X','I','S', ++ '$','F','O','R','M',1,25,0,1,0,23,0,15,'P','Y','X','I','S','$', ++ 'F','O','R','M','_','N','A','M','E',-1,-1,'L' ++ }; /* end of blr string for request isc_1 */ ++ ++static short ++ isc_8l = 161; ++static char ++ isc_8 [] = { ++ 4,2,4,3,1,0,7,0,4,2,1,0,9,0,4,1,2,0,9,0,7,0,4,0,1,0,40,32,0, ++ 12,0,2,7,'C',1,'J',11,'P','Y','X','I','S','$','F','O','R','M', ++ 'S',0,'G',47,23,0,15,'P','Y','X','I','S','$','F','O','R','M', ++ '_','N','A','M','E',25,0,0,0,-1,2,14,1,2,1,23,0,10,'P','Y','X', ++ 'I','S','$','F','O','R','M',25,1,0,0,1,21,8,0,1,0,0,0,25,1,1, ++ 0,-1,17,0,9,13,12,3,18,0,12,2,10,0,1,2,1,25,2,0,0,23,1,10,'P', ++ 'Y','X','I','S','$','F','O','R','M',-1,-1,-1,14,1,1,21,8,0,0, ++ 0,0,0,25,1,1,0,-1,-1,'L' ++ }; /* end of blr string for request isc_8 */ ++ ++static short ++ isc_21l = 140; ++static char ++ isc_21 [] = { ++ 4,2,4,0,2,0,40,32,0,7,0,2,7,'C',1,'J',13,'R','D','B','$','R', ++ 'E','L','A','T','I','O','N','S',0,'G',47,23,0,15,'R','D','B', ++ '$','S','Y','S','T','E','M','_','F','L','A','G',21,8,0,0,0,0, ++ 0,'F',1,'H',23,0,17,'R','D','B','$','R','E','L','A','T','I', ++ 'O','N','_','N','A','M','E',-1,14,0,2,1,23,0,17,'R','D','B', ++ '$','R','E','L','A','T','I','O','N','_','N','A','M','E',25,0, ++ 0,0,1,21,8,0,1,0,0,0,25,0,1,0,-1,14,0,1,21,8,0,0,0,0,0,25,0, ++ 1,0,-1,-1,'L' ++ }; /* end of blr string for request isc_21 */ ++ ++static short ++ isc_25l = 358; ++static char ++ isc_25 [] = { ++ 4,2,4,1,8,0,40,32,0,7,0,40,126,0,40,126,0,7,0,7,0,7,0,7,0,4, ++ 0,1,0,40,32,0,12,0,2,7,'C',2,'J',19,'R','D','B','$','R','E', ++ 'L','A','T','I','O','N','_','F','I','E','L','D','S',0,'J',10, ++ 'R','D','B','$','F','I','E','L','D','S',1,'G',58,47,23,0,17, ++ 'R','D','B','$','R','E','L','A','T','I','O','N','_','N','A', ++ 'M','E',25,0,0,0,47,23,0,16,'R','D','B','$','F','I','E','L', ++ 'D','_','S','O','U','R','C','E',23,1,14,'R','D','B','$','F', ++ 'I','E','L','D','_','N','A','M','E','F',1,'H',23,0,18,'R','D', ++ 'B','$','F','I','E','L','D','_','P','O','S','I','T','I','O', ++ 'N',-1,14,1,2,1,23,0,14,'R','D','B','$','F','I','E','L','D', ++ '_','N','A','M','E',25,1,0,0,1,21,8,0,1,0,0,0,25,1,1,0,1,23, ++ 1,15,'R','D','B','$','E','D','I','T','_','S','T','R','I','N', ++ 'G',25,1,2,0,1,23,0,15,'R','D','B','$','E','D','I','T','_','S', ++ 'T','R','I','N','G',25,1,3,0,1,23,1,18,'R','D','B','$','S','E', ++ 'G','M','E','N','T','_','L','E','N','G','T','H',25,1,4,0,1,23, ++ 1,14,'R','D','B','$','F','I','E','L','D','_','T','Y','P','E', ++ 25,1,5,0,1,23,1,16,'R','D','B','$','F','I','E','L','D','_','L', ++ 'E','N','G','T','H',25,1,6,0,1,23,1,15,'R','D','B','$','F','I', ++ 'E','L','D','_','S','C','A','L','E',25,1,7,0,-1,14,1,1,21,8, ++ 0,0,0,0,0,25,1,1,0,-1,-1,'L' ++ }; /* end of blr string for request isc_25 */ ++ ++static short ++ isc_37l = 113; ++static char ++ isc_37 [] = { ++ 4,2,4,1,2,0,9,0,7,0,4,0,1,0,40,32,0,12,0,2,7,'C',1,'J',11,'P', ++ 'Y','X','I','S','$','F','O','R','M','S',0,'G',47,23,0,15,'P', ++ 'Y','X','I','S','$','F','O','R','M','_','N','A','M','E',25,0, ++ 0,0,-1,14,1,2,1,23,0,10,'P','Y','X','I','S','$','F','O','R', ++ 'M',25,1,0,0,1,21,8,0,1,0,0,0,25,1,1,0,-1,14,1,1,21,8,0,0,0, ++ 0,0,25,1,1,0,-1,-1,'L' ++ }; /* end of blr string for request isc_37 */ ++ ++static short ++ isc_46l = 107; ++static char ++ isc_46 [] = { ++ 4,2,4,0,2,0,40,32,0,7,0,2,7,'C',1,'J',11,'P','Y','X','I','S', ++ '$','F','O','R','M','S',0,'F',1,'H',23,0,15,'P','Y','X','I', ++ 'S','$','F','O','R','M','_','N','A','M','E',-1,14,0,2,1,23,0, ++ 15,'P','Y','X','I','S','$','F','O','R','M','_','N','A','M','E', ++ 25,0,0,0,1,21,8,0,1,0,0,0,25,0,1,0,-1,14,0,1,21,8,0,0,0,0,0, ++ 25,0,1,0,-1,-1,'L' ++ }; /* end of blr string for request isc_46 */ ++ ++static short ++ isc_50l = 120; ++static char ++ isc_50 [] = { ++ 4,2,4,3,1,0,7,0,4,2,1,0,7,0,4,1,1,0,7,0,4,0,1,0,40,32,0,12,0, ++ 2,7,'C',1,'J',11,'P','Y','X','I','S','$','F','O','R','M','S', ++ 0,'G',47,23,0,15,'P','Y','X','I','S','$','F','O','R','M','_', ++ 'N','A','M','E',25,0,0,0,-1,2,14,1,2,1,21,8,0,1,0,0,0,25,1,0, ++ 0,-1,17,0,9,13,12,3,18,0,12,2,5,0,-1,-1,14,1,1,21,8,0,0,0,0, ++ 0,25,1,0,0,-1,-1,'L' ++ }; /* end of blr string for request isc_50 */ ++ ++static short ++ isc_59l = 99; ++static char ++ isc_59 [] = { ++ 4,2,4,0,1,0,7,0,2,7,'C',1,'J',13,'R','D','B','$','R','E','L', ++ 'A','T','I','O','N','S',0,'G',47,23,0,17,'R','D','B','$','R', ++ 'E','L','A','T','I','O','N','_','N','A','M','E',21,14,11,0,'P', ++ 'Y','X','I','S','$','F','O','R','M','S',-1,14,0,2,1,21,8,0,1, ++ 0,0,0,25,0,0,0,-1,14,0,1,21,8,0,0,0,0,0,25,0,0,0,-1,-1,'L' ++ }; /* end of blr string for request isc_59 */ ++ ++ ++#define gds__blob_null isc_blob_null /* compatibility symbols */ ++#define gds__status isc_status ++#define gds__status2 isc_status2 ++#define gds__array_length isc_array_length ++#define gds__count isc_count ++#define gds__slack isc_slack ++#define gds__utility isc_utility /* end of compatibility symbols */ ++ ++#ifndef isc_version4 ++ Generate a compile-time error. ++ Picking up a V3 include file after preprocessing with V4 GPRE. ++#endif ++ ++/**** end of GPRE definitions ****/ ++ ++ ++static SCHAR ddl [] = ++ { ++#include "../pyxis/form_ddl.h" ++ , 0 }; ++ ++static ATT_N special_attributes [] = ++ { ++ att_display_x, ++ att_display_y, ++ /* ++ att_scroll_x, ++ att_scroll_y, ++ */ ++ att_width, ++ att_height, ++ att_border, ++ att_index, ++ att_inactive, ++ att_reverse_video, ++ att_bold, ++ att_underline, ++ att_box, ++ att_blank, ++ att_insert_right, ++ att_updatable_flag, ++ att_wakeup_flag, ++ att_reverse_for_update, ++ att_any ++ }; ++ ++ ++PYXIS_define_forms_relation (dbb) ++ SLONG **dbb; ++{ ++ struct { ++ short isc_61; /* isc_utility */ ++ } isc_60; ++/************************************** ++ * ++ * P Y X I S _ d e f i n e _ f o r m s _ r e l a t i o n ++ * ++ ************************************** ++ * ++ * Functional description ++ * Check for existence of PYXIS$FORMS relation. If it doesn't ++ * exist, create it. ++ * ++ **************************************/ ++SLONG *transaction, *handle, success; ++STATUS status_vector [20]; ++ ++DB = *dbb; ++transaction = handle = NULL; ++success = FALSE; ++ ++/*START_TRANSACTION transaction READ_WRITE;*/ ++{ ++isc_start_transaction ((long*) 0L, &transaction, (short) 1, &DB, (short) 4, isc_tpb_0); ++} ++ ++/*FOR (REQUEST_HANDLE handle TRANSACTION_HANDLE transaction) ++ X IN RDB$RELATIONS WITH X.RDB$RELATION_NAME EQ "PYXIS$FORMS"*/ ++{ ++if (!handle) ++ isc_compile_request ((long*) 0L, &DB, &handle, (short) sizeof (isc_59), (char ISC_FAR *) isc_59); ++isc_start_request ((long*) 0L, &handle, &transaction, (short) 0); ++while (1) ++ { ++ isc_receive ((long*) 0L, &handle, (short) 0, (short) 2, &isc_60, (short) 0); ++ if (!isc_60.isc_61) break; ++ success = TRUE; ++/*END_FOR;*/ ++ } ++} ++ ++gds__release_request (status_vector, GDS_REF (handle)); ++ ++if (!success && gds__ddl (status_vector, ++ GDS_REF (DB), ++ GDS_REF (transaction), ++ sizeof (ddl), ++ ddl)) ++ { ++ gds__print_status (status_vector); ++ success = FALSE; ++ /*ROLLBACK transaction;*/ ++ { ++ isc_rollback_transaction ((long*) 0L, &transaction); ++ } ++ return FALSE; ++ } ++ ++/*COMMIT transaction;*/ ++{ ++isc_commit_transaction ((long*) 0L, &transaction); ++} ++ ++return success; ++} ++ ++OBJ PYXIS_delete_form (dbb, transaction, form_name) ++ SLONG **dbb, **transaction; ++ TEXT *form_name; ++{ ++ struct { ++ short isc_58; /* isc_utility */ ++ } isc_57; ++ struct { ++ short isc_56; /* isc_utility */ ++ } isc_55; ++ struct { ++ short isc_54; /* isc_utility */ ++ } isc_53; ++ struct { ++ char isc_52 [32]; /* PYXIS$FORM_NAME */ ++ } isc_51; ++/************************************** ++ * ++ * P Y X I S _ d e l e t e _ f o r m ++ * ++ ************************************** ++ * ++ * Functional description ++ * Delete a form from a database. ++ * ++ **************************************/ ++int *handle; ++ ++DB = *dbb; ++gds__trans = *transaction; ++handle = NULL; ++ ++/*FOR (REQUEST_HANDLE handle) ++ X IN PYXIS$FORMS WITH X.PYXIS$FORM_NAME EQ form_name*/ ++{ ++if (!handle) ++ isc_compile_request ((long*) 0L, &DB, &handle, (short) sizeof (isc_50), (char ISC_FAR *) isc_50); ++isc_vtov (form_name, isc_51.isc_52, 32); ++isc_start_and_send ((long*) 0L, &handle, &gds__trans, (short) 0, (short) 32, &isc_51, (short) 0); ++while (1) ++ { ++ isc_receive ((long*) 0L, &handle, (short) 1, (short) 2, &isc_53, (short) 0); ++ if (!isc_53.isc_54) break; ++ /*ERASE X;*/ ++ isc_send ((long*) 0L, &handle, (short) 2, (short) 2, &isc_55, (short) 0); ++/*END_FOR;*/ ++ isc_send ((long*) 0L, &handle, (short) 3, (short) 2, &isc_57, (short) 0); ++ } ++} ++ ++gds__release_request (gds__status, GDS_REF (handle)); ++ ++return NULL; ++} ++ ++PYXIS_dump (object, ptr) ++ OBJ object; ++ TEXT **ptr; ++{ ++/************************************** ++ * ++ * P Y X I S _ d u m p ++ * ++ ************************************** ++ * ++ * Functional description ++ * Dump an object into linear form. Assume space is large ++ * enough. ++ * ++ **************************************/ ++ATT attribute; ++ATT_N *attr_ptr, name; ++SLONG value; ++TEXT *p, c; ++ ++p = *ptr; ++ ++/* Start by handling ordinary attributes */ ++ ++for (attribute = object->obj_attributes; attribute; ++ attribute = attribute->att_next) ++ { ++ if (attribute->att_type == attype_other) ++ continue; ++ sprintf (p, "%d", attribute->att_name); ++ while (*p) p++; ++ switch (attribute->att_type) ++ { ++ case attype_string: ++ c = (attribute == object->obj_display_attribute) ? 'D' : 'S'; ++ sprintf (p, "%c`%s`", c, attribute->att_value); ++ while (*p) p++; ++ break; ++ ++ case attype_numeric: ++ sprintf (p, "N%d.", attribute->att_value); ++ while (*p) p++; ++ break; ++ ++ case attype_object: ++ *p++ = 'O'; ++ PYXIS_dump (attribute->att_value, &p); ++ break; ++ ++ default: ++ BUGCHECK ("DUMP:Unknown attribute type"); ++ } ++ } ++ ++/* Next, handle special attributes */ ++ ++for (attr_ptr = special_attributes; *attr_ptr != att_any; attr_ptr++) ++ if (value = GET_VALUE (object, *attr_ptr)) ++ { ++ sprintf (p, "%dN%d.", *attr_ptr, value); ++ while (*p) p++; ++ } ++ ++/* Finish up */ ++ ++*p++ = 'E'; ++*ptr = p; ++} ++ ++PYXIS_dump_length (object) ++ OBJ object; ++{ ++/************************************** ++ * ++ * P Y X I S _ d u m p _ l e n g t h ++ * ++ ************************************** ++ * ++ * Functional description ++ * Compute length of object when dumped. ++ * ++ **************************************/ ++ATT attribute; ++ATT_N *attr_ptr; ++TEXT buffer [32]; ++USHORT n; ++SLONG length; ++SLONG value; ++ ++length = 1; ++ ++for (attribute = object->obj_attributes; attribute; ++ attribute = attribute->att_next) ++ { ++ if (attribute->att_type == attype_other) ++ continue; ++ sprintf (buffer, "%d", attribute->att_name); ++ length += strlen (buffer); ++ switch (attribute->att_type) ++ { ++ case attype_string: ++ length += strlen (attribute->att_value) + 3; ++ break; ++ ++ case attype_numeric: ++ sprintf (buffer, "N%d.", attribute->att_value); ++ length += strlen (buffer); ++ break; ++ ++ case attype_object: ++ length += 1 + PYXIS_dump_length (attribute->att_value); ++ break; ++ ++ default: ++ BUGCHECK ("Unknown attribute type"); ++ } ++ } ++ ++/* Next, handle special attributes */ ++ ++for (attr_ptr = special_attributes; *attr_ptr != att_any; attr_ptr++) ++ if (value = GET_VALUE (object, *attr_ptr)) ++ { ++ sprintf (buffer, "%dN%d.", *attr_ptr, value); ++ length += strlen (buffer); ++ } ++ ++return length; ++} ++ ++PYXIS_field_defaults (field) ++ OBJ field; ++{ ++/************************************** ++ * ++ * P Y X I S _ f i e l d _ d e f a u l t s ++ * ++ ************************************** ++ * ++ * Functional description ++ * Supply defaults for missing field characteristics. ++ * ++ **************************************/ ++ATT attribute; ++OBJ prototype; ++USHORT length, display_length; ++TEXT *p, buffer [256], c, *edit_string; ++PIC picture; ++DSC desc; ++STR string; ++ ++PYXIS_delete_named_attribute (field, att_inactive); ++picture = NULL; ++desc.dsc_length = desc.dsc_dtype = desc.dsc_scale = 0; ++ ++/* If we have a picture string, analyze it */ ++ ++if (edit_string = GET_STRING (field, att_edit_string)) ++ { ++ picture = PICSTR_analyze (edit_string, NULL); ++ switch (picture->pic_type) ++ { ++ case pic_alpha: ++ case pic_text: ++ desc.dsc_dtype = dtype_text; ++ desc.dsc_length = picture->pic_length; ++ break; ++ ++ case pic_numeric: ++ desc.dsc_dtype = dtype_long; ++ desc.dsc_scale = -picture->pic_fractions; ++ break; ++ ++ case pic_date: ++ desc.dsc_dtype = dtype_text; ++ break; ++ ++ case pic_float : ++ c = 'F'; ++ desc.dsc_dtype = dtype_double; /* No path to this stmt. */ ++ break; ++ } ++ } ++ ++/* Pick up data type info, if supplied directly */ ++ ++if (GET_ATTRIBUTE (field, att_dtype)) ++ desc.dsc_dtype = GET_VALUE (field, att_dtype); ++ ++if (GET_ATTRIBUTE (field, att_length)) ++ desc.dsc_length = GET_VALUE (field, att_length); ++ ++if (GET_ATTRIBUTE (field, att_scale)) ++ desc.dsc_scale = GET_VALUE (field, att_scale); ++ ++/* Cleanup datatype info, as appropriate */ ++ ++switch (desc.dsc_dtype) ++ { ++ case dtype_varying: ++/* ++ desc.dsc_length += 2; ++*/ ++ break; ++ ++ case dtype_short: ++ desc.dsc_length = 2; ++ break; ++ ++ case dtype_long: ++ desc.dsc_length = 4; ++ break; ++ ++ case dtype_real: ++ desc.dsc_length = 4; ++ break; ++ ++ case dtype_double: ++#ifdef VMS ++ case dtype_d_float: ++#endif ++ desc.dsc_length = 8; ++ break; ++ ++ case dtype_timestamp: ++ desc.dsc_length = 8; ++ break; ++ ++ case dtype_sql_date: ++ desc.dsc_length = 4; ++ break; ++ ++ case dtype_sql_time: ++ desc.dsc_length = 4; ++ break; ++ ++ case dtype_blob: ++ if (!(display_length = GET_VALUE (field, att_segment_length))) ++ display_length = 40; ++ REPLACE_ATTRIBUTE (field, att_width, attype_numeric, display_length + 2); ++ REPLACE_ATTRIBUTE (field, att_height, attype_numeric, 6); ++ if (!GET_VALUE (field, att_prototype)) ++ { ++ PYXIS_box (field); ++ prototype = PYXIS_create_object (NULL_PTR, 0); ++ REPLACE_ATTRIBUTE (prototype, att_width, attype_numeric, display_length); ++ REPLACE_ATTRIBUTE (prototype, att_reverse_for_update, attype_numeric, TRUE); ++ REPLACE_ATTRIBUTE (field, att_prototype, attype_object, prototype); ++ } ++ return TRUE; ++ ++ case dtype_text: ++ default: ++ desc.dsc_dtype = dtype_text; ++ desc.dsc_scale = 0; ++ if (!desc.dsc_length && ++ !(desc.dsc_length = GET_VALUE (field, att_width))) ++ desc.dsc_length = 10; ++ break; ++ } ++ ++REPLACE_ATTRIBUTE (field, att_dtype, attype_numeric, desc.dsc_dtype); ++REPLACE_ATTRIBUTE (field, att_length, attype_numeric, desc.dsc_length); ++if (desc.dsc_scale) ++ REPLACE_ATTRIBUTE (field, att_scale, attype_numeric, desc.dsc_scale); ++ ++if (!edit_string) ++ { ++ edit_string = (TEXT*) PICSTR_default_edit_string (&desc, buffer); ++ REPLACE_ATTRIBUTE (field, att_edit_string, attype_string, edit_string); ++ picture = PICSTR_analyze (edit_string, NULL); ++ } ++ ++REPLACE_ATTRIBUTE (field, att_width, attype_numeric, picture->pic_length); ++ ++if (!(attribute = GET_ATTRIBUTE (field, att_fill_string))) ++ { ++ switch (picture->pic_type) ++ { ++ case pic_alpha : c = 'X'; break; ++ case pic_numeric: c = '9'; break; ++ case pic_date : c = 'D'; break; ++ case pic_float : c = 'F'; break; ++ case pic_text : c = 'T'; break; ++ } ++ ++ /* Make up fill string, possibly laboriously */ ++ ++ display_length = picture->pic_length; ++ string = NULL; ++ ++ if (display_length < 255) ++ p = buffer; ++ else ++ { ++ string = (STR) ALLOCDV (type_str, display_length); ++ p = string->str_data; ++ } ++ ++ do *p++ = c; while (--display_length); ++ *p = 0; ++ ++ if (string) ++ { ++ attribute = PUT_ATTRIBUTE (field, att_fill_string, attype_string, string->str_data); ++ PYXIS_release (string); ++ } ++ else ++ attribute = PUT_ATTRIBUTE (field, att_fill_string, attype_string, buffer); ++ } ++ ++PYXIS_set_display_attribute (field, attribute); ++ ++if (picture->pic_type == pic_numeric || picture->pic_type == pic_float) ++ REPLACE_ATTRIBUTE (field, att_insert_right, attype_numeric, TRUE); ++ ++return TRUE; ++} ++ ++OBJ PYXIS_forms (dbb, transaction) ++ SLONG **dbb, **transaction; ++{ ++ struct { ++ char isc_48 [32]; /* PYXIS$FORM_NAME */ ++ short isc_49; /* isc_utility */ ++ } isc_47; ++/************************************** ++ * ++ * P Y X I S _ f o r m s ++ * ++ ************************************** ++ * ++ * Functional description ++ * Get menu all of forms, etc. ++ * ++ **************************************/ ++OBJ menu, entree; ++int *handle; ++ ++DB = *dbb; ++gds__trans = *transaction; ++menu = PYXIS_create_object (NULL_PTR, 0); ++handle = NULL; ++ ++/*FOR (REQUEST_HANDLE handle) ++ X IN PYXIS$FORMS SORTED BY X.PYXIS$FORM_NAME*/ ++{ ++if (!handle) ++ isc_compile_request ((long*) 0L, &DB, &handle, (short) sizeof (isc_46), (char ISC_FAR *) isc_46); ++isc_start_request ((long*) 0L, &handle, &gds__trans, (short) 0); ++while (1) ++ { ++ isc_receive ((long*) 0L, &handle, (short) 0, (short) 34, &isc_47, (short) 0); ++ if (!isc_47.isc_49) break; ++ zap_string (/*X.PYXIS$FORM_NAME*/ ++ isc_47.isc_48); ++ PYXIS_create_entree (menu, /*X.PYXIS$FORM_NAME*/ ++ isc_47.isc_48, 0, NULL_PTR); ++/*END_FOR;*/ ++ } ++} ++ ++gds__release_request (gds__status, GDS_REF (handle)); ++ ++return menu; ++} ++ ++OBJ PYXIS_load (ptr) ++ TEXT **ptr; ++{ ++/************************************** ++ * ++ * P Y X I S _ l o a d ++ * ++ ************************************** ++ * ++ * Functional description ++ * Load an object from linear representation. ++ * ++ **************************************/ ++OBJ object; ++ATT attribute; ++ATT_T type; ++SLONG value, name, n, negate, buf_size; ++TEXT *p, c, verb, *s, *string, *new_buf, *buf_end, buffer[1024]; ++ ++p = *ptr; ++object = PYXIS_create_object (NULL_PTR, 0); ++ ++for (;;) ++ { ++ name = 0; ++ while (*p >= '0' && *p <= '9') ++ name = name * 10 + *p++ - '0'; ++ switch (verb = *p++) ++ { ++ case 'D': ++ case 'S': ++ c = *p++; ++ string = buffer; ++ buf_size = sizeof(buffer); ++ buf_end = string + buf_size; ++ s = string; ++ while (*p != c) ++ { ++ *s++ = *p++; ++ if (s == buf_end) ++ { ++ new_buf = (TEXT*) gds__alloc (2 * buf_size); ++ memcpy (new_buf, string, buf_size); ++ if (string != buffer) ++ gds__free (string); ++ string = new_buf; ++ s = string + buf_size; ++ buf_size = 2 * buf_size; ++ buf_end = string + buf_size; ++ } ++ } ++ *s = 0; ++ attribute = PUT_ATTRIBUTE (object, name, attype_string, string); ++ if (verb == 'D') ++ PYXIS_set_display_attribute (object, attribute); ++ p++; ++ if (string != buffer) ++ gds__free (string); ++ break; ++ ++ case 'N': ++ type = attype_numeric; ++ negate = ((*p == '-') ? (++p, TRUE) : (FALSE)); ++ n = 0; ++ while ((c = *p++) != '.') ++ n = n * 10 + c - '0'; ++ if (negate) ++ n = -n; ++ PUT_ATTRIBUTE (object, name, attype_numeric, n); ++ break; ++ ++ case 'O': ++ PUT_ATTRIBUTE (object, name, attype_object, PYXIS_load (&p)); ++ break; ++ ++ case 'E': ++ *ptr = p; ++ return object; ++ ++ default: ++ BUGCHECK ("Bad form definition"); ++ } ++ } ++} ++ ++OBJ PYXIS_load_form (status_vector, dbb, transaction, ++ form_handle, form_name_length, form_name) ++ int *status_vector; ++ SLONG **dbb, **transaction; ++ OBJ *form_handle; ++ USHORT *form_name_length; ++ TEXT *form_name; ++{ ++ struct { ++ ISC_QUAD isc_41; /* PYXIS$FORM */ ++ short isc_42; /* isc_utility */ ++ } isc_40; ++ struct { ++ char isc_39 [32]; /* PYXIS$FORM_NAME */ ++ } isc_38; ++ isc_blob_handle isc_43; /* blob handle */ ++ char isc_44 [80]; /* blob segment */ ++ unsigned short isc_45; /* segment length */ ++/************************************** ++ * ++ * P Y X I S _ l o a d _ f o r m ++ * ++ ************************************** ++ * ++ * Functional description ++ * Load a form from a database. ++ * If the form doesn't exist, return NULL. ++ * ++ **************************************/ ++USHORT buf_len, out_size, length; ++TEXT *ptr, buffer [4096], *buff, *p; ++STATUS code; ++SLONG temp_vector [20], handle, seg_count, max_seg; ++SLONG size; ++ ++DB = *dbb; ++gds__trans = *transaction; ++*form_handle = NULL; ++handle = NULL; ++ptr = NULL; ++ ++/* Unless name is zero terminated, copy and terminate form name */ ++ ++if (form_name_length && (length = *form_name_length)) ++ { ++ for (p = buffer; length; --length) ++ *p++ = *form_name++; ++ *p = 0; ++ form_name = buffer; ++ } ++ ++buff = buffer; ++buf_len = sizeof (buffer); ++ ++/* Lookup form */ ++ ++/*FOR (REQUEST_HANDLE handle) ++ X IN PYXIS$FORMS WITH X.PYXIS$FORM_NAME EQ form_name*/ ++{ ++if (!handle) ++ isc_compile_request (isc_status, &DB, &handle, (short) sizeof (isc_37), (char ISC_FAR *) isc_37); ++isc_43 = 0; ++isc_vtov (form_name, isc_38.isc_39, 32); ++if (handle) ++ isc_start_and_send (isc_status, &handle, &gds__trans, (short) 0, (short) 32, &isc_38, (short) 0); ++if (!isc_status [1]) { ++while (1) ++ { ++ isc_receive (isc_status, &handle, (short) 1, (short) 10, &isc_40, (short) 0); ++ if (!isc_40.isc_42 || isc_status [1]) break; ++ /*OPEN_BLOB B IN X.PYXIS$FORM*/ ++ { ++ { ++ isc_open_blob2 (isc_status, &DB, &gds__trans, &isc_43, &isc_40.isc_41, (short) 0, (char*) 0); ++ }; ++ /*ON_ERROR*/ ++ if (isc_status [1]) ++ { ++ break; ++ /*END_ERROR;*/ ++ } ++ } ++ ++ if (gds__blob_size (&/*B*/ ++ isc_43, &size, &seg_count, &max_seg)) ++ if (size > sizeof (buffer)) ++ buff = ptr = (TEXT *) gds__alloc (size + 2); ++ ++ while (size > 0) ++ { ++ buf_len = MIN (buf_len, size); ++ if (code = gds__get_segment (gds__status, ++ GDS_REF (/*B*/ ++ isc_43), ++ GDS_REF (out_size), ++ buf_len, ++ GDS_VAL (buff))) ++ ++ { ++ ++ /* segment and segstr_eof codes are benign; ++ otherwise, we have an internal error */ ++ ++ if (code == gds__segstr_eof) ++ break; ++ if (code != gds__segment) ++ BUGCHECK ("Unable to load form"); ++ } ++ ++ buff += out_size; ++ size -= out_size; ++ } ++ /*CLOSE_BLOB B;*/ ++ { ++ isc_close_blob ((long*) 0L, &isc_43); ++ } ++ if (!(buff = ptr)) ++ buff = buffer; ++ *form_handle = PYXIS_load (&buff); ++ break; ++/*END_FOR*/ ++ } ++ }; ++ /*ON_ERROR*/ ++ if (isc_status [1]) ++ { ++ /*END_ERROR;*/ ++ } ++ } ++ ++gds__release_request (temp_vector, GDS_REF (handle)); ++ ++/* If something failed and there isn't a status vector, ++ blow away user */ ++ ++if (!status_vector && !*form_handle) ++ { ++ if (gds__status [1]) ++ gds__print_status (gds__status); ++ else ++ { ++ sprintf (buffer, "form %s not found\n", form_name); ++ gds__put_error (buffer); ++ } ++ exit (FINI_ERROR); ++ } ++ ++if (ptr) ++ gds__free (ptr); ++ ++/* Copy status vector */ ++ ++if (status_vector) ++ MOVP_fast (gds__status, status_vector, 20 * sizeof (STATUS)); ++ ++return (OBJ) gds__status [1]; ++} ++ ++OBJ PYXIS_relation_fields (dbb, transaction, relation_name) ++ SLONG **dbb, **transaction; ++ TEXT *relation_name; ++{ ++ struct { ++ char isc_29 [32]; /* RDB$FIELD_NAME */ ++ short isc_30; /* isc_utility */ ++ char isc_31 [126]; /* RDB$EDIT_STRING */ ++ char isc_32 [126]; /* RDB$EDIT_STRING */ ++ short isc_33; /* RDB$SEGMENT_LENGTH */ ++ short isc_34; /* RDB$FIELD_TYPE */ ++ short isc_35; /* RDB$FIELD_LENGTH */ ++ short isc_36; /* RDB$FIELD_SCALE */ ++ } isc_28; ++ struct { ++ char isc_27 [32]; /* RDB$RELATION_NAME */ ++ } isc_26; ++/************************************** ++ * ++ * P Y X I S _ r e l a t i o n _ f i e l d s ++ * ++ ************************************** ++ * ++ * Functional description ++ * Create an object containing fields for relation. This is ++ * NOT formatted as a form. ++ * ++ **************************************/ ++ATT attribute; ++OBJ form, field; ++USHORT length, display_length, segment_length; ++TEXT *p, c, *edit_string; ++int *handle; ++DSC desc; ++ ++DB = *dbb; ++gds__trans = *transaction; ++form = PYXIS_create_object (NULL_PTR, 0); ++handle = NULL; ++ ++/*FOR (REQUEST_HANDLE handle) ++ RFR IN RDB$RELATION_FIELDS CROSS FLD IN RDB$FIELDS WITH ++ RFR.RDB$RELATION_NAME EQ relation_name AND ++ RFR.RDB$FIELD_SOURCE EQ FLD.RDB$FIELD_NAME ++ SORTED BY RFR.RDB$FIELD_POSITION*/ ++{ ++if (!handle) ++ isc_compile_request ((long*) 0L, &DB, &handle, (short) sizeof (isc_25), (char ISC_FAR *) isc_25); ++isc_vtov (relation_name, isc_26.isc_27, 32); ++isc_start_and_send ((long*) 0L, &handle, &gds__trans, (short) 0, (short) 32, &isc_26, (short) 0); ++while (1) ++ { ++ isc_receive ((long*) 0L, &handle, (short) 1, (short) 294, &isc_28, (short) 0); ++ if (!isc_28.isc_30) break; ++ ++ /* Create field itself */ ++ ++ zap_string (/*RFR.RDB$FIELD_NAME*/ ++ isc_28.isc_29); ++ field = PYXIS_create_object (/*RFR.RDB$FIELD_NAME*/ ++ isc_28.isc_29, att_field_name); ++ ++ desc.dsc_scale = /*FLD.RDB$FIELD_SCALE*/ ++ isc_28.isc_36; ++ desc.dsc_length = /*FLD.RDB$FIELD_LENGTH*/ ++ isc_28.isc_35; ++ switch (/*FLD.RDB$FIELD_TYPE*/ ++ isc_28.isc_34) ++ { ++ case blr_text: ++ desc.dsc_dtype = dtype_text; ++ break; ++ ++ case blr_varying: ++ desc.dsc_dtype = dtype_varying; ++ desc.dsc_length += 2; ++ break; ++ ++ case blr_short: ++ desc.dsc_dtype = dtype_short; ++ desc.dsc_length = 2; ++ break; ++ ++ case blr_long: ++ desc.dsc_dtype = dtype_long; ++ desc.dsc_length = 4; ++ break; ++ ++ case blr_float: ++ desc.dsc_dtype = dtype_real; ++ desc.dsc_length = 4; ++ break; ++ ++ case blr_double: ++#ifndef VMS ++ case blr_d_float: ++#endif ++ desc.dsc_dtype = dtype_double; ++ desc.dsc_length = 8; ++ break; ++ ++#ifdef VMS ++ case blr_d_float: ++ desc.dsc_dtype = dtype_d_float; ++ desc.dsc_length = 8; ++ break; ++#endif ++ ++ case blr_timestamp: ++ desc.dsc_dtype = dtype_timestamp; ++ desc.dsc_length = 8; ++ break; ++ ++ case blr_sql_date: ++ desc.dsc_dtype = dtype_sql_date; ++ desc.dsc_length = 4; ++ break; ++ ++ case blr_sql_time: ++ desc.dsc_dtype = dtype_sql_time; ++ desc.dsc_length = 4; ++ break; ++ ++ case blr_blob: ++ desc.dsc_dtype = dtype_blob; ++ desc.dsc_length = 8; ++ if (segment_length = /*FLD.RDB$SEGMENT_LENGTH*/ ++ isc_28.isc_33) ++ PUT_ATTRIBUTE (field, att_segment_length, attype_numeric, segment_length); ++ break; ++ } ++ ++ PYXIS_put_attribute (field, att_dtype, attype_numeric, desc.dsc_dtype); ++ PYXIS_put_attribute (field, att_length, attype_numeric, desc.dsc_length); ++ if (desc.dsc_scale) ++ PYXIS_put_attribute (field, att_scale, attype_numeric, desc.dsc_scale); ++ ++ if (desc.dsc_dtype != dtype_blob) ++ { ++ edit_string = /*RFR.RDB$EDIT_STRING*/ ++ isc_28.isc_32; ++ if (!*edit_string || *edit_string == ' ') ++ edit_string = /*FLD.RDB$EDIT_STRING*/ ++ isc_28.isc_31; ++ if (*edit_string && *edit_string != ' ') ++ PUT_ATTRIBUTE (field, att_edit_string, attype_string, edit_string); ++ } ++ PUT_ATTRIBUTE (field, att_inactive, attype_numeric, TRUE); ++ PYXIS_create_entree (form, /*RFR.RDB$FIELD_NAME*/ ++ isc_28.isc_29, attype_object, field); ++/*END_FOR;*/ ++ } ++} ++ ++gds__release_request (gds__status, GDS_REF (handle)); ++ ++return form; ++} ++ ++ ++OBJ PYXIS_relation_form (window, fields) ++ WIN window; ++ OBJ fields; ++{ ++/************************************** ++ * ++ * P Y X I S _ r e l a t i o n _ f o r m ++ * ++ ************************************** ++ * ++ * Functional description ++ * Create a form from the fields of a relation. ++ * ++ **************************************/ ++ATT attribute; ++OBJ form, field, label; ++TEXT *name; ++ ++form = PYXIS_create_object (NULL_PTR, 0); ++ ++for (attribute = NULL; ++ attribute = PYXIS_find_object (fields, attribute, att_entree, TRUE);) ++ if (field = GET_OBJECT ((OBJ)attribute->att_value, att_entree_value)) ++ { ++ field = PYXIS_clone (field); ++ if (GET_VALUE (field, att_dtype) != dtype_blob && ++ GET_VALUE (field, att_datatype) != blr_blob) ++ REPLACE_ATTRIBUTE (field, att_reverse_for_update, attype_numeric, TRUE); ++ PYXIS_field_defaults (field); ++ name = GET_STRING (field, att_field_name); ++ label = PYXIS_create_object (name, att_literal_string); ++ PUT_ATTRIBUTE (form, att_label, attype_object, label); ++ PUT_ATTRIBUTE (form, att_field, attype_object, field); ++ } ++ ++PYXIS_format_form (form, window->win_width, window->win_height); ++ ++return form; ++} ++ ++OBJ PYXIS_relations (dbb, transaction) ++ SLONG **dbb, **transaction; ++{ ++ struct { ++ char isc_23 [32]; /* RDB$RELATION_NAME */ ++ short isc_24; /* isc_utility */ ++ } isc_22; ++/************************************** ++ * ++ * P Y X I S _ r e l a t i o n s ++ * ++ ************************************** ++ * ++ * Functional description ++ * Get menu all of relations, etc. ++ * ++ **************************************/ ++OBJ menu, entree; ++int *handle; ++ ++DB = *dbb; ++gds__trans = *transaction; ++menu = PYXIS_create_object (NULL_PTR, 0); ++handle = NULL; ++ ++/*FOR (REQUEST_HANDLE handle) ++ X IN RDB$RELATIONS WITH X.RDB$SYSTEM_FLAG == 0 SORTED BY X.RDB$RELATION_NAME*/ ++{ ++if (!handle) ++ isc_compile_request ((long*) 0L, &DB, &handle, (short) sizeof (isc_21), (char ISC_FAR *) isc_21); ++isc_start_request ((long*) 0L, &handle, &gds__trans, (short) 0); ++while (1) ++ { ++ isc_receive ((long*) 0L, &handle, (short) 0, (short) 34, &isc_22, (short) 0); ++ if (!isc_22.isc_24) break; ++ zap_string (/*X.RDB$RELATION_NAME*/ ++ isc_22.isc_23); ++ PYXIS_create_entree (menu, /*X.RDB$RELATION_NAME*/ ++ isc_22.isc_23, 0, NULL_PTR); ++/*END_FOR;*/ ++ } ++} ++ ++gds__release_request (gds__status, GDS_REF (handle)); ++ ++return menu; ++} ++ ++ ++PYXIS_store_form (dbb, transaction, form_name, form) ++ SLONG **dbb, **transaction; ++ TEXT *form_name; ++ OBJ form; ++{ ++ struct { ++ ISC_QUAD isc_3; /* PYXIS$FORM */ ++ char isc_4 [32]; /* PYXIS$FORM_NAME */ ++ } isc_2; ++ isc_blob_handle isc_5; /* blob handle */ ++ char isc_6 [80]; /* blob segment */ ++ unsigned short isc_7; /* segment length */ ++ struct { ++ short isc_17; /* isc_utility */ ++ } isc_16; ++ struct { ++ ISC_QUAD isc_15; /* PYXIS$FORM */ ++ } isc_14; ++ struct { ++ ISC_QUAD isc_12; /* PYXIS$FORM */ ++ short isc_13; /* isc_utility */ ++ } isc_11; ++ struct { ++ char isc_10 [32]; /* PYXIS$FORM_NAME */ ++ } isc_9; ++ isc_blob_handle isc_18; /* blob handle */ ++ char isc_19 [80]; /* blob segment */ ++ unsigned short isc_20; /* segment length */ ++/************************************** ++ * ++ * P Y X I S _ s t o r e _ f o r m ++ * ++ ************************************** ++ * ++ * Functional description ++ * Store a form in a database. If the form already exists, replace it. ++ * ++ **************************************/ ++SLONG size; ++TEXT *ptr, buffer [4096], *buff, *p; ++int *handle; ++USHORT seg_len; ++ ++DB = *dbb; ++gds__trans = *transaction; ++handle = NULL; ++ptr = NULL_PTR; ++seg_len = sizeof (buffer); ++ ++/* If local buffer is big enough use it; otherwise allocate buffer big enough */ ++ ++size = PYXIS_dump_length (form); ++buff = buffer; ++ ++if (size > sizeof (buffer)) ++ buff = ptr = (TEXT*) gds__alloc (size); ++ ++/* Linearize the form */ ++ ++p = buff; ++PYXIS_dump (form, &p); ++size = p - buff; ++ ++/* If form exists, modify it */ ++ ++/*FOR (REQUEST_HANDLE handle) ++ X IN PYXIS$FORMS WITH X.PYXIS$FORM_NAME EQ form_name*/ ++{ ++if (!handle) ++ isc_compile_request ((long*) 0L, &DB, &handle, (short) sizeof (isc_8), (char ISC_FAR *) isc_8); ++isc_18 = 0; ++isc_vtov (form_name, isc_9.isc_10, 32); ++isc_start_and_send ((long*) 0L, &handle, &gds__trans, (short) 0, (short) 32, &isc_9, (short) 0); ++while (1) ++ { ++ isc_receive ((long*) 0L, &handle, (short) 1, (short) 10, &isc_11, (short) 0); ++ if (!isc_11.isc_13) break; ++ /*MODIFY X USING*/ ++ { ++ /*CREATE_BLOB B IN X.PYXIS$FORM;*/ ++ { ++ isc_create_blob2 ((long*) 0L, &DB, &gds__trans, &isc_18, &isc_11.isc_12, (short) 0, (char*) 0); ++ } ++ while (size > 0) ++ { ++ seg_len = MIN (seg_len, size); ++ if (gds__put_segment (gds__status, ++ GDS_REF (/*B*/ ++ isc_18), ++ seg_len, ++ GDS_VAL (buff))) ++ break; ++ buff += seg_len; ++ size -= seg_len; ++ } ++ if (gds__status[1]) ++ gds__print_status (gds__status); ++ /*CLOSE_BLOB B;*/ ++ { ++ isc_close_blob ((long*) 0L, &isc_18); ++ } ++ /*END_MODIFY;*/ ++ isc_14.isc_15 = isc_11.isc_12; ++ isc_send ((long*) 0L, &handle, (short) 2, (short) 8, &isc_14, (short) 0); ++ } ++ if (ptr) ++ gds__free (ptr); ++ gds__release_request (gds__status, GDS_REF (handle)); ++ return SUCCESS; /* gpre generates a gds__send call after this which ++ can never be reached; but it's ok */ ++/*END_FOR;*/ ++ isc_send ((long*) 0L, &handle, (short) 3, (short) 2, &isc_16, (short) 0); ++ } ++} ++ ++gds__release_request (gds__status, GDS_REF (handle)); ++ ++/* Form doesn't exist -- store a new record */ ++ ++/*STORE (REQUEST_HANDLE handle) ++ X IN PYXIS$FORMS*/ ++{ ++ ++if (!handle) ++ isc_compile_request ((long*) 0L, &DB, &handle, (short) sizeof (isc_1), (char ISC_FAR *) isc_1); ++isc_5 = 0; ++isc_2.isc_3 = isc_blob_null; ++ strcpy (/*X.PYXIS$FORM_NAME*/ ++ isc_2.isc_4, form_name); ++ /*CREATE_BLOB B IN X.PYXIS$FORM;*/ ++ { ++ isc_create_blob2 ((long*) 0L, &DB, &gds__trans, &isc_5, &isc_2.isc_3, (short) 0, (char*) 0); ++ } ++ while (size > 0) ++ { ++ seg_len = MIN (seg_len, size); ++ if (gds__put_segment (gds__status, ++ GDS_REF (/*B*/ ++ isc_5), ++ seg_len, ++ GDS_VAL (buff))) ++ break; ++ buff += seg_len; ++ size -= seg_len; ++ } ++ if (gds__status[1]) ++ gds__print_status (gds__status); ++ /*CLOSE_BLOB B;*/ ++ { ++ isc_close_blob ((long*) 0L, &isc_5); ++ } ++/*END_STORE;*/ ++ ++isc_start_and_send ((long*) 0L, &handle, &gds__trans, (short) 0, (short) 40, &isc_2, (short) 0); ++} ++ ++gds__release_request (gds__status, GDS_REF (handle)); ++ ++if (ptr) ++ gds__free (ptr); ++} ++ ++static zap_string (string) ++ TEXT *string; ++{ ++/************************************** ++ * ++ * z a p _ s t r i n g ++ * ++ ************************************** ++ * ++ * Functional description ++ * Zap trailing blanks in a string. ++ * ++ **************************************/ ++ ++while (*string && *string != ' ') ++ string++; ++ ++*string = 0; ++} diff --git a/Firebird-fix.patch b/Firebird-fix.patch new file mode 100644 index 0000000..49d469d --- /dev/null +++ b/Firebird-fix.patch @@ -0,0 +1,83 @@ +--- firebird-1.0.0.796/qli/help.e.orig Thu Aug 3 22:53:52 2000 ++++ firebird-1.0.0.796/qli/help.e Thu Dec 5 00:21:52 2002 +@@ -160,7 +160,7 @@ + if (!(l = p - X.TOPIC)) + continue; + if (++topics == 1 && banner) +- ib_printf ("%s\n", banner, string, parent); ++ ib_printf ("%s\n", banner); + p = line + ((ptr - line + COLUMN_WIDTH - 1) / COLUMN_WIDTH) * COLUMN_WIDTH; + if (p + l > line + RIGHT_MARGIN) + { +--- firebird-1.0.0.796/porting/qli/help.c.orig Thu Dec 5 00:00:10 2002 ++++ firebird-1.0.0.796/porting/qli/help.c Thu Dec 5 00:22:15 2002 +@@ -289,7 +289,7 @@ + isc_25.isc_26)) + continue; + if (++topics == 1 && banner) +- ib_printf ("%s\n", banner, string, parent); ++ ib_printf ("%s\n", banner); + p = line + ((ptr - line + COLUMN_WIDTH - 1) / COLUMN_WIDTH) * COLUMN_WIDTH; + if (p + l > line + RIGHT_MARGIN) + { +--- firebird-1.0.0.796/jrd/rse.c.orig Fri Mar 1 12:54:03 2002 ++++ firebird-1.0.0.796/jrd/rse.c Thu Dec 5 00:48:00 2002 +@@ -735,7 +735,7 @@ + MOV_get_int64 (EVL_expr (tdbb, (NOD) rsb->rsb_arg [0]), 0); + + if (((IRSB_FIRST)impure)->irsb_count < 1) +- ERR_post (gds__bad_limit_param, 0); ++ ERR_post (gds__not_valid /*gds__bad_limit_param*/, 0); + + rsb = rsb->rsb_next; + break; +@@ -745,7 +745,7 @@ + MOV_get_int64 (EVL_expr (tdbb, (NOD) rsb->rsb_arg [0]), 0); + + if (((IRSB_SKIP)impure)->irsb_count < 0) +- ERR_post (gds__bad_skip_param, 0); ++ ERR_post (gds__not_valid /*gds__bad_skip_param*/, 0); + ((IRSB_SKIP)impure)->irsb_count++; + + rsb = rsb->rsb_next; +--- firebird-1.0.0.796/dsql/ddl.c.orig Sat Dec 8 13:57:34 2001 ++++ firebird-1.0.0.796/dsql/ddl.c Thu Dec 5 00:52:03 2002 +@@ -2885,7 +2885,7 @@ + if (!arguments || position > arguments->nod_count || position < 1) + ERRD_post (gds__sqlerr, gds_arg_number, (SLONG) -607, + gds_arg_gds, gds__dsql_command_err, +- gds_arg_gds, isc_dsql_udf_return_pos_err, /*gds__extern_func_err, */ ++ gds_arg_gds, isc_dsql_function_err /*isc_dsql_udf_return_pos_err*/, /*gds__extern_func_err, */ + gds_arg_number, (SLONG) (arguments ? arguments->nod_count : 0), + /* CVC: We should devise new msg "position should be between 1 and #params"; + here it is: dsql_udf_return_pos_err */ +--- firebird-1.0.0.796/dsql/pass1.c.orig Fri Feb 8 13:03:01 2002 ++++ firebird-1.0.0.796/dsql/pass1.c Thu Dec 5 00:57:13 2002 +@@ -1193,7 +1193,7 @@ + if (node) + ALLD_release ((FRB) node); + ERRD_post (gds__sqlerr, gds_arg_number, (SLONG) -204, +- gds_arg_gds, isc_dsql_ambiguous_field_name, ++ gds_arg_gds, isc_dsql_field_ref /*isc_dsql_ambiguous_field_name*/, + gds_arg_string, buffer, + gds_arg_string, ++p, + gds_arg_gds, gds__random, +@@ -1204,7 +1204,7 @@ + + + ERRD_post_warning (isc_sqlwarn, gds_arg_number, (SLONG) 204, +- gds_arg_warning, isc_dsql_ambiguous_field_name, ++ gds_arg_warning, isc_dsql_field_ref /*isc_dsql_ambiguous_field_name*/, + gds_arg_string, buffer, + gds_arg_string, ++p, + gds_arg_gds, gds__random, +--- firebird-1.0.0.796/Configure_SetupEnv.sh.orig Tue Aug 7 20:19:19 2001 ++++ firebird-1.0.0.796/Configure_SetupEnv.sh Thu Dec 5 08:14:29 2002 +@@ -53,6 +53,6 @@ + LD_LIBRARY_PATH=$FBNewBuild/lib:$FBBuildRoot/jrd:$LD_LIBRARY_PATH + export LD_LIBRARY_PATH + +-PATH=$PATH:$FBNewBuild/bin:. ++PATH=$FBNewBuild/bin:$PATH:. + + diff --git a/Firebird-isc4.gbak b/Firebird-isc4.gbak new file mode 100644 index 0000000000000000000000000000000000000000..4b5245ede9f678ac40ec1aecad255cd811ecaa25 GIT binary patch literal 3072 zcmc&$OK;O!5T0{#oY+a+0)n(l3xRT55GnyA1S=jXUFO7?DSx5P1V>M&H>svBY-w?0EpZgL}T4^_ual5`-wXk z_;CzUGzR0nJ%6-sKm+Xz456t^w6oZEi#ghAf;Zdj0ZputyXPkpH%g7J;*U-BgpKe4 z+Gw3=j7#ejSGc7d{OYPre0u)Sore2PG93kjvF9hlICi?-)WJ1&iEe7Ufv2OQc$$jt zE&fqExSj#cf5-8D^1y$r(QAypIEUU+bhFJ_k~JQ57Gd21)LKu z>1NJlZCWuaYa07eQpBcxd_CcVZnjk^Hfs_E4};L(P19OYKO^$`S8nPGXfKy>3}#Dx zLET3$Mi)OD&>RL4)|(=u<_d5&ptToxUg(!Etfm%F09WL-D`?<_W-B#o(W=IxCn~~;HHd1<-jT#76O&HYnI1S&T@cAMSJ=3eq z4z_Bbe8HTF|@MSbGB+C(p0)K zPw+gejt|;MV*8 ztKJW=>X^OPcLBct{slkr&oXBg8(1B|YfSR9CgRKwZSiOv`f-DGW@>M9=-^D~>6y^p znb6THbbT`IhrwVbPimK8RmwB3O1}InRizR-uSz9!UX@DdyegH@S(f^xQ6%&HuyOW@!ikl2;w=*}wn!1H