File: Utilities.cc

package info (click to toggle)
proda 1.0-12
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 584 kB
  • sloc: cpp: 8,549; xml: 163; makefile: 109; sh: 12
file content (120 lines) | stat: -rw-r--r-- 3,413 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
//////////////////////////////////////////////////////////////////////
// Utilities.cc
//////////////////////////////////////////////////////////////////////

#include <stdlib.h>
#include <string.h>
#include "Assert.h"
#include "Utilities.h"

//////////////////////////////////////////////////////////////////////
// Read data from file.
//   
// This routine will read characters from a file object and 
// store them in the resulting buffer.  
//
// -- characters from the "terminatingChars" string are used
//    to signify when reading should stop; these characters
//    are not included in the buffer
//     
// -- the "skipChars" string denotes any other characters 
//    that should be skipped
//
// -- a NULL character is appended to the end of the read
//    string
//	
// The result returned is the length of the read buffer,
// excluding the NULL character.  If a character appears in
// both the terminating characters and the skipped characters
// strings, the former takes precedence.
//////////////////////////////////////////////////////////////////////

int GetData (FILE *file, char *&buffer, 
	     const char *terminatingChars,
	     const char *skipChars){
  
  bool isTerm[256];
  bool isSkip[256];
  
  int length = 0, capacity = 1;
  char *temp = new char[capacity];
  char ch;
  
  ASSERT (temp, "Out of memory.");
  
  // precompute character detection flags
  
  for (int i = 0; i < 256; i++) isTerm[i] = isSkip[i] = false;
  {for (int i = strlen(terminatingChars) - 1; i >= 0; i--) 
	  isTerm[(unsigned char) terminatingChars[i]] = true;}
  {for (int i = strlen(skipChars) - 1; i >= 0; i--)
	  isSkip[(unsigned char) skipChars[i]] = true;}

  // read buffer
  
  while ((ch = fgetc (file)) != EOF){
    
    if (isTerm[(unsigned char) ch]) break;
    if (isSkip[(unsigned char) ch]) continue;

    if (length == capacity){
      buffer = new char[capacity *= 2];
      ASSERT (buffer, "Out of memory.");
      
      memcpy (buffer, temp, sizeof(char) * length);
      delete[] temp;
      temp = buffer;	
    }
    
    temp[length++] = ch;
  }
  
  // trim buffer to correct length
  
  buffer = new char[length+1];
  ASSERT (buffer, "Out of memory.");
  
  memcpy (buffer, temp, sizeof(char) * length);
  buffer[length] = '\0';
  delete[] temp;

  return length;
}

//////////////////////////////////////////////////////////////////////
// Duplicate string
//////////////////////////////////////////////////////////////////////

char *StrDup (const char *s){
  int len = strlen(s);
  char *ret = new char[len+1];
  ASSERT (ret, "Out of memory.");
  memcpy (ret, s, len+1);
  return ret;
}

//////////////////////////////////////////////////////////////////////
// Substring
//////////////////////////////////////////////////////////////////////

char *SubString (const char *s, int i, int j){
  ASSERT (i >= 0 && i <= (int) strlen(s), "Invalid index.");
  ASSERT (j >= i && j <= (int) strlen(s), "Invalid index.");
  char *ret = new char[j - i + 1];
  ASSERT (ret, "Out of memory.");
  memcpy (ret, s + i, j - i);
  ret[j - i] = '\0';
  return ret;
}

///////////////////////////////////////////////////////////////////////////////
// Returns overlap length of two intervals
///////////////////////////////////////////////////////////////////////////////
int Overlap(int b1, int e1, int b2, int e2)
{
	int b = b1 > b2 ? b1 : b2;
	int e = e1 < e2 ? e1 : e2;
	return e - b + 1;
}