예제 #1
0
파일: seqspeclist.c 프로젝트: Accio/ribios
static void readList (char *line) {
  // recursively expand; loops are detected
  if (*line == '@') {
    // line+1 is a list file name
    FILE *f = hlr_fopenRead (line+1);
    int linebuflen;
    char *fline = NULL;
    if (strstr (string (fileNames),line+1))
      die ("loop in @file including at file %s",line+1);
    stringCat (fileNames,line+1);
    stringCat (fileNames,"\001"); // a char not contained in any file name
    while (getLine (f,&fline,&linebuflen)) {
      stripNlGetLength (fline);
      readList (fline);
    }
    hlr_free (fline);
    fclose (f);
  }
  else {
    Seqspec seqspec;

    if (!seqspec_isCommentLine (line) &&
        (seqspec = seqspec_parseLine (line)) != NULL) {
      array (seqspecs,arrayMax (seqspecs),Seqspec) = seqspec_clone (seqspec);
      seqCnt++;
    }
  }
}
예제 #2
0
string AES128CTR(string in, string key, string nonce){
	string cipher=newString(NULL, in.len);
	string keystream;
	string counter=newString(NULL,8);
	int i,j,n;
	n=numBlocks(in,16);

	if (nonce.len!=8){
		nonce=newString(NULL,8);
	}

	j=0;
	for(i=0; i<n; i++){
		keystream=AES128EncodeBlock(stringCat(nonce, counter), key);
		do{
			if(j<in.len){
				cipher.c[j]=keystream.c[j%16] ^ in.c[j];
				j++;
			}
			else break;
		}while(j%16);
		littleEndianIncrement(&counter);
	}
	return cipher;
}
예제 #3
0
string AES128DecodeCBC(string in, string key, string IV){
	if(in.len%16){
		return NULLSTRING;
	}
	string out = NULLSTRING;
	string *blocks = blockString(in, 16);
	int num = numBlocks(in, 16);
	for(int i=num-1; i>=0; i--){
		blocks[i] = AES128DecodeBlock(blocks[i],key);
		if(i==0){
			out = stringCat(stringXOR(blocks[i], IV), out);
		} else{
			out = stringCat(stringXOR(blocks[i-1], blocks[i]),out);
		}
	}
	return out;
}
예제 #4
0
int main() {

	char string1 [] = "hello";
	char string2 [] = "world";
	printf ("This is the concatenation of string1 and string2: ");
	stringCat(string1, string2);
	int comparison = stringCmp(string1, string2);
	printf ("This is the comparison of string1 and string2: %d\n", comparison);
}
예제 #5
0
string AES128DecodeECB(string in, string key){
	if(in.len%16){
		return NULLSTRING;
	}
	string out = NULLSTRING;
	for(int i=0; i<in.len; i+=16){
		out = stringCat(out, AES128DecodeBlock(newString(&in.c[i],16),key));
	}
	return out;
}
예제 #6
0
string AES128EncodeECB(string in, string key){
	if(key.len!=16) return NULLSTRING;
	if(!validatePKCS7Padding(in)){
		in = PKCS7PadString(in, 16);
	}
	string out = NULLSTRING;
	for(int i=0; i<in.len; i+=16){
		out = stringCat(out, AES128EncodeBlock(newString(&in.c[i],16),key));
	}
	return out;
}
예제 #7
0
파일: seqspeclist.c 프로젝트: Accio/ribios
int seqspec_split2continous (Seqspec this1) {
  /**
     If 'this1' sequence segment is of the form 'db:seq_n begin:b end:e'
     it is transformed into 'db:seq begin:b1 end:e1'
     where b1=b+n*100000, e1=e+n*100000
     which means the GCG type split is removed
     @param[in] this1 - the Seqspec object
     @param[out] this1 - the Seqspec object possibly modified
     @return 1 if 'this1' changed, else 0
  */
  static char *seqname = NULL;
  static Stringa dbseqname = NULL;
  int nameLen;
  char *cp;
  int offset;
  int segnum;

  stringCreateClear (dbseqname,40);
  strReplace (&seqname,this1->seqname);
  nameLen = strlen (seqname);
  if (nameLen < 3)
    return 0;
  if ((cp = strrchr(seqname, '_')) == NULL)
    return 0;
  if (*(cp+1) == '\0' || strlen (cp+1) > 2)
    return 0;
  segnum = atoi (cp+1);
  *cp = 0;
  offset = segnum * FRAGMENT_LENGTH;
  this1->begin += offset;
  if (this1->end != 0)
    this1->end += offset;
  stringCpy (dbseqname,this1->dbname);
  stringCat (dbseqname,":");
  stringCat (dbseqname,seqname);
  seqspec_IDset (this1,string (dbseqname));
  return 1;
}
예제 #8
0
string AES128EncodeCBC(string in, string key, string IV){
	string out = NULLSTRING;
	if(!validatePKCS7Padding(in)){
		in = PKCS7PadString(in, 16);
	}
	string *blocks = blockString(in, 16);
	int num = numBlocks(in, 16);
	for(int i=0; i<num; i++){
		if(i==0){
			blocks[0] = stringXOR(blocks[0], IV);
		}else{
			blocks[i] = stringXOR(blocks[i], newString(&out.c[(i-1)*16],16));
		}
		out = stringCat(out, AES128EncodeBlock(blocks[i], key));
	}
	return out;
}
예제 #9
0
static void como_execute(ComoFrame *frame, ComoFrame *callingframe) {
    size_t i;
    for(i = 0; i < O_AVAL(frame->code)->size; i++) {
        ComoOpCode *opcode = ((ComoOpCode *)(O_PTVAL(O_AVAL(frame->code)->table[i])));
        switch(opcode->op_code) {
            default: {
                como_error_noreturn("Invalid OpCode got %d", opcode->op_code);
            }
            case POSTFIX_INC: {
                Object *value = NULL;
                value = mapSearchEx(frame->cf_symtab, 
                    O_SVAL(opcode->operand)->value);

                if(value == NULL) {
                    como_error_noreturn("undefined variable '%s'", 
                        O_SVAL(opcode->operand)->value);
                } else {
                    if(O_TYPE(value) != IS_LONG) {
                        como_error_noreturn("unsupported value for POSTFIX_INC");
                    } else {
                        long oldvalue = O_LVAL(value);
                        O_LVAL(value) = oldvalue + 1;
                        push(frame, newLong(oldvalue));
                    }   
                }
                break;        
            }
            case POSTFIX_DEC: {
                Object *value = NULL;
                value = mapSearchEx(frame->cf_symtab, 
                    O_SVAL(opcode->operand)->value);

                if(value == NULL) {
                    como_error_noreturn("undefined variable '%s'", 
                        O_SVAL(opcode->operand)->value);
                } else {
                    if(O_TYPE(value) != IS_LONG) {
                        como_error_noreturn("unsupported value for POSTFIX_DEC");
                    } else {
                        long oldvalue = O_LVAL(value);
                        O_LVAL(value) = oldvalue - 1;
                        push(frame, newLong(oldvalue));
                    }   
                }
                break;        
            }
						case IS_LESS_THAN: {
							Object *right = pop(frame);
							Object *left = pop(frame);
							assert(right);
							assert(left);

							if(objectValueIsLessThan(left, right)) {
								push(frame, newLong(1L));
							} else {
								push(frame, newLong(0L));
							}
							break;
						}
						case IADD: {
							Object *right = pop(frame);
							Object *left = pop(frame);
							assert(right);
							assert(left);

							if(O_TYPE(left) == IS_LONG && O_TYPE(right) == IS_LONG) {
								long value = O_LVAL(left) + O_LVAL(right);
								push(frame, newLong(value));
							} else {
								char *left_str = objectToString(left);
								char *right_str = objectToString(right);
								Object *s1 = newString(left_str);
								Object *s2 = newString(right_str);
								Object *value = stringCat(s1, s2);
								push(frame, value);
								objectDestroy(s1);
								objectDestroy(s2);
								free(left_str);
								free(right_str);	
							}
							break;
						}
            case IMINUS: {
                Object *right = pop(frame);
                Object *left = pop(frame);
                assert(right);
                assert(left);
                if(O_TYPE(left) != IS_LONG && O_TYPE(right) != IS_LONG) {
                    como_error_noreturn("unsupported value for IMINUS");
                } else {
                    push(frame, newLong(O_LVAL(left) - O_LVAL(right)));
                }      
                break;
            }
            case IS_LESS_THAN_OR_EQUAL: {
                Object *right = pop(frame);
                Object *left = pop(frame);
                assert(right);
                assert(left);

                if(objectValueCompare(left, right) || objectValueIsLessThan(left, right)) {
                    push(frame, newLong(1L));
                } else {
                    push(frame, newLong(0L));
                }
                break;
            }
            case JZ: {
                Object *cond = pop(frame);
                if(O_TYPE(cond) == IS_LONG && O_LVAL(cond) == 0) {
                    i = (size_t)O_LVAL(opcode->operand);      
                    continue;          
                }
                break;
            }
            case JMP: {
                i = O_LVAL(opcode->operand);
                continue;
            }
            case LABEL: {
                break;
            }
            case HALT: {
                break;
            }
						case IS_NOT_EQUAL: {
							Object *right = pop(frame);
							Object *left = pop(frame);

							if(!objectValueCompare(left, right)) {
								push(frame, newLong(1L));
							} else {
								push(frame, newLong(0L));
							}
							break;
						}
            case LOAD_CONST: {
								como_debug("LOAD_CONST");
                push(frame, opcode->operand);
                break;
            }
            case STORE_NAME: {
                Object *value = pop(frame);
                mapInsertEx(frame->cf_symtab, 
                    O_SVAL(opcode->operand)->value, value);
                break;
            }
						/* This is where recursion was broken, don't do *ex */
            case LOAD_NAME: {
                Object *value = NULL;
                value = mapSearch(frame->cf_symtab, 
                    O_SVAL(opcode->operand)->value);
                if(value) {
                    goto load_name_leave;
                } else {
                    value = mapSearch(global_frame->cf_symtab, 
                        O_SVAL(opcode->operand)->value);
                }

                if(value == NULL) {
                    como_error_noreturn("undefined variable '%s'", 
                        O_SVAL(opcode->operand)->value);
                }
load_name_leave:
                push(frame, value);
                break;
            }
            case CALL_FUNCTION: {
                Object *fn = pop(frame);
                Object *argcount = pop(frame);
                long i = O_LVAL(argcount);
                ComoFrame *fnframe;
                if(O_TYPE(fn) != IS_POINTER) {
                    como_error_noreturn("name '%s' is not callable",
                        O_SVAL(opcode->operand)->value);
                }
                fnframe = (ComoFrame *)O_PTVAL(fn);
                if(O_LVAL(argcount) != (long)(O_AVAL(fnframe->namedparameters)->size)) {
                    como_error_noreturn("callable '%s' expects %ld arguments, but %ld were given",
                        O_SVAL(opcode->operand)->value, 
                        (long)(O_AVAL(fnframe->namedparameters)->size), 
                        O_LVAL(argcount));
                }
								//como_debug("calling '%s'", O_SVAL(opcode->operand)->value);
                // DOING THIS ACTUALLY DEFINES THE NAME AT RUNTIME
								// which could not be equal to that actual function body 
								// declared
								// name = my_function
								// name() 
								// that call will have "name" for value __FUNCTION__
								// even though the real function is my_function
								// must define it at COMPILE time
								// mapInsertEx(fnframe->cf_symtab, "__FUNCTION__", 
                // newString(O_SVAL(opcode->operand)->value));

                while(i--) {
                    como_debug("getting %ldth argument for function call '%s'",
                        i, O_SVAL(opcode->operand)->value);
                    Object *argname = O_AVAL(fnframe->namedparameters)->table[i];

                    Object *argvalue = pop(frame);
                    mapInsert(fnframe->cf_symtab, O_SVAL(argname)->value,
                        argvalue);
                    char *argvaluestr = objectToString(argvalue);
                    
										como_debug("%ldth argument: '%s' has value: %s", i, O_SVAL(argname)->value,
                        argvaluestr);
										free(argvaluestr);
                }
                //ComoFrame *prev = frame;

                //fnframe->next = prev;

                como_execute(fnframe, NULL);
                
								push(frame, pop(fnframe));
								//fnframe->next = NULL;

                break;
            }
						case IS_EQUAL: {
							Object *right = pop(frame);
							Object *left = pop(frame);
							push(frame, newLong((long)objectValueCompare(left, right)));
							break;
						}
            case ITIMES: {
                Object *right = pop(frame);
                Object *left = pop(frame);
                assert(right);
								assert(left);

								if(O_TYPE(right) != IS_LONG && O_TYPE(left) != IS_LONG) {
                    como_error_noreturn("invalid operands for ITIMES");
                }
								como_debug("ITIMES: %d, %d", O_TYPE(left),
											O_TYPE(right));

                long value = O_LVAL(left) * O_LVAL(right);
                push(frame, newLong(value));
                break;
            }
            case IRETURN: {
                /* If there wasn't a return statement found in func body*
								 * The compiler will insert a 1 as the operand if 
								 * the AST had an expression for the return statement,
								 * otherwise, it will be 0
								 * The actual value to be returned is popped from the stack
								 */
								if(! (O_LVAL(opcode->operand))) {
                    push(frame, newLong(0L));
                }
                return;
            }
            case IPRINT: {
                Object *value = pop(frame);
                size_t len = 0;
                char *sval = objectToStringLength(value, &len);
                fprintf(stdout, "%s\n", sval);
                fflush(stdout);
                free(sval);
                break;          
            }
        }
    }
}
예제 #10
0
int main (int argc, char *argv[])
{
  Array intervals;
  Interval *currInterval;
  SubInterval *currSubInterval;
  int h,i,j;
  Array seqs;
  Seq *currSeq,testSeq;
  int index;
  Stringa buffer;
  Array geneTranscriptEntries;
  Texta geneTranscriptIds;
  Array alterations;
  Alteration *currAlteration,*nextAlteration;
  char *proteinSequenceBeforeIndel;
  char *proteinSequenceAfterIndel;
  int numDisabledTranscripts;
  Stringa disabledTranscripts;
  int seqLength,refLength,altLength;
  char *sequenceBeforeIndel = NULL;
  int overlapMode;
  int numOverlaps;
  int sizeIndel,indelOffset;
  int overlap;
  Array coordinates;
  VcfEntry *currVcfEntry;
  VcfGenotype *currVcfGenotype;
  int position;
  Texta alternateAlleles;
  int flag1,flag2;
  
  if (argc != 3) {
    usage ("%s <annotation.interval> <annotation.fa>",argv[0]);
  }
  intervalFind_addIntervalsToSearchSpace (argv[1],0);
  geneTranscriptEntries = util_getGeneTranscriptEntries (intervalFind_getAllIntervals ());
  seq_init ();
  fasta_initFromFile (argv[2]);
  seqs = fasta_readAllSequences (0);
  fasta_deInit ();
  arraySort (seqs,(ARRAYORDERF)util_sortSequencesByName); 
  buffer = stringCreate (100);
  disabledTranscripts = stringCreate (100);
  alterations = arrayCreate (100,Alteration);
  vcf_init ("-");
  stringPrintf (buffer,"##INFO=<ID=VA,Number=.,Type=String,Description=\"Variant Annotation, %s\">",argv[1]);
  vcf_addComment (string (buffer));
  puts (vcf_writeMetaData ());
  puts (vcf_writeColumnHeaders ());
  while (currVcfEntry = vcf_nextEntry ()) {
    if (vcf_isInvalidEntry (currVcfEntry)) {
      continue;
    }
    flag1 = 0;
    flag2 = 0;
    position = currVcfEntry->position - 1; // make zero-based
    alternateAlleles = vcf_getAlternateAlleles (currVcfEntry);
    for (h = 0; h < arrayMax (alternateAlleles); h++) {
      refLength = strlen (currVcfEntry->referenceAllele);
      altLength = strlen (textItem (alternateAlleles,h));
      sizeIndel = abs (refLength - altLength);
      indelOffset = MAX (refLength,altLength) - 1; 
      util_clearAlterations (alterations);
      intervals = intervalFind_getOverlappingIntervals (currVcfEntry->chromosome,position,position + indelOffset);
      for (i = 0; i < arrayMax (intervals); i++) {
        currInterval = arru (intervals,i,Interval*);
        overlapMode = OVERLAP_NONE;
        numOverlaps = 0;
        for (j = 0; j < arrayMax (currInterval->subIntervals); j++) {
          currSubInterval = arrp (currInterval->subIntervals,j,SubInterval);
          overlap = rangeIntersection (position,position + indelOffset,currSubInterval->start,currSubInterval->end);
          if (currSubInterval->start <= position && (position + indelOffset) < currSubInterval->end) {
            overlapMode = OVERLAP_FULLY_CONTAINED;
            numOverlaps++;
          }
          else if (j == 0 && overlap > 0 && position < currSubInterval->start) {
            overlapMode = OVERLAP_START;
            numOverlaps++;
          }
          else if (j == (arrayMax (currInterval->subIntervals) - 1) && overlap > 0 && (position + indelOffset) >= currSubInterval->end) {
            overlapMode = OVERLAP_END;
            numOverlaps++;
          }
          else if (overlap > 0 && overlap <= indelOffset) {
            overlapMode = OVERLAP_SPLICE;
            numOverlaps++;
          }
        }
        if (overlapMode == OVERLAP_NONE) {
          continue;
        }
        currAlteration = arrayp (alterations,arrayMax (alterations),Alteration);
        if (numOverlaps > 1) {
          util_addAlteration (currAlteration,currInterval->name,"multiExonHit",currInterval,position,0);
          continue;
        }
        else if (numOverlaps == 1 && overlapMode == OVERLAP_SPLICE) {
          util_addAlteration (currAlteration,currInterval->name,"spliceOverlap",currInterval,position,0);
          continue;
        }
        else if (numOverlaps == 1 && overlapMode == OVERLAP_START) {
          util_addAlteration (currAlteration,currInterval->name,"startOverlap",currInterval,position,0);
          continue;
        }
        else if (numOverlaps == 1 && overlapMode == OVERLAP_END) {
          util_addAlteration (currAlteration,currInterval->name,"endOverlap",currInterval,position,0);
          continue;
        }
        else if (numOverlaps == 1 && overlapMode == OVERLAP_FULLY_CONTAINED && altLength > refLength) {
          if ((sizeIndel % 3) == 0) {
            util_addAlteration (currAlteration,currInterval->name,"insertionNFS",currInterval,position,0);
          }
          else {
            util_addAlteration (currAlteration,currInterval->name,"insertionFS",currInterval,position,0);
          }
        }
        else if (numOverlaps == 1 && overlapMode == OVERLAP_FULLY_CONTAINED && altLength < refLength) {
          if ((sizeIndel % 3) == 0) {
            util_addAlteration (currAlteration,currInterval->name,"deletionNFS",currInterval,position,0);
          }
          else {
            util_addAlteration (currAlteration,currInterval->name,"deletionFS",currInterval,position,0);
          }
        }
        else if (numOverlaps == 1 && overlapMode == OVERLAP_FULLY_CONTAINED && altLength == refLength) {
          util_addAlteration (currAlteration,currInterval->name,"substitution",currInterval,position,0);
        }
        else {
          die ("Unexpected type: %d %s %s %s",
               currVcfEntry->position,currVcfEntry->chromosome,
               currVcfEntry->referenceAllele,currVcfEntry->alternateAllele);
        }
        if ((sizeIndel % 3) != 0 && altLength != refLength) { 
          continue;
        }
        // Only run the remaining block of code if the indel is fully contained (insertion or deletion) AND does not cause a frameshift OR
        // if it is a substitution that is fully contained in the coding sequence
        stringPrintf (buffer,"%s|%s|%c|",currInterval->name,currInterval->chromosome,currInterval->strand);
        for (j = 0; j < arrayMax (currInterval->subIntervals); j++) {
          currSubInterval = arrp (currInterval->subIntervals,j,SubInterval);
          stringAppendf (buffer,"%d|%d%s",currSubInterval->start,currSubInterval->end,j < arrayMax (currInterval->subIntervals) - 1 ? "|" : "");
        }
        testSeq.name = hlr_strdup (string (buffer));
        if (!arrayFind (seqs,&testSeq,&index,(ARRAYORDERF)util_sortSequencesByName)) {
          die ("Expected to find %s in seqs",string (buffer));
        }
        hlr_free (testSeq.name);
        currSeq = arrp (seqs,index,Seq);
        strReplace (&sequenceBeforeIndel,currSeq->sequence);
        seqLength = strlen (sequenceBeforeIndel); 
        coordinates = util_getCoordinates (currInterval);
        // arraySort (coordinates,(ARRAYORDERF)util_sortCoordinatesByChromosomeAndTranscriptPosition); Array is already sorted by definition
        j = 0;
        stringClear (buffer);
        while (j < seqLength) {
          if (util_getGenomicCoordinate (coordinates,j,currVcfEntry->chromosome) == position) {
            if (altLength > refLength) {
              stringCat (buffer,textItem (alternateAlleles,h));
              j++;
              continue;
            }
            else if (altLength < refLength) {
              stringCatChar (buffer,sequenceBeforeIndel[j]);
              j = j + refLength - altLength + 1;
              continue;
            }
            else {
              stringCat (buffer,textItem (alternateAlleles,h));
              j = j + altLength;
              continue;
            }
          }
          stringCatChar (buffer,sequenceBeforeIndel[j]);
          j++;
        }
        util_destroyCoordinates (coordinates);
        proteinSequenceBeforeIndel = hlr_strdup (util_translate (currInterval,sequenceBeforeIndel));
        proteinSequenceAfterIndel = hlr_strdup (util_translate (currInterval,string (buffer)));
        addSubstitution (currAlteration,proteinSequenceBeforeIndel,proteinSequenceAfterIndel,indelOffset);
        hlr_free (proteinSequenceBeforeIndel);
        hlr_free (proteinSequenceAfterIndel);
      }
      if (arrayMax (alterations) == 0) {
        continue;
      }
      arraySort (alterations,(ARRAYORDERF)util_sortAlterationsByGeneIdAndType);
      stringClear (buffer);
      i = 0;
      while (i < arrayMax (alterations)) {
        currAlteration = arrp (alterations,i,Alteration);
        stringAppendf (buffer,"%s%d:%s:%s:%c:%s",stringLen (buffer) == 0 ? "" : ",",h + 1,currAlteration->geneName,currAlteration->geneId,currAlteration->strand,currAlteration->type);
         stringClear (disabledTranscripts);
        if (currAlteration->substitution[0] != '\0') {
          stringAppendf (disabledTranscripts,"%s:%s:%d_%d_%s",currAlteration->transcriptName,currAlteration->transcriptId,currAlteration->transcriptLength,currAlteration->relativePosition,currAlteration->substitution);
        }
        else if (strEqual (currAlteration->type,"multiExonHit") || strEqual (currAlteration->type,"spliceOverlap") ||
                 strEqual (currAlteration->type,"startOverlap") || strEqual (currAlteration->type,"endOverlap")) {
          stringAppendf (disabledTranscripts,"%s:%s:%d",currAlteration->transcriptName,currAlteration->transcriptId,currAlteration->transcriptLength);
        }
        else {
          stringAppendf (disabledTranscripts,"%s:%s:%d_%d",currAlteration->transcriptName,currAlteration->transcriptId,currAlteration->transcriptLength,currAlteration->relativePosition);
        }
        numDisabledTranscripts = 1;
        j = i + 1;
        while (j < arrayMax (alterations)) {
          nextAlteration = arrp (alterations,j,Alteration);
          if (strEqual (currAlteration->geneId,nextAlteration->geneId) && 
              strEqual (currAlteration->type,nextAlteration->type)) {
            if (nextAlteration->substitution[0] != '\0') {
              stringAppendf (disabledTranscripts,":%s:%s:%d_%d_%s",nextAlteration->transcriptName,nextAlteration->transcriptId,nextAlteration->transcriptLength,nextAlteration->relativePosition,nextAlteration->substitution);
            }
            else if (strEqual (nextAlteration->type,"multiExonHit") || strEqual (nextAlteration->type,"spliceOverlap") ||
                     strEqual (nextAlteration->type,"startOverlap") || strEqual (nextAlteration->type,"endOverlap")) {
              stringAppendf (disabledTranscripts,":%s:%s:%d",nextAlteration->transcriptName,nextAlteration->transcriptId,nextAlteration->transcriptLength);
            }
            else {
              stringAppendf (disabledTranscripts,":%s:%s:%d_%d",nextAlteration->transcriptName,nextAlteration->transcriptId,nextAlteration->transcriptLength,nextAlteration->relativePosition);
            }
            numDisabledTranscripts++;
          }
          else {
            break;
          }
          j++;
        }
        i = j;
        geneTranscriptIds = util_getTranscriptIdsForGeneId (geneTranscriptEntries,currAlteration->geneId);
        stringAppendf (buffer,":%d/%d:%s",numDisabledTranscripts,arrayMax (geneTranscriptIds),string (disabledTranscripts));
      }
      if (flag1 == 0) {
        printf ("%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s;VA=",
                currVcfEntry->chromosome,currVcfEntry->position,currVcfEntry->id,
                currVcfEntry->referenceAllele,currVcfEntry->alternateAllele,
                currVcfEntry->quality,currVcfEntry->filter,currVcfEntry->info);
        flag1 = 1;
      }
      printf ("%s%s",flag2 == 1 ? "," : "",string (buffer)); 
      flag2 = 1;
    }
    if (flag1 == 1) {
      for (i = 0; i < arrayMax (currVcfEntry->genotypes); i++) {
        currVcfGenotype = arrp (currVcfEntry->genotypes,i,VcfGenotype);
        if (i == 0) {
          printf ("\t%s\t",currVcfEntry->genotypeFormat);
        }
        printf ("%s%s%s%s",currVcfGenotype->genotype,
                currVcfGenotype->details[0] != '\0' ? ":" : "",
                currVcfGenotype->details[0] != '\0' ?  currVcfGenotype->details : "",
                i < arrayMax (currVcfEntry->genotypes) - 1 ? "\t" : ""); 
      }
      puts ("");
    }
  }
  vcf_deInit ();
  return 0;
}
예제 #11
0
/*
* opendir
*
* Returns a pointer to a DIR structure appropriately filled in to begin
* searching a directory.
*/
DIR *
opendir (const char_t *szPath)
{
    DIR *nd;
    char_t szFullPath[CL_MAX_DIR];

    errno = 0;

    if (!szPath)
    {
        errno = EFAULT;
        return NULL;
    }

    if (szPath[0] == '\0')
    {
        errno = ENOTDIR;
        return NULL;
    }

    /* Attempt to determine if the given path really is a directory. */
    struct Struct_Stat rcs;
    if ( Cmd_Stat(szPath,&rcs) == -1)
    {
        /* call GetLastError for more error info */
        errno = ENOENT;
        return NULL;
    }
    if (!(rcs.st_mode & _S_IFDIR))
    {
        /* Error, entry exists but not a directory. */
        errno = ENOTDIR;
        return NULL;
    }

    /* Make an absolute pathname.  */
    fileFullName (szFullPath, szPath, CL_MAX_DIR);

    /* Allocate enough space to store DIR structure and the complete
    * directory path given. */
    //nd = (DIR *) malloc (sizeof (DIR) + stringLength (szFullPath) + stringLength (DIRENT_SLASH) +
    //					stringLength (DIRENT_SEARCH_SUFFIX)+1);
    nd = new DIR;

    if (!nd)
    {
        /* Error, out of memory. */
        errno = ENOMEM;
        return NULL;
    }

    /* Create the search expression. */
    stringCopy (nd->dd_name, szFullPath);

    /* Add on a slash if the path does not end with one. */
    if (nd->dd_name[0] != '\0' &&
            nd->dd_name[stringLength (nd->dd_name) - 1] != '/' &&
            nd->dd_name[stringLength (nd->dd_name) - 1] != '\\')
    {
        stringCat (nd->dd_name, DIRENT_SLASH);
    }

    /* Add on the search pattern */
    stringCat (nd->dd_name, DIRENT_SEARCH_SUFFIX);

    /* Initialize handle to -1 so that a premature closedir doesn't try
    * to call _findclose on it. */
    nd->dd_handle = -1;

    /* Initialize the status. */
    nd->dd_stat = 0;

    /* Initialize the dirent structure. ino and reclen are invalid under
    * Win32, and name simply points at the appropriate part of the
    * findfirst_t structure. */
    //nd->dd_dir.d_ino = 0;
    //nd->dd_dir.d_reclen = 0;
    nd->dd_dir.d_namlen = 0;
    nd->dd_dir.d_name = nd->dd_dta.name;

    return nd;
}
예제 #12
0
/*
* readdir
*
* Return a pointer to a dirent structure filled with the information on the
* next entry in the directory.
*/
struct dirent * readdir (DIR * dirp)
{
    errno = 0;

    /* Check for valid DIR struct. */
    if (!dirp)
    {
        errno = EFAULT;
        return NULL;
    }

    if (dirp->dd_dir.d_name != dirp->dd_dta.name)
    {
        /* The structure does not seem to be set up correctly. */
        errno = EINVAL;
        return NULL;
    }

    if (dirp->dd_stat < 0)
    {
        /* We have already returned all files in the directory
        * (or the structure has an invalid dd_stat). */
        return NULL;
    }
    else if (dirp->dd_stat == 0)
    {
        /* We haven't started the search yet. */
        /* Start the search */
        dirp->dd_handle = CmdFindFirst (dirp->dd_name, &(dirp->dd_dta));

        if (dirp->dd_handle == -1)
        {
            /* Whoops! Seems there are no files in that
            * directory. */
            dirp->dd_stat = -1;
        }
        else
        {
            dirp->dd_stat = 1;
        }
    }
    else
    {
        /* Get the next search entry. */
        if (CmdFindNext (dirp->dd_handle, &(dirp->dd_dta)))
        {
            /* We are off the end or otherwise error. */
            _findclose (dirp->dd_handle);
            dirp->dd_handle = -1;
            dirp->dd_stat = -1;
        }
        else
        {
            /* Update the status to indicate the correct
            * number. */
            dirp->dd_stat++;
        }
    }

    if (dirp->dd_stat > 0)
    {
        /* Successfully got an entry. Everything about the file is
        * already appropriately filled in except the length of the
        * file name. */
        dirp->dd_dir.d_namlen = stringLength (dirp->dd_dir.d_name);

        if ( dirp->dd_dir.d_name[0] == '.' &&
                (dirp->dd_dir.d_name[1] == 0 ||
                 (dirp->dd_dir.d_name[1] == '.' && dirp->dd_dir.d_name[2] == 0)))
            return readdir(dirp);

        struct _stat buf;
        char_t buffer[CL_MAX_DIR];
        int bl = stringLength(dirp->dd_name)-stringLength(DIRENT_SEARCH_SUFFIX);
        stringNCopy(buffer,dirp->dd_name,bl);
        buffer[bl]=0;
        stringCat(buffer, dirp->dd_dir.d_name);
        if ( Cmd_Stat(buffer,&buf) == -1 )
            return readdir(dirp);

        return &dirp->dd_dir;
    }

    return NULL;
}