Example #1
0
static void addroute(struct session *ses, int a, int b, char *way, int dist, char *cond)
{
    struct routenode *r;

    r=ses->routes[a];
    while (r&&(r->dest!=b))
        r=r->next;
    if (r)
    {
        SFREE(r->path);
        r->path=mystrdup(way);
        r->distance=dist;
        SFREE(r->cond);
        r->cond=mystrdup(cond);
    }
    else
    {
        r=TALLOC(struct routenode);
        r->dest=b;
        r->path=mystrdup(way);
        r->distance=dist;
        r->cond=mystrdup(cond);
        r->next=ses->routes[a];
        ses->routes[a]=r;
    }
}
Example #2
0
/*-------------------------------------------------------------------------
 * Function:	_lite_PD_rl_syment
 *
 * Purpose:	Reclaim the space of the given syment.
 *
 * Return:	void
 *
 * Programmer:	Adapted from PACT PDB
 *		Mar  5, 1996 12:05 PM EST
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
void
_lite_PD_rl_syment (syment *ep) {

    SFREE(PD_entry_type(ep));
    SFREE(PD_entry_blocks(ep));
    SFREE(ep);
}
Example #3
0
/*-------------------------------------------------------------------------
 * Function:	lite_SC_rl_hash_table
 *
 * Purpose:	Release a hash table.  Call SC_HASH_CLR first to
 *		release the contents of the table.
 *
 * Return:	void
 *
 * Programmer:	Adapted from PACT SCORE
 *		Mar 12, 1996
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
void
lite_SC_rl_hash_table (HASHTAB *tab) {

    lite_SC_hash_clr(tab);

    SFREE(tab->table);
    SFREE(tab);
}
Example #4
0
int fetchannotations(void)
{
    int afirst = 1, i;
    WFDB_Anninfo ai;
    WFDB_Time ta0, taf;

    if (nann < 1) return (0);
    if (tfreq != ffreq) {
	ta0 = (WFDB_Time)(t0*tfreq/ffreq + 0.5);
	taf = (WFDB_Time)(tf*tfreq/ffreq + 0.5);
    }
    else {
	ta0 = t0;
	taf = tf;
    }

    printf("  %c \"annotator\":\n    [", nosig > 0 ? ' ' : '{');  
    setgvmode(WFDB_HIGHRES);
    for (i = 0; i < nann; i++) {
	ai.name = annotator[i];
	ai.stat = WFDB_READ;
	if (annopen(recpath, &ai, 1) >= 0) {
	    char *p;
	    int first = 1;
	    WFDB_Annotation annot;

	    if (ta0 > 0L) iannsettime(ta0);
	    if (!afirst) printf(",");
	    else afirst = 0;
	    printf("\n      { \"name\": \"%s\",\n", annotator[i]);
	    printf("        \"annotation\":\n");
	    printf("        [");
	    while ((getann(0, &annot) == 0) && (taf <= 0 || annot.time < taf)) {
		if (!first) printf(",");
		else first = 0;
		printf("\n          { \"t\": %ld,\n", (long)(annot.time));
		printf("            \"a\": %s,\n",
		       p = strjson(annstr(annot.anntyp)));
		SFREE(p);
		printf("            \"s\": %d,\n", annot.subtyp);
		printf("            \"c\": %d,\n", annot.chan);
		printf("            \"n\": %d,\n", annot.num);
		if (annot.aux && *(annot.aux)) {
		    printf("            \"x\": %s\n", p = strjson(annot.aux+1));
		    SFREE(p);
		}
		else
		    printf("            \"x\": null\n");
		printf("          }");
	    }
	    printf("\n        ]\n      }");	    
	}
    }
    printf("\n    ]\n  }\n");
    return (1);
}
void delete_Platform(Platform *self)
{
      for(int i = 0; i < kPlatformInfoSize; ++i)
            SFREE(self->platform_info[i]);

      for(int i = 0; i < self->num_devices; ++i)
            delete_Device(self->devices[i]);

      SFREE(self);
}
Example #6
0
/* Function flushcal empties the calibration list. */
FVOID flushcal(void)
{
    while (first_cle) {
	SFREE(first_cle->sigtype);
	SFREE(first_cle->units);
	this_cle = first_cle->next;
	SFREE(first_cle);
	first_cle = this_cle;
    }
}
Example #7
0
/*-------------------------------------------------------------------------
 * Function:	_lite_PD_rl_standard
 *
 * Purpose:	Release a data standard structure.
 *
 * Return:	void
 *
 * Programmer:	Adapted from PACT PDB
 *		Mar  4, 1996  1:01 PM EST
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
void
_lite_PD_rl_standard (data_standard *std) {

    if (lite_SC_arrlen(std) > 0) {
        SFREE(std->float_format);
        SFREE(std->float_order);
        SFREE(std->double_format);
        SFREE(std->double_order);
        SFREE(std);
    }
}
Example #8
0
/*-------------------------------------------------------------------------
 * Function:	_lite_PD_rl_alignment
 *
 * Purpose:	Release a data alignment structure.
 *
 * Return:	void
 *
 * Programmer:	Adapted from PACT PDB
 *		Mar  4, 1996 12:57 PM EST
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
void
_lite_PD_rl_alignment (data_alignment *align) {

    if (lite_SC_arrlen(align) > 0) {
        SFREE(align);
    }
}
Example #9
0
void pardiso_solve_as(double *b, ITG *neq){

  char *env;
  ITG maxfct=1,mnum=1,mtype=11,phase=33,*perm=NULL,nrhs=1,
      msglvl=0,i,error=0;
  double *x=NULL;

  printf(" Solving the system of equations using the asymmetric pardiso solver\n");

  iparmas[0]=0;
/* pardiso_factor has been called befor, MKL_NUM_THREADS=nthread_mkl_as is set*/

  printf(" number of threads =% d\n\n",nthread_mkl_as);

  NNEW(x,double,*neq);

  FORTRAN(pardiso,(ptas,&maxfct,&mnum,&mtype,&phase,neq,aupardisoas,
		   pointersas,irowpardisoas,perm,&nrhs,iparmas,&msglvl,
                   b,x,&error));

  for(i=0;i<*neq;i++){b[i]=x[i];}
  SFREE(x);

  return;
}
Example #10
0
void pardiso_cleanup_as(ITG *neq){

  ITG maxfct=1,mnum=1,mtype=11,phase=-1,*perm=NULL,nrhs=1,
      msglvl=0,error=0;
  double *b=NULL,*x=NULL;

  FORTRAN(pardiso,(ptas,&maxfct,&mnum,&mtype,&phase,neq,aupardisoas,
		   pointersas,irowpardisoas,perm,&nrhs,iparmas,&msglvl,
                   b,x,&error));

  SFREE(irowpardisoas);
  SFREE(aupardisoas);
  SFREE(pointersas);

  return;
}
Example #11
0
char *str_uri_path(char *str_request) {
	char *str_return = NULL;
	
	// if the request is not long enough to have a URI then abort
	ERROR_CHECK(strlen(str_request) >= 5, "request too short to parse;");
	
	// find uri start character
	char *ptr_uri;
	if (strncmp(str_request, "GET ", 4) == 0 ) {
		ptr_uri = str_request + 4;
	} else if (strncmp(str_request, "HEAD ", 5) == 0 || strncmp(str_request, "POST ", 5) == 0) {
		ptr_uri = str_request + 5;
	} else {
		ERROR("unknown request type");
	}
	// return just the Request-URI
	char *ptr_uri_end = strstr(ptr_uri, " ");
	int int_uri_len = (int)(ptr_uri_end - ptr_uri);
	
	DEBUG("int_uri_len: %i", int_uri_len);
	
	ERROR_SALLOC(str_return, int_uri_len + 1);
	memcpy(str_return, ptr_uri, int_uri_len);
	str_return[int_uri_len] = '\0';
	return str_return;
error:
	SFREE(str_return);
	return NULL;
}
Example #12
0
void lwfail(char *error_message)
{
    char *p = strjson(error_message);

    printf("{\n  \"success\": false,\n  \"error\": %s\n}\n", p);
    SFREE(p);
}
Example #13
0
void dblist(void)
{
    char *next, *wfdb = getwfdb();
    int first = 1;
   
    while (*wfdb) {
	/* Isolate the next component of the WFDB path. */
	for (next = wfdb; *next && next - wfdb < MFNLEN - 6; next++)
	    if (*next == ' ') { *next++ = '\0'; break; }
	/* Look for a "DBS" file in the next possible location. */
	sprintf(wfdb_filename, "%s/DBS", wfdb);
	if ((ifile = wfdb_fopen(wfdb_filename, "rb")) != NULL) {
	    if (first) printf("{ \"database\": [\n");
	    while (wfdb_fgets(buf, sizeof(buf), ifile)) {
		char *p, *name, *desc;

		for (p = buf; p < buf + sizeof(buf) && *p != '\t'; p++)
		    ;
		if (*p != '\t') continue;
		*p++ = '\0';
		while (p < buf + sizeof(buf) - 1 && *p == '\t')
		    p++;
		p[strlen(p)-1] = '\0';
		if (!first) printf(",\n");
		else first = 0;
		name = strjson(buf);
		desc = strjson(p);
		printf("    { \"name\": %s,\n      \"desc\": %s\n    }",
		       name, desc);
		SFREE(desc);
		SFREE(name);
	    }
	    wfdb_fclose(ifile);
	    first = 0; /* ensure that the database array will be closed in the
			  output even if the DBS file was empty */
	}
	wfdb = next;  /* prepare to search the next location in the WFDB path */
    }
    if (!first) {
	printf("\n  ],\n");
	printf("  \"version\": \"%s\",\n", LWVER);
        lwpass();
    }
    else {
	lwfail("The list of databases could not be read");
    }
}
Example #14
0
void log_off(struct session *ses)
{
    fclose(ses->logfile);
    ses->logfile = NULL;
    SFREE(ses->logname);
    ses->logname = NULL;
    cleanup_conv(&ses->c_log);
}
Example #15
0
/* Expand command substitutions in VAR; needed if libcurl is included
   in LDFLAGS, so that we invoke the curl-config program rather than
   simply printing "`curl-config --libs`". */
static void expand_var(const char *var)
{
    char *buffer;
    SUALLOC(buffer, strlen(var) + 6, 1);
    sprintf(buffer, "echo %s", var);
    system(buffer);
    SFREE(buffer);
}
Example #16
0
void
_lite_PD_convert_attrtab (PDBfile *file) {

   int i, sz;
   defstr *dp;
   hashel *np, *prev;
   memdes *desc;

   struct ohashel {
      char *name;
      char *type;
      byte *def;
      struct ohashel *next;
   } *onp, *nxt, **otb;

   dp  = PD_inquire_type(file, "hashel");
   for (desc = dp->members; desc != 0; desc = desc->next) {
      if (strcmp(desc->member, "integer free") == 0) return;
   }

   sz  = file->attrtab->size;
   otb = (struct ohashel **) file->attrtab->table;
   for (i = 0; i < sz; i++) {
      prev = NULL;
      for (onp = otb[i]; onp!= NULL; onp = nxt) {
	 np = FMAKE(hashel, "_PD_CONVERT_ATTRTAB:np");
	 np->name = onp->name;
	 np->type = onp->type;
	 np->def  = onp->def;
#ifdef FIX_ME
	 np->free = TRUE;
#endif
	 np->next = NULL;
	 if (prev == NULL) otb[i]   = (struct ohashel *) np;
	 else prev->next = np;
	 prev = np;
	 nxt  = onp->next;
	 SFREE(onp);
      }
   }

   _lite_PD_rl_defstr(dp);
   lite_SC_hash_rem("hashel", file->host_chart);
   lite_SC_hash_rem("hashel", file->chart);

   dp = lite_PD_defstr(file, "hashel",
		       "char *name", 
		       "char *type", 
		       "char *def", 
		       "integer free", 
		       "hashel *next", 
		       lite_LAST);
   if (dp == NULL) {
      lite_PD_error("COULDN'T DEFINE HASHEL - _PD_CONVERT_ATTRTAB", PD_OPEN);
   }

   lite_PD_cast(file, "hashel", "def", "type");
}
Example #17
0
void kill_routes(struct session *ses)
{
    for (int i=0;i<MAX_LOCATIONS;i++)
    {
        SFREE(ses->locations[i]);
        ses->locations[i]=0;
        struct routenode *r=ses->routes[i];
        while (r)
        {
            struct routenode *p=r;
            r=r->next;
            SFREE(p->path);
            SFREE(p->cond);
            TFREE(p, struct routenode);
        }
        ses->routes[i]=0;
    }
}
Example #18
0
//take a file list and convert it into json
//int_remove_length is the number of characters to remove from each line
//useful if your list is like:
//  /path/to/file1
//  /path/to/file2
//and you want it like:
//  file1
//  file2
char *file_list_to_json (char *str_content, int int_remove_length) {
	char *str_return = NULL;
	char *str_temp = NULL;
	char *str_temp_json = NULL;
	ERROR_NORESPONSE("int_remove_length: %d", int_remove_length);
	ERROR_CAT_CSTR(str_return, "");
	char *ptr_content = str_content + int_remove_length + 1; // + 1 means remove /
	if (*(ptr_content - 1) == '\n') { //if we are at a newline,
		//then the first line must be the full length to remove, so skip that line
		ptr_content = ptr_content + int_remove_length + 1; // + 1 means remove \n
	}
	int int_length;
	int int_done = 1;
	char *ptr_end_content = str_content + strlen(str_content);
	while (int_done > 0) {
		if (ptr_content <= ptr_end_content && strchr(ptr_content, '\n') != 0) {
			int_length = (strchr(ptr_content, '\n') - ptr_content);
			if (int_length > 0) {
				ERROR_SALLOC(str_temp, int_length + 1);
				memcpy(str_temp, ptr_content, int_length);
				str_temp[int_length] = 0;
				str_temp_json = jsonify(str_temp);
				SFREE(str_temp);
				if (strlen(str_return) > 0) {
					ERROR_CAT_APPEND(str_return, ",", str_temp_json);
				} else {
					ERROR_CAT_APPEND(str_return, str_temp_json);
				}
				ERROR_NORESPONSE(">%s|%s|%s<", str_return, str_temp_json, ptr_content);
				SFREE(str_temp_json);
			}
			ptr_content = strchr(ptr_content, '\n') + int_remove_length + 1 + 1; // + 1 means remove \n // + 1 means remove /
		} else {
			int_done = 0;
		}
	}
	return str_return;
error:
	SFREE(str_temp);
	SFREE(str_temp_json);
	SFREE(str_return);
	return NULL;
}
Example #19
0
int btree_init(BTreePtr btree, FILE* fp)
{
    ssize_t nbytes = 0;
    void*   buf    = NULL;

    buf       = ALLOC(512);
    assert(buf != NULL);

    // First, init the fork record for future calls.
    btree->fp = fp;

    // Now load up the header node.
    if ( (nbytes = fpread(btree->fp, buf, sizeof(BTNodeDescriptor), 0)) < 0 ) {
        SFREE(buf);
        return -1;
    }

    btree->nodeDescriptor = *(BTNodeDescriptor*)buf;
    swap_BTNodeDescriptor(&btree->nodeDescriptor);

    // If there's a header record, we'll likely want that as well.
    if (btree->nodeDescriptor.numRecords > 0) {
        memset(buf, 0, 512);

        if ( (nbytes = fpread(btree->fp, buf, sizeof(BTHeaderRec), sizeof(BTNodeDescriptor))) < 0 ) {
            SFREE(buf);
            return -1;
        }

        btree->headerRecord = *(BTHeaderRec*)buf;
        swap_BTHeaderRec(&btree->headerRecord);

        // Next comes 128 bytes of "user" space for record 2 that we don't care about.
        // TODO: Then the remainder of the node is allocation bitmap data for record 3 which we'll care about later.
    }

    // Init the node cache.
    cache_init(&btree->nodeCache, 100);
    SFREE(buf);

    return 0;
}
Example #20
0
/*-------------------------------------------------------------------------
 * Function:	_lite_PD_clr_table
 *
 * Purpose:	Release the storage associated with a homogeneous hash
 *		table.
 *
 * Return:	void
 *
 * Programmer:	Adapted from PACT PDB
 *		Mar  5, 1996  1:36 PM EST
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
void
_lite_PD_clr_table (HASHTAB *tab, FreeFuncType rel) {

    int i, n;
    hashel **tb, *hp, *nxt;

    n  = tab->size;
    tb = tab->table;
    for (i = 0; i < n; i++) {
        for (hp = tb[i]; hp != NULL; hp = nxt) {
            nxt = hp->next;
            SFREE(hp->name);
            if (rel != NULL) (*rel)(hp->def);
            SFREE(hp);
        }
        tb[i] = NULL;
    }

    lite_SC_rl_hash_table(tab);
}
Example #21
0
void unroute_command(const char *arg, struct session *ses)
{
    char a[BUFFER_SIZE], b[BUFFER_SIZE];
    bool found=false;

    arg=get_arg(arg, a, 0, ses);
    arg=get_arg(arg, b, 1, ses);

    if ((!*a)||(!*b))
    {
        tintin_eprintf(ses, "#SYNTAX: #unroute <from> <to>");
        return;
    }

    for (int i=0;i<MAX_LOCATIONS;i++)
        if (ses->locations[i]&&match(a, ses->locations[i]))
            for (struct routenode**r=&ses->routes[i];*r;)
            {
                if (match(b, ses->locations[(*r)->dest]))
                {
                    struct routenode *p=*r;
                    if (ses->mesvar[MSG_ROUTE])
                    {
                        tintin_printf(ses, "#Ok. There is no longer a route from {%s~-1~} to {%s~-1~}.",
                            ses->locations[i],
                            ses->locations[p->dest]);
                    }
                    found=true;
                    *r=(*r)->next;
                    SFREE(p->path);
                    SFREE(p->cond);
                    TFREE(p, struct routenode);
                }
                else
                    r=&((*r)->next);
            }
    if (found)
        kill_unused_locations(ses);
    else if (ses->mesvar[MSG_ROUTE])
        tintin_printf(ses, "#THAT ROUTE (%s) IS NOT DEFINED.", b);
}
Example #22
0
char *str_cookie(char *str_request, char *str_cookie_name) {
	char *str_return = NULL;
	DEFINE_VAR_ALL(str_full_cookie);
	
	DEBUG("str_cookie 1");
	
	ERROR_CAT_CSTR(str_full_cookie, str_cookie_name, "=");
	
	DEBUG("str_cookie 2");
	
	// find the cookie
	char *ptr_cookie = strstr(str_request, "Cookie:");
	WARN_CHECK(ptr_cookie != NULL, "no cookie found");
	ptr_cookie = strstr(ptr_cookie, str_full_cookie);
	WARN_CHECK(ptr_cookie != NULL, "no cookie found");
	ptr_cookie = ptr_cookie + strlen(str_full_cookie); // advance cursor past "postage="
	SFREE(str_full_cookie);
	
	DEBUG("str_cookie 3");
	
	// get cookie length
	char *ptr_cookie_end_return = strstr(ptr_cookie, "\r\n");
	char *ptr_cookie_end_semi = strstr(ptr_cookie, ";");
	int int_cookie_len;
	
	DEBUG("str_cookie 4");
	
	if (ptr_cookie_end_return == NULL && ptr_cookie_end_semi == NULL) {
		int_cookie_len = strlen(ptr_cookie);
	} else if (ptr_cookie_end_return != NULL && ptr_cookie_end_semi == NULL) {
		int_cookie_len = ptr_cookie_end_return - ptr_cookie;
	} else if (ptr_cookie_end_return == NULL && ptr_cookie_end_semi != NULL) {
		int_cookie_len = ptr_cookie_end_semi - ptr_cookie;
	} else {
		int_cookie_len = (ptr_cookie_end_return < ptr_cookie_end_semi) ? ptr_cookie_end_return - ptr_cookie : ptr_cookie_end_semi - ptr_cookie;
	}
	
	DEBUG("str_cookie 5");
	
	// return just the postage cookie
	ERROR_SALLOC(str_return, int_cookie_len + 1);
	memcpy(str_return, ptr_cookie, int_cookie_len);
	str_return[int_cookie_len] = '\0';
	
	DEBUG("str_cookie 6");
	
	SFREE_PWORD_ALL();
	return str_return;
error:
	SFREE_PWORD_ALL();
	SFREE_PWORD(str_return);
	return NULL;
}
int main(void) {
    // read data from stdin
    // read data count
    TYPE count = 0;
    if(scanf("%d\n", &count) != 1 && count <= 0) {
        DEBUG_PRINT_STATE;
        DEBUG_PRINT_STRING("can not get right data count.\n");
        DEBUG_PRINT_VALUE("%d", count);
        fflush(stdout);
        assert(0);
        exit(EXIT_FAILURE);
    }
    TYPE* array = SCALLOC(count, TYPE);
    // read data to array
    // get first value
    TYPE temp;
    if(scanf("%d\n", &temp) != 1) {
        DEBUG_PRINT_STATE;
        DEBUG_PRINT_STRING("can not get data.\n");
        DEBUG_PRINT_VALUE("%d", temp);
        fflush(stdout);
        assert(0);
        exit(EXIT_FAILURE);
    }
    // get difference value
    TYPE i;
    TYPE current;
    for(i = 0; i < count - 1; i++) {
        if(scanf("%d\n", &current) != 1) {
            DEBUG_PRINT_STATE;
            DEBUG_PRINT_STRING("can not get data.\n");
            DEBUG_PRINT_VALUE("%d", i);
            DEBUG_PRINT_VALUE("%d", current);
            fflush(stdout);
            assert(0);
            exit(EXIT_FAILURE);
        }
        array[i] = current - temp;
        temp = current;
        DEBUG_PRINT_VALUE("%d", i);
        DEBUG_PRINT_VALUE("%d", array[i]);
    }
    count--;
    // get result in linear time
    struct subarray data_final;
    data_final = find_maximum_subarray(array, 0, count - 1);
    // output result
    printf("max different value = %d\n", data_final.sum_max);
    printf("index in array: %d to %d\n", data_final.index_begin,
            data_final.index_end + 1);
    SFREE(&array);
    return EXIT_SUCCESS;
}
Example #24
0
/*-------------------------------------------------------------------------
 * Function:	_lite_PD_rl_defstr
 *
 * Purpose:	Free up the storage associated with a defstr.
 *
 * Return:	void
 *
 * Programmer:	Adapted from PACT PDB
 *		Mar  5, 1996  3:18 PM EST
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
void
_lite_PD_rl_defstr (defstr *dp) {

    memdes *desc, *next;
    int *ord;
    long *frm;

    for (desc = dp->members; desc != NULL; desc = next) {
        next = desc->next;
        _lite_PD_rl_descriptor(desc);
    }

    ord = dp->order;
    if ((ord != NULL) && (lite_SC_arrlen(ord) > -1)) SFREE(ord);

    frm = dp->format;
    if ((frm != NULL) && (lite_SC_arrlen(frm) > -1)) SFREE(dp->format);

    SFREE(dp->type);
    SFREE(dp);
}
Example #25
0
/*-------------------------------------------------------------------------
 * Function:	lite_SC_hash_clr
 *
 * Purpose:	Clear the specified hash table.
 *
 * Return:	void
 *
 * Programmer:	Adapted from PACT SCORE
 *		Mar 12, 1996
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
void
lite_SC_hash_clr (HASHTAB *tab) {

    int i, sz;
    hashel **tb, *np, *nxt;

    sz = tab->size;
    tb = tab->table;
    for (i = 0; i < sz; i++) {
        for (np = tb[i]; np != NULL; np = nxt) {
            nxt = np->next;

            /*
             * Undo the MARK in SC_install.
             */
            SFREE(np->def);
            SFREE(np->name);
            SFREE(np);
        }
        tb[i] = NULL;
    }
}
void delete_ContextManager(ContextManager *self)
{
      for(int i = 0; i < self->num_platforms; ++i)
		  delete_Platform(self->platforms[i]);
	  ContextManager_ShutdownQueues(self);
	  for(int i = 0; i < self->num_threads; ++i)
	  {
		  pthread_join(self->threads[i], NULL);
	  }
      delete_Queue(self->incoming_queue, true);
      delete_Queue(self->outgoing_queue, true);
      SFREE(self);
}
Example #27
0
/*-------------------------------------------------------------------------
 * Function:	_lite_PD_rl_dimensions
 *
 * Purpose:	Release a dimension descriptor.
 *
 * Return:	void
 *
 * Programmer:	Adapted from PACT PDB
 *		Mar  5, 1996  3:19 PM EST
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
void
_lite_PD_rl_dimensions (dimdes *dims) {

    dimdes *pp, *nxt;
    int nc;

    for (pp = dims; pp != NULL; pp = nxt) {
        nxt = pp->next;
        nc  = lite_SC_ref_count(pp);
        SFREE(pp);
        if (nc > 1) break;
    }
}
Example #28
0
/*-------------------------------------------------------------------------
 * Function:	_lite_PD_rl_pdb
 *
 * Purpose:	Release the storage associated with the PDBfile
 *
 * Return:	void
 *
 * Programmer:	Adapted from PACT PDB
 *		Mar  5, 1996 12:03 PM EST
 *
 * Modifications:
 *    Eric Brugger, Mon Dec  7 10:51:58 PST 1998
 *    Removed call to lite_PD_reset_ptr_list since it was removed.  I
 *    added a call to free current_prefix to close a memory leak.
 *
 *-------------------------------------------------------------------------
 */
void
_lite_PD_rl_pdb (PDBfile *file) {

    SFREE(file->date);

    _lite_PD_rl_standard(file->std);
    _lite_PD_rl_standard(file->host_std);
    _lite_PD_rl_alignment(file->align);
    _lite_PD_rl_alignment(file->host_align);

    if (file->attrtab != NULL) _lite_PD_clr_table(file->attrtab, NULL);

    _lite_PD_clr_table(file->host_chart,(FreeFuncType)_lite_PD_rl_defstr);
    _lite_PD_clr_table(file->chart,(FreeFuncType)_lite_PD_rl_defstr);
    _lite_PD_clr_table(file->symtab,(FreeFuncType)_lite_PD_rl_syment_d);

    if (file->previous_file != NULL) SFREE(file->previous_file);

    if (file->current_prefix != NULL) SFREE(file->current_prefix);

    if (file->type != NULL) SFREE(file->type);

    if (lite_LAST != NULL) SFREE(lite_LAST);

    if (lite_PD_DEFSTR_S != NULL) SFREE(lite_PD_DEFSTR_S);
    lite_PD_DEFSTR_S = NULL;

    if (lite_PD_SYMENT_S != NULL) SFREE(lite_PD_SYMENT_S);
    lite_PD_SYMENT_S = NULL;

    if (lite_io_close_hook == (PFfclose) _lite_PD_pio_close)
        lite_io_close_hook = (PFfclose) fclose;

    if (lite_io_seek_hook == (PFfseek) _lite_PD_pio_seek)
        lite_io_seek_hook = (PFfseek) fseek;

    if (lite_io_printf_hook == (PFfprintf) _lite_PD_pio_printf)
        lite_io_printf_hook = (PFfprintf) fprintf;

    SFREE(file->name);
    SFREE(file);
}
Example #29
0
/*-------------------------------------------------------------------------
 * Function:	lite_PD_cd
 *
 * Purpose:	Change the current working directory.  The directory
 *		may be specified by an absolute or relative path.
 *
 * Return:	Success:	TRUE
 *
 *		Failure:	FALSE
 *
 * Programmer:	Adapted from PACT PDB
 *		Mar  4, 1996 11:41 AM EST
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
int
lite_PD_cd (PDBfile *file, char *dirname) {

   char name[MAXLINE];
   syment *ep;

   lite_PD_err[0] = '\0';

   if (file == NULL) {
      sprintf(lite_PD_err, "ERROR: BAD FILE ID - PD_CD\n");
      return(FALSE);
   }
     
   if (dirname == NULL) {
      strcpy(name, "/");
   } else {
      strcpy(name, _lite_PD_fixname(file, dirname));
      if (name[strlen(name) - 1] != '/') strcat(name, "/");
   }

   ep = lite_PD_inquire_entry(file, name, FALSE, NULL);
   if (ep == NULL) {
      if (dirname == NULL) {
	 return(FALSE);
      } else {
	 if (strcmp(name, "/") != 0) {
	    name[strlen(name) - 1] = '\0';
	    ep = lite_PD_inquire_entry(file, name, FALSE, NULL);
	    strcat(name, "/");
	 }

	 if (ep == NULL) {
	    sprintf(lite_PD_err, "ERROR: DIRECTORY %s NOT FOUND - PD_CD\n",
		    dirname);
	    return(FALSE);
	 }
      }
   }

   if (strcmp(ep->type, "Directory") != 0) {
      sprintf(lite_PD_err, "ERROR: BAD DIRECTORY %s - PD_CD\n", dirname);
      return(FALSE);
   } else {
      if (file->current_prefix) SFREE(file->current_prefix);
      file->current_prefix = lite_SC_strsavef(name, "char*:PD_CD:name");
   }

   return(TRUE);
}
Example #30
0
// Check path environment variable for a program
char *where_is_program(char *str_program_name) {
	DEFINE_VAR_ALL(str_PATH, str_PATH2);
	char *str_return = NULL;
	
	ERROR_CAT_CSTR(str_PATH, getenv("PATH"));
	char *ptr_PATH = str_PATH;
	char *ptr_PATH_end = str_PATH + strlen(str_PATH);
	int int_next_colon;
	
	while (ptr_PATH < ptr_PATH_end) {
		//DEBUG("%s", ptr_PATH);
		int_next_colon = strcspn(ptr_PATH, ":");
		
		ERROR_SALLOC(str_PATH2, int_next_colon + 2);
		memcpy(str_PATH2, ptr_PATH, int_next_colon);
		str_PATH2[int_next_colon] = '/';
		str_PATH2[int_next_colon + 1] = '\0';
		//DEBUG("%s", str_ptr_PATH);
		str_return = canonical(str_PATH2, str_program_name, "read_dir_or_file"); //"read_file");
		SFREE(str_PATH2);
		if (str_return != NULL) {
			SFREE_ALL();
			return str_return;
		}
		
		//DEBUG("%i", int_next_colon);
		ptr_PATH += int_next_colon + 1;
	}
	
	WARN("Could not find program: %s", str_program_name);
	//ERROR("Could not find program: %s", str_program_name);
error:
	SFREE_ALL();
	SFREE(str_return);
	return NULL;
}