NTSTATUS HandleTablehandleTranslate(PCHANDLE_TABLE HandleTable, HANDLE Handle, PVOID *Object)
{
KIRQL irql;
PCHANDLE_TABLE_MAPPING mapping = NULL;
PHASH_ITEM hashItem = NULL;
NTSTATUS status = STATUS_UNSUCCESSFUL;
DEBUG_ENTER_FUNCTION("Handletable=0x%p; Handle=0x%p; Object=0x%p", HandleTable, Handle, Object);
_HandleTableLockShared(HandleTable, &irql);
hashItem = HashTableGet(HandleTable->HashTable, Handle);
if (hashItem != NULL) {
PVOID object = NULL;
HANDLE handleValue = NULL;
PCHANDLE_TABLE handleTable = NULL;
mapping = CONTAINING_RECORD(hashItem, CHANDLE_TABLE_MAPPING, HashItem);
object = mapping->Object;
handleValue = mapping->HandleValue;
handleTable = mapping->HandleTable;
_HandleTableUnlock(HandleTable, irql);
HandleTable->HandleTranslateProcedure(handleTable, object, handleValue);
*Object = object;
status = STATUS_SUCCESS;
} else {
_HandleTableUnlock(HandleTable, irql);
status = STATUS_INVALID_HANDLE;
}
DEBUG_EXIT_FUNCTION("0x%x, *Object=0x%p", status, *Object);
return status;
}
void AsmPass1(Assembler *a, char *text) { // 第一階段的組譯
int i, address = 0, number;
Array* lines = split(text, "\r\n", REMOVE_SPLITER); // 將組合語言分割成一行一行
ArrayEach(lines, strPrintln); // 印出以便觀察
printf("=================PASS1================\n");
for (i=0; i<lines->count; i++) { // 對於每一行
strReplace(lines->item[i], ";", '\0');
strReplace(lines->item[i], "\t", ' ');
AsmCode *code = AsmCodeNew(lines->item[i]); // 建立指令物件
if (code == NULL) continue;
code->address = address; // 設定該行的位址
Op *op = NULL;
if (code->op != NULL) {
op = HashTableGet(opTable, code->op); // 查詢運算碼
if (op != NULL) { // 如果查到
code->opCode = op->code; // 設定運算碼
code->type = op->type; // 設定型態
}
}
if (code->label != NULL) // 如果有標記符號
HashTablePut(a->symTable, code->label, code); // 加入符號表中
ArrayAdd(a->codes, code); // 建構指令物件陣列
AsmCodePrintln(code); // 印出觀察
code->size = AsmCodeSize(code); // 計算指令大小
address += code->size; // 計算下一個指令位址
}
ArrayFree(lines, strFree); // 釋放記憶體
}
NTSTATUS DriverHookRecordDeleteDevice(PDEVICE_HOOK_RECORD DeviceRecord)
{
KIRQL irql;
PHASH_ITEM h = NULL;
PDRIVER_HOOK_RECORD driverRecord = NULL;
NTSTATUS status = STATUS_UNSUCCESSFUL;
PDEVICE_HOOK_RECORD deviceRecord = NULL;
DEBUG_ENTER_FUNCTION("DeviceRecord=0x%p", DeviceRecord);
driverRecord = DeviceRecord->DriverRecord;
KeAcquireSpinLock(&driverRecord->SelectedDevicesLock, &irql);
h = HashTableGet(driverRecord->SelectedDevices, DeviceRecord->DeviceObject);
if (h != NULL) {
deviceRecord = CONTAINING_RECORD(h, DEVICE_HOOK_RECORD, HashItem);
DeviceHookRecordReference(deviceRecord);
KeReleaseSpinLock(&driverRecord->SelectedDevicesLock, irql);
if (deviceRecord->CreateReason == edrcrUserRequest) {
deviceRecord->CreateReason = edrcrDriverHooked;
deviceRecord->MonitoringEnabled = FALSE;
_InvalidateDeviceHookRecord(deviceRecord);
status = STATUS_SUCCESS;
} else status = STATUS_NOT_FOUND;
DeviceHookRecordDereference(deviceRecord);
} else {
KeReleaseSpinLock(&driverRecord->SelectedDevicesLock, irql);
status = STATUS_NOT_FOUND;
ASSERT(FALSE);
}
DEBUG_EXIT_FUNCTION("0x%x", status);
return status;
}
WordFormRule *WordFormGetRules(char *suffix1, char *lefeat1)
{
char index[PHRASELEN];
StringCpy(index, suffix1, PHRASELEN);
StringCat(index, lefeat1, PHRASELEN);
return((WordFormRule *)HashTableGet(WordFormHt, index));
}
NTSTATUS DriverHookRecordAddDevice(PDRIVER_HOOK_RECORD DriverRecord, PDEVICE_OBJECT DeviceObject, PUCHAR IRPSettings, PUCHAR FastIoSettings, BOOLEAN MonitoringEnabled, PDEVICE_HOOK_RECORD *DeviceRecord)
{
KIRQL irql;
PHASH_ITEM h = NULL;
PDEVICE_HOOK_RECORD newDeviceRecord = NULL;
NTSTATUS status = STATUS_UNSUCCESSFUL;
DEBUG_ENTER_FUNCTION("Record=0x%p; DeviceObject=0x%p; IRPSettings=0x%p; FastIoSettings=0x%p; MonitoringEnabled=%u; DeviceRecord=0x%p", DriverRecord, DeviceObject, IRPSettings, FastIoSettings, MonitoringEnabled, DeviceRecord);
status = _DeviceHookRecordCreate(DriverRecord, &newDeviceRecord, IRPSettings, FastIoSettings, MonitoringEnabled, edrcrUserRequest, DeviceObject);
if (NT_SUCCESS(status)) {
KeAcquireSpinLock(&DriverRecord->SelectedDevicesLock, &irql);
h = HashTableGet(DriverRecord->SelectedDevices, DeviceObject);
if (h == NULL) {
// For the hash table
DeviceHookRecordReference(newDeviceRecord);
HashTableInsert(DriverRecord->SelectedDevices, &newDeviceRecord->HashItem, DeviceObject);
KeReleaseSpinLock(&DriverRecord->SelectedDevicesLock, irql);
_MakeDeviceHookRecordValid(newDeviceRecord);
// For the reference going out of this routine
DeviceHookRecordReference(newDeviceRecord);
*DeviceRecord = newDeviceRecord;
} else {
PDEVICE_HOOK_RECORD existingDeviceRecord = NULL;
existingDeviceRecord = CONTAINING_RECORD(h, DEVICE_HOOK_RECORD, HashItem);
DeviceHookRecordReference(existingDeviceRecord);
KeReleaseSpinLock(&DriverRecord->SelectedDevicesLock, irql);
if (existingDeviceRecord->CreateReason == edrcrDriverHooked) {
memset(existingDeviceRecord->IRPMonitorSettings, TRUE, (IRP_MJ_MAXIMUM_FUNCTION + 1)*sizeof(UCHAR));
if (IRPSettings != NULL)
memcpy(existingDeviceRecord->IRPMonitorSettings, IRPSettings, (IRP_MJ_MAXIMUM_FUNCTION + 1)*sizeof(UCHAR));
memset(existingDeviceRecord->FastIoMonitorSettings, TRUE, FastIoMax*sizeof(UCHAR));
if (FastIoSettings != NULL)
memcpy(existingDeviceRecord->FastIoMonitorSettings, FastIoSettings, FastIoMax*sizeof(UCHAR));
existingDeviceRecord->CreateReason = edrcrUserRequest;
existingDeviceRecord->MonitoringEnabled = MonitoringEnabled;
_MakeDeviceHookRecordValid(existingDeviceRecord);
DeviceHookRecordReference(existingDeviceRecord);
*DeviceRecord = existingDeviceRecord;
status = STATUS_SUCCESS;
} else status = STATUS_ALREADY_REGISTERED;
DeviceHookRecordDereference(existingDeviceRecord);
}
DeviceHookRecordDereference(newDeviceRecord);
}
DEBUG_EXIT_FUNCTION("0x%x, *DeviceRecord=0x%p", status, *DeviceRecord);
return status;
}
static VOID _InvalidateDriverHookRecord(PDRIVER_HOOK_RECORD DriverRecord)
{
KIRQL irql;
DEBUG_ENTER_FUNCTION("DriverRecord=0x%p", DriverRecord);
KeAcquireSpinLock(&_driverValidationTableLock, &irql);
ASSERT(HashTableGet(_driverValidationTable, DriverRecord) != NULL);
HashTableDelete(_driverValidationTable, DriverRecord);
KeReleaseSpinLock(&_driverValidationTableLock, irql);
DEBUG_EXIT_FUNCTION_VOID();
return;
}
static VOID _MakeDriverHookRecordValid(PDRIVER_HOOK_RECORD DriverRecord)
{
KIRQL irql;
DEBUG_ENTER_FUNCTION("DriverRecord=0x%p", DriverRecord);
KeAcquireSpinLock(&_driverValidationTableLock, &irql);
ASSERT(HashTableGet(_driverValidationTable, DriverRecord) == NULL);
HashTableInsert(_driverValidationTable, &DriverRecord->ValidationHashItem, DriverRecord);
KeReleaseSpinLock(&_driverValidationTableLock, irql);
DEBUG_EXIT_FUNCTION_VOID();
return;
}
NTSTATUS HookDriverObject(PDRIVER_OBJECT DriverObject, PDRIVER_MONITOR_SETTINGS MonitorSettings, PDRIVER_HOOK_RECORD *DriverRecord)
{
KIRQL irql;
PDRIVER_HOOK_RECORD record = NULL;
PDEVICE_HOOK_RECORD *existingDevices = NULL;
ULONG existingDeviceCount = 0;
NTSTATUS status = STATUS_UNSUCCESSFUL;
DEBUG_ENTER_FUNCTION("DriverObject=0x%p; MonitorSettings=%u; DriverRecord=0x%p", DriverObject, MonitorSettings, DriverRecord);
status = _DriverHookRecordCreate(DriverObject, MonitorSettings, FALSE, &record);
if (NT_SUCCESS(status)) {
status = _CreateRecordsForExistingDevices(record, &existingDevices, &existingDeviceCount);
if (NT_SUCCESS(status)) {
KeAcquireSpinLock(&_driverTableLock, &irql);
if (HashTableGet(_driverTable, DriverObject) == NULL) {
KIRQL irql2;
ULONG i = 0;
DriverHookRecordReference(record);
HashTableInsert(_driverTable, &record->HashItem, DriverObject);
KeAcquireSpinLock(&record->SelectedDevicesLock, &irql2);
for (i = 0; i < existingDeviceCount; ++i) {
PDEVICE_HOOK_RECORD deviceRecord = existingDevices[i];
DeviceHookRecordReference(deviceRecord);
HashTableInsert(record->SelectedDevices, &deviceRecord->HashItem, deviceRecord->DeviceObject);
}
KeReleaseSpinLock(&record->SelectedDevicesLock, irql2);
KeReleaseSpinLock(&_driverTableLock, irql);
_MakeDriverHookRecordValid(record);
if (record->MonitoringEnabled)
_HookDriverObject(DriverObject, record);
DriverHookRecordReference(record);
*DriverRecord = record;
} else {
KeReleaseSpinLock(&_driverTableLock, irql);
status = STATUS_ALREADY_REGISTERED;
}
_FreeDeviceHookRecordArray(existingDevices, existingDeviceCount);
}
DriverHookRecordDereference(record);
}
DEBUG_EXIT_FUNCTION("0x%x, *DriverRecord=0x%p", status, *DriverRecord);
return status;
}
BOOLEAN DriverHookRecordValid(PDRIVER_HOOK_RECORD DriverRecord)
{
KIRQL irql;
BOOLEAN ret = FALSE;
DEBUG_ENTER_FUNCTION("DriverRecord=0x%p", DriverRecord);
KeAcquireSpinLock(&_driverValidationTableLock, &irql);
ret = HashTableGet(_driverValidationTable, DriverRecord) != NULL;
if (ret)
DriverHookRecordReference(DriverRecord);
KeReleaseSpinLock(&_driverValidationTableLock, irql);
DEBUG_EXIT_FUNCTION("%u", ret);
return ret;
}
void AsmCodeParse(AsmCode *code, Assembler *a) {
int i, rIdx=0;
for (i=0; i<3; i++) {
if (code->arg[i] == NULL)
break;
if (sscanf(code->arg[i], "R%d", &code->r[rIdx])>0) // 可能是暫存器，例如 R1
rIdx++;
else if (sscanf(code->arg[i], "%d", &code->cx) == 0) { // 可能是常數，例如 37
AsmCode *labelCode = HashTableGet(a->symTable, code->arg[i]); // 可能是符號
if (labelCode != NULL) {
code->cx = labelCode->address - code->address - 4; // 計算 cx 欄位，相對於 PC 編碼
code->r[rIdx++] = 15; // rb = PC = R15
}
}
}
code->rCount = rIdx;
}
PDEVICE_HOOK_RECORD DriverHookRecordGetDevice(PDRIVER_HOOK_RECORD Record, PDEVICE_OBJECT DeviceObject)
{
KIRQL irql;
PHASH_ITEM h = NULL;
PDEVICE_HOOK_RECORD ret = NULL;
DEBUG_ENTER_FUNCTION("Record=0x%p; DeviceObject=0x%p", Record, DeviceObject);
KeAcquireSpinLock(&Record->SelectedDevicesLock, &irql);
h = HashTableGet(Record->SelectedDevices, DeviceObject);
if (h != NULL) {
ret = CONTAINING_RECORD(h, DEVICE_HOOK_RECORD, HashItem);
DeviceHookRecordReference(ret);
}
KeReleaseSpinLock(&Record->SelectedDevicesLock, irql);
DEBUG_EXIT_FUNCTION("0x%p", ret);
return ret;
}
PDRIVER_HOOK_RECORD DriverHookRecordGet(PDRIVER_OBJECT DriverObject)
{
KIRQL irql;
PHASH_ITEM h = NULL;
PDRIVER_HOOK_RECORD ret = NULL;
DEBUG_ENTER_FUNCTION("DriverObject=0x%p", DriverObject);
KeAcquireSpinLock(&_driverTableLock, &irql);
h = HashTableGet(_driverTable, DriverObject);
if (h != NULL) {
ret = CONTAINING_RECORD(h, DRIVER_HOOK_RECORD, HashItem);
DriverHookRecordReference(ret);
}
KeReleaseSpinLock(&_driverTableLock, irql);
DEBUG_EXIT_FUNCTION("0x%p", ret);
return ret;
}
void WordFormRuleAdd(char *suffix1, char *lefeat1, char *linkfeat1,
char *suffix2, char *lefeat2, char *linkfeat2,
LexEntry *le1, LexEntry *le2)
{
char index[PHRASELEN];
WordFormRule *wfr;
wfr = CREATE(WordFormRule);
wfr->count = 1;
wfr->suffix1 = suffix1;
wfr->lefeat1 = lefeat1;
wfr->linkfeat1 = linkfeat1;
wfr->suffix2 = suffix2;
wfr->lefeat2 = lefeat2;
wfr->linkfeat2 = linkfeat2;
StringCpy(index, suffix1, PHRASELEN);
StringCat(index, lefeat1, PHRASELEN);
wfr->example1 = le1;
wfr->example2 = le2;
wfr->next = (WordFormRule *)HashTableGet(WordFormHt, index);
HashTableSetDup(WordFormHt, index, wfr);
}
int transfer_SAM_to_position_table(char * sam_file)
{
char linebuf[max(2*MAX_READ_LENGTH+300,3000)];
int allreads=0,mapped=0;
char mate_chro[MAX_CHROMOSOME_NAME_LEN+1];
unsigned int mate_pos;
int flags_mate;
char cigar_mate[EXON_MAX_CIGAR_LEN+1];
gene_input_t input_file;
HashTable * local_reassembly_pileup_files;
HashTable * chromosome_size_table;
chromosome_size_table = HashTableCreate(100);
HashTableSetDeallocationFunctions(chromosome_size_table, NULL, NULL);
HashTableSetKeyComparisonFunction(chromosome_size_table, my_strcmp);
HashTableSetHashFunction(chromosome_size_table, HashTableStringHashFunction);
local_reassembly_pileup_files = HashTableCreate(100);
HashTableSetDeallocationFunctions(local_reassembly_pileup_files, NULL, NULL);
HashTableSetKeyComparisonFunction(local_reassembly_pileup_files, my_strcmp);
HashTableSetHashFunction(local_reassembly_pileup_files ,HashTableStringHashFunction);
geinput_open_sam(sam_file, &input_file,0);
while(1)
{
unsigned int read_pos =0xffffffff;
char read_name[MAX_READ_NAME_LEN+1];
int flags;
char chro_name[MAX_CHROMOSOME_NAME_LEN+1];
unsigned int pos, pair_dist;
char cigar[EXON_MAX_CIGAR_LEN+1];
char read_text[MAX_READ_LENGTH+1];
char qual_text[MAX_READ_LENGTH+1];
int read_len, is_repeated, mapping_quality, is_anchor_certain=1;
int pos_delta = 0;
int is_paired_end_reads = 0;
unsigned long long int file_offset = ftello(input_file.input_fp);
if(feof(input_file.input_fp))break;
read_text[0]=0;
qual_text[0]=0;
geinput_readline(&input_file, linebuf,0);
int res = parse_SAM_line(linebuf, read_name,& flags, chro_name, & pos, cigar, & mapping_quality, & pair_dist, read_text , qual_text, & read_len, & is_repeated);
int cigar_cursor = 0;
int firstM = 1,xx=0;
is_paired_end_reads = flags &1;
if(res==0)
{
for(; cigar[cigar_cursor]; cigar_cursor++)
{
char nch = cigar[cigar_cursor];
if(nch>='0'&&nch<='9')
{
xx=xx*10+(nch-'0');
}else
{
if(nch=='M') firstM=0;
else if(nch=='S')
{
if(firstM)
pos_delta = xx;
}
xx=0;
}
}
pos -= pos_delta;
}
if(res == 1) {chro_name[0]='*'; chro_name[1]=0;}
//printf("MAPPED=%d\n", res);
if(res == 0) // mapped
{
read_pos = pos - 1;
mapped++;
}
else if(res == 1 && is_paired_end_reads) // unmapped
{
is_anchor_certain=0;
if(mate_chro[0])
{
if(mate_chro[0]!='*')
{
read_pos = mate_pos ;
strcpy(chro_name, mate_chro);
}
//printf("RECOVERED 1: %u - %s ; LEN=%d ; YOU_ARE_FIRST=%d\n%s\n%s\n", read_anchor_position, read_name, read_len, flags_mate & SAM_FLAG_FIRST_READ_IN_PAIR, read_text, qual_text);
}
else
{
char read_text_null[MAX_READ_LENGTH+1];
char qual_text_null[MAX_READ_LENGTH+1];
geinput_readline_back(&input_file, linebuf);
res = parse_SAM_line(linebuf, read_name,& flags_mate, mate_chro, & mate_pos, cigar_mate, & mapping_quality, & pair_dist, read_text_null , qual_text_null, & read_len, & is_repeated);
if(res==0)
{
read_pos = mate_pos - 1;
strcpy(chro_name, mate_chro);
}
//printf("RECOVERED 2: %u - %s ; LEN=%d ; YOU_ARE_FIRST=%d\n%s\n%s\n", read_anchor_position, read_name, read_len, flags_mate & SAM_FLAG_FIRST_READ_IN_PAIR, read_text, qual_text);
}
}
if(read_pos<0xffff0000)
{
unsigned int read_span = calculate_read_span(cigar);
write_read_pos(chro_name, read_pos, read_len, flags, file_offset, cigar, read_span, local_reassembly_pileup_files);
unsigned int old_max_pos = HashTableGet(chromosome_size_table, chro_name) - NULL;
if(old_max_pos==0)
{
char * chro_name_new = malloc(strlen(chro_name)+1);
strcpy(chro_name_new , chro_name);
HashTablePut(chromosome_size_table, chro_name_new, NULL+read_pos + read_span+1);
}
else if(read_pos + read_span +1 > old_max_pos )
HashTablePutReplace(chromosome_size_table, chro_name, NULL+read_pos + read_span+1, 0);
}
if(allreads %2==1)
mate_chro[0] = 0;
else
{
strcpy(mate_chro, chro_name);
mate_pos = pos - 1;
flags_mate = flags;
}
allreads++;
}
SUBREADprintf("Processed %d reads; %d mapped.\n", allreads, mapped);
destroy_pileup_table(local_reassembly_pileup_files);
finalise_sam_index(chromosome_size_table, sam_file);
HashTableDestroy(chromosome_size_table);
return 0;
}
int HashTableContainsKey(const HashTable *hashTable, const void *key) {
return (HashTableGet(hashTable, key) != NULL);
}
void AsmTranslateCode(Assembler *a, AsmCode *code) { // 指令的編碼函數
char cxCode[9]="00000000";
code->objCode = memNew(code->size*2+1);
memset(code->objCode, '\0', code->size*2+1); // 目的碼為 0000…
switch (code->type) { // 根據指令型態
case 'J' : // 處理 J 型指令
AsmCodeParse(code, a);
sprintf(cxCode, "%8x", code->cx);
sprintf(code->objCode, "%2x%s", code->opCode, &cxCode[2]); // 編出目的碼(16進位)
break;
case 'L' :
AsmCodeParse(code, a);
sprintf(cxCode, "%8x", code->cx);
sprintf(code->objCode, "%2x%x%x%s", code->opCode, code->r[0], code->r[1], &cxCode[4]);
break;
case 'A' : // 處理 A 型指令
AsmCodeParse(code, a);
sprintf(cxCode, "%8x", code->cx);
sprintf(code->objCode, "%2x%x%x%x%s", code->opCode,code->r[0],code->r[1],code->r[2],&cxCode[5]); // 編出目的碼(16進位)
break;
case 'D' : { // 處理是資料宣告
// 我們將資料宣告 RESW, RESB, WORD, BYTE 也視為一種指令，其形態為 D
Array *tokens = code->tokens;
char format4[]="%8x", format1[]="%2x", *format = format1;
switch (code->opCode) { // 如果是 RESW
case OP_RESW: // 或 RESB
case OP_RESB:
memset(code->objCode, '0', code->size*2); // 目的碼為 0000….
break; // 如果是 WORD:
case OP_WORD:
format = format4; // 設定輸出格式為 %8x
case OP_BYTE: { // 如果是 BYTE : 輸出格式為 %2x
char *objPtr = code->objCode;
int i=0, si;
for (i=code->argStart; i<tokens->count; i++) {
char *item = tokens->item[i];
if (item[0] == '"') {
for (si=1; item[si] != '"'; si++) {
sprintf(objPtr, "%2x", item[si]);
objPtr += 2;
}
} else if (isdigit(item[0])) {
sprintf(objPtr, format, atoi(item));
} else {
AsmCode *itemCode = HashTableGet(a->symTable, item);
sprintf(objPtr, format, itemCode->address);
}
// strFree(item);
objPtr += strlen(objPtr);
}
break;
} // case OP_BYTE:
} // switch
break;
} // case ' '
default:
break;
}
strReplace(code->objCode, " ", '0');
strToUpper(code->objCode);
}
int main(int argc, char ** argv)
{
char * junc_table_file;
HashTable * junc_table = HashTableCreate(337);
HashTable * junc_table_l = HashTableCreate(337);
HashTable * junc_table_r = HashTableCreate(337);
HashTable * bin_table = HashTableCreate(9337);
if(argc<2)
{
printf("Usage cat my.SAM | filterJunc junc.table | featureCounts -i STDIN -a myAnnot.txt \n");
return -1;
}
junc_table_file = argv[1];
if(load_junc_table(junc_table_file, junc_table, junc_table_l, junc_table_r, bin_table))
{
printf("Junction table not found!\n");
return -1;
}
char * linebuf=malloc(5001);
char * linebuf2=malloc(5001);
while(1)
{
int support_found = 0, ii, jj, alternative_found = 0;
char * new_line = fgets(linebuf, 5000, stdin);
if(!new_line) break;
if(new_line[0]=='@')
{
fputs(new_line, stdout);
continue;
}
char * new_line2 = fgets(linebuf2, 5000, stdin);
for(ii=0;ii<2;ii++)
{
int flag=0;
char chro[20];
unsigned int pos=0;
char cigar[50];
unsigned int start_points[6];
unsigned short section_lengths[6];
parse_line(ii?new_line2:new_line, &flag, chro, &pos, cigar);
int sections = RSubread_parse_CIGAR_string(cigar, start_points, section_lengths);
for(jj=0; jj<sections-1; jj++)
{
unsigned int edge1 = start_points[jj] + pos + section_lengths[jj];
unsigned int edge2 = start_points[jj+1] + pos - 1;
unsigned long long int junc_table_key = (edge1*1LLU) <<32 | edge2;
char * junc_chro=HashTableGet(junc_table, (void *)junc_table_key);
if(junc_chro && strcmp(junc_chro, chro)==0)
{
support_found = 1;
}
else
{
char * junc_chro_l=HashTableGet(junc_table_l, NULL+edge1);
char * junc_chro_2=HashTableGet(junc_table_r, NULL+edge2);
if( (junc_chro_l && strcmp(junc_chro_l, chro)==0)
|| (junc_chro_2 && strcmp(junc_chro_2, chro)==0))
alternative_found = 1;
}
}
//if(support_found) break;
if(!support_found && !alternative_found)
for(jj=0; jj<sections; jj++)
{
unsigned int edge2 = start_points[jj] + pos + section_lengths[jj];
unsigned int edge1 = start_points[jj] + pos;
unsigned int real_edge1 = HashTableGet(bin_table, NULL+edge1/50)-NULL;
unsigned int real_edge2 = HashTableGet(bin_table, NULL+edge2/50)-NULL;
if(real_edge1)
{
long long int diff = real_edge1;
diff -= edge1;
if(abs(diff)<section_lengths[jj])
alternative_found=1;
// this section should contain the read_edge, but it does not! (it was a section as a whole)
}
if(real_edge2)
{
long long int diff = real_edge2;
diff -= edge1;
if(abs(diff)<section_lengths[jj])
alternative_found=1;
// this section should contain the read_edge, but it does not! (it was a section as a whole)
}
}
}
if(alternative_found)
//if(support_found)
{
fputs( new_line, stdout);
fputs( new_line2, stdout);
}
//printf("READ: (%d) %s,%u %s\n\n", flag2, chro2, pos2, cigar2);
}
free(linebuf);
free(linebuf2);
}
