int TDBINI::GetMaxSize(PGLOBAL g)
{
if (MaxSize < 0)
MaxSize = Cardinality(g);
return MaxSize;
} // end of GetMaxSize
static
void BrowWriteUnformattedSet(Tcl_Interp *interp,struct Instance *i)
{
CONST struct set_t *s;
unsigned long len,c;
char value[80];
s = SetAtomList(i);
switch(SetKind(s)) {
case empty_set:
break;
case integer_set:
case string_set:
len = Cardinality(s);
for(c=1;c<=len;c++) {
if (SetKind(s)==integer_set) {
sprintf(value,"%u", FetchIntMember(s,c));
Tcl_AppendResult(interp,value," ",(char *)NULL);
} else {
Tcl_AppendResult(interp,"'",SCP(FetchStrMember(s,c)),"' ",
(char *)NULL);
}
}
return;
default:
return;
}
}
void MarkDefaultReductions( void )
/********************************/
{
a_pro *pro;
a_state *state;
a_reduce_action *raction;
a_reduce_action *default_raction;
a_shift_action *saction;
unsigned i;
unsigned max_tokens;
unsigned count_tokens;
unsigned nshifts;
unsigned nreduces;
for( i = 0; i < nstate; ++i ) {
// iterate over all reductions in state
state = statetab[i];
nshifts = 0;
for( saction = state->trans; saction->sym != NULL; ++saction ) {
++nshifts;
if( saction->sym == errsym ) {
// if there is a shift on the error token then
// we don't want default reduce actions
state = NULL;
break;
}
}
if( state == NULL ) {
continue;
}
default_raction = NULL;
max_tokens = 0;
nreduces = 0;
for( raction = state->redun; (pro = raction->pro) != NULL; ++raction ) {
++nreduces;
count_tokens = Cardinality( raction->follow );
if( count_tokens >= max_tokens ) {
max_tokens = count_tokens;
default_raction = raction;
}
}
if( nshifts == 0 && nreduces == 1 ) {
OnlyReduce( state );
++nstate_1_reduce;
assert( default_raction != NULL );
}
if( default_raction != NULL ) {
state->default_reduction = default_raction;
}
}
}
bool MAPFAM::OpenTableFile(PGLOBAL g)
{
char filename[_MAX_PATH];
int len;
MODE mode = Tdbp->GetMode();
PFBLOCK fp;
PDBUSER dbuserp = (PDBUSER)g->Activityp->Aptr;
#if defined(_DEBUG)
// Insert mode is no more handled using file mapping
assert(mode != MODE_INSERT);
#endif // _DEBUG
/*********************************************************************/
/* We used the file name relative to recorded datapath. */
/*********************************************************************/
PlugSetPath(filename, To_File, Tdbp->GetPath());
/*********************************************************************/
/* Under Win32 the whole file will be mapped so we can use it as */
/* if it were entirely read into virtual memory. */
/* Firstly we check whether this file have been already mapped. */
/*********************************************************************/
if (mode == MODE_READ) {
for (fp = dbuserp->Openlist; fp; fp = fp->Next)
if (fp->Type == TYPE_FB_MAP && !stricmp(fp->Fname, filename)
&& fp->Count && fp->Mode == mode)
break;
if (trace)
htrc("Mapping file, fp=%p\n", fp);
} else
fp = NULL;
if (fp) {
/*******************************************************************/
/* File already mapped. Just increment use count and get pointer. */
/*******************************************************************/
fp->Count++;
Memory = fp->Memory;
len = fp->Length;
} else {
/*******************************************************************/
/* If required, delete the whole file if no filtering is implied. */
/*******************************************************************/
bool del;
HANDLE hFile;
MEMMAP mm;
del = mode == MODE_DELETE && !Tdbp->GetNext();
if (del)
DelRows = Cardinality(g);
/*******************************************************************/
/* Create the mapping file object. */
/*******************************************************************/
hFile = CreateFileMap(g, filename, &mm, mode, del);
if (hFile == INVALID_HANDLE_VALUE) {
DWORD rc = GetLastError();
if (!(*g->Message))
sprintf(g->Message, MSG(OPEN_MODE_ERROR),
"map", (int) rc, filename);
if (trace)
htrc("CreateFileMap: %s\n", g->Message);
return (mode == MODE_READ && rc == ENOENT)
? PushWarning(g, Tdbp) : true;
} // endif hFile
/*******************************************************************/
/* Get the file size (assuming file is smaller than 4 GB) */
/*******************************************************************/
len = mm.lenL;
Memory = (char *)mm.memory;
if (!len) { // Empty or deleted file
CloseFileHandle(hFile);
Tdbp->ResetSize();
return false;
} // endif len
if (!Memory) {
CloseFileHandle(hFile);
sprintf(g->Message, MSG(MAP_VIEW_ERROR),
filename, GetLastError());
return true;
} // endif Memory
#if defined(WIN32)
if (mode != MODE_DELETE) {
#else // !WIN32
if (mode == MODE_READ) {
#endif // !WIN32
CloseFileHandle(hFile); // Not used anymore
hFile = INVALID_HANDLE_VALUE; // For Fblock
} // endif Mode
/*******************************************************************/
/* Link a Fblock. This make possible to reuse already opened maps */
/* and also to automatically unmap them in case of error g->jump. */
/* Note: block can already exist for previously closed file. */
/*******************************************************************/
fp = (PFBLOCK)PlugSubAlloc(g, NULL, sizeof(FBLOCK));
fp->Type = TYPE_FB_MAP;
fp->Fname = (char*)PlugSubAlloc(g, NULL, strlen(filename) + 1);
strcpy((char*)fp->Fname, filename);
fp->Next = dbuserp->Openlist;
dbuserp->Openlist = fp;
fp->Count = 1;
fp->Length = len;
fp->Memory = Memory;
fp->Mode = mode;
fp->File = NULL;
fp->Handle = hFile; // Used for Delete
} // endif fp
To_Fb = fp; // Useful when closing
/*********************************************************************/
/* The pseudo "buffer" is here the entire file mapping view. */
/*********************************************************************/
Fpos = Mempos = Memory;
Top = Memory + len;
if (trace)
htrc("fp=%p count=%d MapView=%p len=%d Top=%p\n",
fp, fp->Count, Memory, len, Top);
return AllocateBuffer(g); // Useful for DBF files
} // end of OpenTableFile
/***********************************************************************/
/* GetRowID: return the RowID of last read record. */
/***********************************************************************/
int MAPFAM::GetRowID(void)
{
return Rows;
} // end of GetRowID
/***********************************************************************/
/* GetPos: return the position of last read record. */
/***********************************************************************/
int MAPFAM::GetPos(void)
{
return Fpos - Memory;
} // end of GetPos
/***********************************************************************/
/* GetNextPos: return the position of next record. */
/***********************************************************************/
int MAPFAM::GetNextPos(void)
{
return Mempos - Memory;
} // end of GetNextPos
/***********************************************************************/
/* SetPos: Replace the table at the specified position. */
/***********************************************************************/
bool MAPFAM::SetPos(PGLOBAL g, int pos)
{
Fpos = Mempos = Memory + pos;
if (Mempos >= Top || Mempos < Memory) {
strcpy(g->Message, MSG(INV_MAP_POS));
return true;
} // endif Mempos
Placed = true;
return false;
} // end of SetPos
bool DOSFAM::OpenTableFile(PGLOBAL g)
{
char opmode[4], filename[_MAX_PATH];
//int ftype = Tdbp->GetFtype();
MODE mode = Tdbp->Mode;
PDBUSER dbuserp = PlgGetUser(g);
// This is required when using Unix files under Windows
Bin = (Ending == 1);
switch (mode) {
case MODE_READ:
strcpy(opmode, "r");
break;
case MODE_DELETE:
if (!Tdbp->Next) {
// Store the number of deleted lines
DelRows = Cardinality(g);
if (Blocked) {
// Cardinality must return 0
Block = 0;
Last = Nrec;
} // endif blocked
// This will erase the entire file
strcpy(opmode, "w");
Tdbp->ResetSize();
break;
} // endif
// Selective delete, pass thru
Bin = true;
case MODE_UPDATE:
if ((UseTemp = Tdbp->IsUsingTemp(g))) {
strcpy(opmode, "r");
Bin = true;
} else
strcpy(opmode, "r+");
break;
case MODE_INSERT:
strcpy(opmode, "a+");
break;
default:
sprintf(g->Message, MSG(BAD_OPEN_MODE), mode);
return true;
} // endswitch Mode
// For blocked I/O or for moving lines, open the table in binary
strcat(opmode, (Blocked || Bin) ? "b" : "t");
// Now open the file stream
PlugSetPath(filename, To_File, Tdbp->GetPath());
if (!(Stream = PlugOpenFile(g, filename, opmode))) {
if (trace)
htrc("%s\n", g->Message);
return (mode == MODE_READ && errno == ENOENT)
? PushWarning(g, Tdbp) : true;
} // endif Stream
if (trace)
htrc("File %s open Stream=%p mode=%s\n", filename, Stream, opmode);
To_Fb = dbuserp->Openlist; // Keep track of File block
/*********************************************************************/
/* Allocate the line buffer. For mode Delete a bigger buffer has to */
/* be allocated because is it also used to move lines into the file.*/
/*********************************************************************/
return AllocateBuffer(g);
} // end of OpenTableFile
static struct gl_list_t *FindArrayChildrenPath(struct gl_list_t *list,
CONST struct set_t *sptr,
enum find_errors *errval)
{
struct gl_list_t *result;
CONST struct Instance *i,*child;
struct InstanceName rec;
struct TypeDescription *desc;
unsigned long c1,len1,c2,len2,pos;
PAN *p, *p2;
struct Name *n, *n2;
symchar *senum;
long sint;
switch(SetKind(sptr)){
case empty_set: return gl_create(0);
case string_set:
SetInstanceNameType(rec,StrArrayIndex);
len2 = Cardinality(sptr);
len1 = gl_length(list);
result = gl_create(len1*len2);
for (c1=1; c1<=len1; c1++){
p = (PAN *)gl_fetch(list,c1);
i = p->i;
if (InstanceKind(i)==ARRAY_ENUM_INST){
if (NextToExpand(i)!=1){
for (c2=1; c2<=len2; c2++){
senum = FetchStrMember(sptr,c2);
SetInstanceNameStrIndex(rec,senum);
if ((pos = ChildSearch(i,&rec))==0){
DestroyPANList(&result);
desc = InstanceTypeDesc(i);
if ( GetArrayBaseIsRelation(desc) || GetArrayBaseIsLogRel(desc)){
*errval = unmade_instance;
} else {
*errval = impossible_instance;
}
return NULL;
} else {
child = InstanceChild(i,pos);
if (child!=NULL){
n = CreateEnumElementName(senum);
n2 = CopyAppendNameNode(p->n, n);
DestroyName(n);
p2 = CreatePAN(child, n2);
gl_append_ptr(result,(VOIDPTR)p2);
} else {
DestroyPANList(&result);
*errval = unmade_instance;
return NULL;
}
}
}
} else {
DestroyPANList(&result);
*errval = unmade_instance;
return NULL;
}
} else {
DestroyPANList(&result);
*errval = impossible_instance;
return NULL;
}
}
return result;
case integer_set:
SetInstanceNameType(rec,IntArrayIndex);
len2 = Cardinality(sptr);
len1 = gl_length(list);
result = gl_create(len1*len2);
for (c1=1; c1<=len1; c1++){
p = (PAN *)gl_fetch(list,c1);
i = p->i;
if (InstanceKind(i)==ARRAY_INT_INST){
if (NextToExpand(i)!=1){
for (c2=1; c2<=len2; c2++){
sint = FetchIntMember(sptr,c2);
SetInstanceNameIntIndex(rec,sint);
if ((pos = ChildSearch(i,&rec))==0){
DestroyPANList(&result);
desc = InstanceTypeDesc(i);
if (GetArrayBaseIsRelation(desc) || GetArrayBaseIsLogRel(desc)) {
*errval = unmade_instance;
} else {
*errval = impossible_instance;
}
return NULL;
} else {
child = InstanceChild(i,pos);
if (child!=NULL){
n = CreateIntegerElementName(sint);
n2 = CopyAppendNameNode(p->n, n);
DestroyName(n);
p2 = CreatePAN(child, n2);
gl_append_ptr(result,(VOIDPTR)p2);
} else{
DestroyPANList(&result);
*errval = unmade_instance;
return NULL;
}
}
}
} else {
DestroyPANList(&result);
*errval = unmade_instance;
return NULL;
}
} else {
DestroyPANList(&result);
*errval = impossible_instance;
return NULL;
}
}
return result;
}
/*NOTREACHED*/
return NULL;
}
bool ZIPFAM::OpenTableFile(PGLOBAL g)
{
char opmode[4], filename[_MAX_PATH];
MODE mode = Tdbp->GetMode();
switch (mode) {
case MODE_READ:
strcpy(opmode, "r");
break;
case MODE_UPDATE:
/*****************************************************************/
/* Updating ZIP files not implemented yet. */
/*****************************************************************/
strcpy(g->Message, MSG(UPD_ZIP_NOT_IMP));
return true;
case MODE_DELETE:
if (!Tdbp->GetNext()) {
// Store the number of deleted lines
DelRows = Cardinality(g);
// This will erase the entire file
strcpy(opmode, "w");
// Block = 0; // For ZBKFAM
// Last = Nrec; // For ZBKFAM
Tdbp->ResetSize();
} else {
sprintf(g->Message, MSG(NO_PART_DEL), "ZIP");
return true;
} // endif filter
break;
case MODE_INSERT:
strcpy(opmode, "a+");
break;
default:
sprintf(g->Message, MSG(BAD_OPEN_MODE), mode);
return true;
} // endswitch Mode
/*********************************************************************/
/* Open according to logical input/output mode required. */
/* Use specific zlib functions. */
/* Treat files as binary. */
/*********************************************************************/
strcat(opmode, "b");
Zfile = gzopen(PlugSetPath(filename, To_File, Tdbp->GetPath()), opmode);
if (Zfile == NULL) {
sprintf(g->Message, MSG(GZOPEN_ERROR),
opmode, (int)errno, filename);
strcat(strcat(g->Message, ": "), strerror(errno));
return (mode == MODE_READ && errno == ENOENT)
? PushWarning(g, Tdbp) : true;
} // endif Zfile
/*********************************************************************/
/* Something to be done here. >>>>>>>> NOT DONE <<<<<<<< */
/*********************************************************************/
//To_Fb = dbuserp->Openlist; // Keep track of File block
/*********************************************************************/
/* Allocate the line buffer. */
/*********************************************************************/
return AllocateBuffer(g);
} // end of OpenTableFile
