Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : CubitUtil.cc
3 : : //
4 : : // Purpose : This file contains utility functions that can be used
5 : : // throughout Cubit.
6 : : //
7 : : // Special Notes : This is a pure virtual class, to prevent instantiation.
8 : : // All functions are static, called like this:
9 : : // CubitUtil::function_name();
10 : : //
11 : : // Creator : Darryl Melander
12 : : //
13 : : // Date : 06/08/98
14 : : //
15 : : // Owner : Darryl Melander
16 : : //-------------------------------------------------------------------------
17 : :
18 : : #include "CubitUtil.hpp"
19 : : #include "CubitString.hpp"
20 : : #include "CubitEntity.hpp"
21 : : #include "CubitMessage.hpp"
22 : :
23 : : #include "AppUtil.hpp"
24 : : #include <ctype.h>
25 : : #include <time.h>
26 : : #include <sstream>
27 : :
28 : :
29 : : #ifdef _WIN32
30 : : #include "windows.h"
31 : : #else
32 : : #include <unistd.h>
33 : : #include <sys/utsname.h>
34 : : #endif
35 : :
36 : : FILE *CubitUtil::fp = NULL;
37 : : static int displayDigits = -1;
38 : :
39 : :
40 : 0 : int CubitUtil::get_digits()
41 : : {
42 : 0 : return displayDigits;
43 : : }
44 : :
45 : 0 : void CubitUtil::set_digits(int new_digits)
46 : : {
47 : 0 : displayDigits = new_digits;
48 : 0 : }
49 : :
50 : :
51 : 0 : void CubitUtil::convert_string_to_lowercase(char *string)
52 : : {
53 : 0 : register char *p = string;
54 [ # # ]: 0 : while (*p)
55 : : {
56 [ # # ][ # # ]: 0 : if (isascii(*p) && isupper(*p))
57 : 0 : *p = tolower(*p);
58 : 0 : p++;
59 : : }
60 : 0 : }
61 : :
62 : 0 : int CubitUtil::strcmp_case_insensitive (const char *s1, const char *s2)
63 : : {
64 : : char c1, c2;
65 : :
66 [ # # ]: 0 : do
67 : : {
68 : 0 : c1 = *s1++;
69 [ # # ]: 0 : if(isupper(c1))
70 : 0 : c1 = tolower(c1);
71 : :
72 : 0 : c2 = *s2++;
73 [ # # ]: 0 : if(isupper(c2))
74 : 0 : c2 = tolower(c2);
75 : :
76 [ # # ]: 0 : if(c1 != c2)
77 : 0 : return c1 - c2;
78 : :
79 : : } while(c1 != '\0');
80 : :
81 : 0 : return 0;
82 : : }
83 : :
84 : 0 : int CubitUtil::strncmp_case_insensitive (const char *s1, const char *s2,
85 : : int n)
86 : : {
87 : : char c1, c2;
88 : :
89 [ # # ]: 0 : do
90 : : {
91 : 0 : c1 = *s1++;
92 [ # # ]: 0 : if(isupper(c1))
93 : 0 : c1 = tolower(c1);
94 : :
95 : 0 : c2 = *s2++;
96 [ # # ]: 0 : if(isupper(c2))
97 : 0 : c2 = tolower(c2);
98 : :
99 [ # # ]: 0 : if(c1 != c2)
100 : 0 : return c1 - c2;
101 : :
102 : 0 : n--;
103 [ # # ]: 0 : } while(c1 && n > 0);
104 : :
105 : 0 : return 0;
106 : : }
107 : :
108 : 0 : void CubitUtil::list_ids( const char *const heading,
109 : : const DLIList<CubitEntity*> &entity_list,
110 : : int should_sort, int report_once,
111 : : int wrap )
112 : : {
113 [ # # ][ # # ]: 0 : if ( entity_list.size() == 0 )
114 : : {
115 [ # # ][ # # ]: 0 : PRINT_INFO(" No %s.\n", heading );
[ # # ][ # # ]
116 : 0 : return;
117 : : }
118 [ # # ][ # # ]: 0 : DLIList <int> id_list( entity_list.size() );
119 [ # # ][ # # ]: 0 : for ( int j = 0; j < entity_list.size(); j++ )
120 : : {
121 [ # # ][ # # ]: 0 : id_list.append( entity_list[j]->id() );
[ # # ]
122 : : }
123 : :
124 [ # # ][ # # ]: 0 : if ( id_list.size() == 1 )
125 : : {
126 [ # # ][ # # ]: 0 : PRINT_INFO(" The 1 %s id is %d.\n", heading, id_list[0]);
[ # # ][ # # ]
[ # # ]
127 : 0 : return;
128 : : }
129 [ # # ][ # # ]: 0 : sort_and_print_ids( heading, id_list, should_sort, report_once, wrap );
[ # # ]
130 : : }
131 : :
132 : 0 : void CubitUtil::sort_and_print_ids( const char *const heading,
133 : : DLIList<int> &id_list,
134 : : int should_sort, int report_once,
135 : : int wrap )
136 : : {
137 : : // sort, if desired
138 [ # # ]: 0 : if ( should_sort ) {
139 : 0 : id_list.sort();
140 : : }
141 : :
142 [ # # ]: 0 : if ( report_once ) {
143 [ # # ]: 0 : DLIList <int> id_list_2( id_list );
144 [ # # ]: 0 : id_list_2.reset();
145 [ # # ]: 0 : id_list.clean_out();
146 [ # # ][ # # ]: 0 : id_list.append( id_list_2.get_and_step() );
147 [ # # ][ # # ]: 0 : for ( int j = id_list_2.size()-1; j--; )
148 : : {
149 [ # # ][ # # ]: 0 : if ( id_list_2.get() != id_list_2.prev() )
[ # # ]
150 [ # # ][ # # ]: 0 : id_list.append( id_list_2.get() );
151 [ # # ]: 0 : id_list_2.step();
152 [ # # ]: 0 : }
153 : : }
154 : :
155 [ # # ]: 0 : if( wrap == -1 )
156 : : {
157 : : // print out ranges
158 : 0 : int begin = id_list.get_and_step();
159 : 0 : int end = begin;
160 : 0 : int current = -1;
161 [ # # ][ # # ]: 0 : PRINT_INFO(" The %d %s ids are %d", id_list.size(), heading, begin);
162 [ # # ]: 0 : for (int i=id_list.size()-1; i > 0; i--) {
163 : 0 : current = id_list.get_and_step();
164 [ # # ]: 0 : if (current == end+1) {
165 : 0 : end++;
166 : : }
167 : : else {
168 [ # # ]: 0 : if (end == begin) {
169 [ # # ][ # # ]: 0 : PRINT_INFO(", %d", current);
170 : : }
171 [ # # ]: 0 : else if (end == begin+1) {
172 [ # # ][ # # ]: 0 : PRINT_INFO(", %d, %d", end, current);
173 : : }
174 : : else {
175 [ # # ][ # # ]: 0 : PRINT_INFO(" to %d, %d", end, current);
176 : : }
177 : 0 : begin = current;
178 : 0 : end = begin;
179 : : }
180 : : }
181 [ # # ]: 0 : if (current == begin + 1) {
182 [ # # ][ # # ]: 0 : PRINT_INFO(", %d", current);
183 : : }
184 [ # # ]: 0 : else if (current != begin) {
185 [ # # ][ # # ]: 0 : PRINT_INFO(" to %d", current);
186 : : }
187 [ # # ][ # # ]: 0 : PRINT_INFO(".\n");
188 : : }
189 : : else
190 : : {
191 : : char pre_string[67];
192 [ # # ]: 0 : sprintf( pre_string, " The %d %s ids are: ", id_list.size(),heading );
193 : : CubitUtil::list_entity_ids( pre_string, id_list, wrap, ".\n", CUBIT_FALSE,
194 [ # # ]: 0 : CUBIT_FALSE );
195 : : }
196 : 0 : }
197 : :
198 : 938 : void CubitUtil::list_entity_ids( const char *pre_string,
199 : : const DLIList<CubitEntity*> &entity_list,
200 : : int width, const char *post_string,
201 : : int sort, int unique,
202 : : int tab, const char *sep_string,
203 : : const char *post_string_none )
204 : : {
205 [ + - ][ + - ]: 938 : DLIList <int> id_list( entity_list.size() );
206 [ + - ][ + + ]: 2761 : for ( int i=0; i<entity_list.size(); i++ )
207 [ + - ][ + - ]: 1823 : id_list.append( entity_list.next(i)->id() );
[ + - ]
208 : :
209 : : list_entity_ids( pre_string, id_list, width, post_string, sort,
210 [ + - ][ + - ]: 938 : unique, tab, sep_string, post_string_none );
211 : 938 : }
212 : :
213 : 1350 : void CubitUtil::list_entity_ids( const char *pre_string,
214 : : DLIList<int> &id_list,
215 : : int width,
216 : : const char *post_string,
217 : : int sort, int unique,
218 : : int tab_len, const char *sep_string,
219 : : const char *post_string_none )
220 : : {
221 [ + - ]: 1350 : CubitString ret_str;
222 : : process_entity_ids( 1, ret_str, pre_string, id_list, width, post_string,
223 [ + - ][ + - ]: 1350 : sort, unique, tab_len, sep_string, post_string_none );
224 : 1350 : }
225 : :
226 : 0 : CubitString CubitUtil::get_entity_ids_str( const char *pre_string,
227 : : DLIList<int> &id_list,
228 : : int width, const char *post_string,
229 : : int sort, int unique, int tab_len,
230 : : const char *sep_string,
231 : : const char *post_string_none )
232 : : {
233 : 0 : CubitString ret_str;
234 : :
235 : : process_entity_ids( 0, ret_str, pre_string, id_list, width, post_string,
236 [ # # ]: 0 : sort, unique, tab_len, sep_string, post_string_none );
237 : 0 : return ret_str;
238 : : }
239 : :
240 : 1350 : void CubitUtil::process_entity_ids( int method,
241 : : CubitString &ret_str,
242 : : const char *pre_string,
243 : : DLIList<int> &id_list,
244 : : int max_len,
245 : : const char *post_string,
246 : : int sort, int unique,
247 : : int tab_len, const char *sep_string,
248 : : const char* post_string_none )
249 : : {
250 : : // Method: 0 - to a string
251 : : // 1 - to PRINT_INFO
252 : : char temp[200];
253 : :
254 [ + - ][ - + ]: 1350 : if ( id_list.size() == 0 ) {
255 [ # # ]: 0 : if( method )
256 [ # # ][ # # ]: 0 : PRINT_INFO("%s%s", pre_string, post_string_none );
[ # # ][ # # ]
257 : : else
258 : : {
259 : 0 : sprintf( temp, "%s%s", pre_string, post_string_none );
260 [ # # ][ # # ]: 0 : ret_str = temp;
[ # # ]
261 : : }
262 [ # # ]: 0 : if( fp )
263 [ # # ]: 0 : fprintf( fp, "%s%s", pre_string, post_string_none );
264 : 1350 : return;
265 : : }
266 : :
267 : : // sort
268 [ + - ]: 1350 : if( sort )
269 : : {
270 [ + - ]: 1350 : id_list.sort();
271 : :
272 : : // make unique
273 [ + - ]: 1350 : if( unique )
274 : : {
275 : : int i;
276 [ + - ]: 1350 : DLIList <int> id_list_2( id_list );
277 [ + - ]: 1350 : id_list_2.reset();
278 [ + - ]: 1350 : id_list.clean_out();
279 [ + - ][ + - ]: 1350 : id_list.append( id_list_2.get_and_step() );
280 [ + - ][ + + ]: 2628 : for ( i=id_list_2.size()-1; i--; )
281 : : {
282 [ + - ][ + - ]: 1278 : if ( id_list_2.get() != id_list_2.prev() )
[ + - ]
283 [ + - ][ + - ]: 1278 : id_list.append( id_list_2.get() );
284 [ + - ]: 1278 : id_list_2.step();
285 [ + - ]: 1350 : }
286 : : }
287 : : }
288 : :
289 [ - + ]: 1350 : if( max_len < 0 )
290 : 0 : max_len = CUBIT_INT_MAX/2;
291 : :
292 : : // TODO: wrap prestring, if necessary
293 [ + - ]: 1350 : if( method )
294 [ + - ][ + - ]: 1350 : PRINT_INFO( "%s", pre_string );
[ + - ][ + - ]
295 : : else
296 [ # # ][ # # ]: 0 : ret_str = pre_string;
[ # # ]
297 [ - + ]: 1350 : if( fp )
298 [ # # ]: 0 : fprintf( fp, "%s", pre_string );
299 : :
300 : : // Keep track of length printed
301 : 1350 : int curr_len = strlen(pre_string);
302 : :
303 : 1350 : int num = 0;
304 [ + - ]: 1350 : int begin = id_list.get();
305 : 1350 : int previous = begin;
306 : : int current;
307 : 1350 : int comma = 0; // Is comma needed
308 : : int beg_len, prev_len;
309 : 1350 : int sep_len = strlen( sep_string );
310 : :
311 : : // Setup the tab
312 [ + - ]: 1350 : char* tab = new char[tab_len+1];
313 [ + + ]: 5400 : for( int i=0; i<tab_len; i++ )
314 : 4050 : tab[i] = ' ';
315 : 1350 : tab[tab_len] = '\0';
316 : :
317 : : // Loop until all the ids are printed. Use ranges if possible.
318 [ + - ][ + + ]: 5328 : while( num < id_list.size()+1 )
319 : : {
320 [ + - ]: 3978 : current = id_list.get_and_step();
321 : 3978 : num++;
322 : :
323 : : // Handle last entity
324 [ + - ][ + + ]: 3978 : if( num <= id_list.size() )
325 : : {
326 [ + + ]: 2628 : if( num==1 ) // Handle 1st time in loop
327 : 1350 : continue;
328 : :
329 [ + - ]: 1278 : if( current==previous+1 )
330 : : {
331 : 1278 : previous = current;
332 : 1278 : continue;
333 : : }
334 : : }
335 : :
336 : : // If we are here, we are no longer tracking a range and
337 : : // need to print the range or a number.
338 [ - + ]: 1350 : if( comma )
339 : : {
340 [ # # ]: 0 : if( method )
341 [ # # ][ # # ]: 0 : PRINT_INFO("%s", sep_string );
[ # # ][ # # ]
342 : : else
343 [ # # ][ # # ]: 0 : ret_str += sep_string;
[ # # ]
344 [ # # ]: 0 : if( fp )
345 [ # # ]: 0 : fprintf( fp, "%s", sep_string );
346 : 0 : curr_len += sep_len;
347 : : }
348 : :
349 [ + + ]: 1350 : if( begin==previous )
350 : : {
351 : : // a single number
352 [ + - ]: 932 : prev_len = int_len(previous);
353 : :
354 [ - + ]: 932 : if( curr_len+1+prev_len+sep_len > max_len )
355 : : {
356 [ # # ]: 0 : if( method )
357 : : {
358 [ # # ][ # # ]: 0 : PRINT_INFO( "\n" );
[ # # ][ # # ]
359 [ # # ][ # # ]: 0 : PRINT_INFO( "%s%d", tab, previous );
[ # # ][ # # ]
360 : : }
361 : : else
362 : : {
363 : 0 : sprintf( temp, "\n%s%d", tab, previous );
364 [ # # ][ # # ]: 0 : ret_str += temp;
[ # # ]
365 : : }
366 [ # # ]: 0 : if( fp )
367 [ # # ]: 0 : fprintf( fp, "\n%s%d", tab, previous );
368 : 0 : curr_len = tab_len + prev_len;
369 : : }
370 : : else
371 : : {
372 [ - + ]: 932 : if( comma ) // Don't print space before first item
373 : : {
374 [ # # ]: 0 : if( method )
375 [ # # ][ # # ]: 0 : PRINT_INFO( " " );
[ # # ][ # # ]
376 : : else
377 [ # # ][ # # ]: 0 : ret_str += " ";
[ # # ]
378 [ # # ]: 0 : if( fp )
379 [ # # ]: 0 : fprintf( fp, " " );
380 : 0 : curr_len++;
381 : : }
382 : :
383 [ + - ]: 932 : if( method )
384 [ + - ][ + - ]: 932 : PRINT_INFO( "%d", previous );
[ + - ][ + - ]
385 : : else
386 : : {
387 : 0 : sprintf( temp, "%d", previous );
388 [ # # ][ # # ]: 0 : ret_str += temp;
[ # # ]
389 : : }
390 [ - + ]: 932 : if( fp )
391 [ # # ]: 0 : fprintf( fp, "%d", previous );
392 : 932 : curr_len = curr_len + prev_len;
393 : : }
394 : : }
395 [ + + ]: 418 : else if( previous==begin+1 )
396 : : {
397 : : // a range, but only 2 consecutive numbers
398 [ + - ]: 268 : prev_len = int_len(previous);
399 [ + - ]: 268 : beg_len = int_len(begin);
400 : :
401 : : // Print 1st
402 [ - + ]: 268 : if( curr_len+1+beg_len+sep_len > max_len )
403 : : {
404 [ # # ]: 0 : if( method )
405 : : {
406 [ # # ][ # # ]: 0 : PRINT_INFO( "\n" );
[ # # ][ # # ]
407 [ # # ][ # # ]: 0 : PRINT_INFO( "%s%d%s", tab, begin, sep_string );
[ # # ][ # # ]
408 : : }
409 : : else
410 : : {
411 : 0 : sprintf( temp, "\n%s%d%s", tab, begin, sep_string );
412 [ # # ][ # # ]: 0 : ret_str += temp;
[ # # ]
413 : : }
414 [ # # ]: 0 : if( fp )
415 [ # # ]: 0 : fprintf( fp, "\n%s%d%s", tab, begin, sep_string );
416 : 0 : curr_len = tab_len + beg_len + sep_len;
417 : : }
418 : : else
419 : : {
420 [ - + ]: 268 : if( comma ) // Don't print space before first item
421 : : {
422 [ # # ]: 0 : if( method )
423 [ # # ][ # # ]: 0 : PRINT_INFO( " " );
[ # # ][ # # ]
424 : : else
425 [ # # ][ # # ]: 0 : ret_str += " ";
[ # # ]
426 [ # # ]: 0 : if( fp )
427 [ # # ]: 0 : fprintf( fp, " " );
428 : 0 : curr_len++;
429 : : }
430 : :
431 [ + - ]: 268 : if( method )
432 [ + - ][ + - ]: 268 : PRINT_INFO( "%d%s", begin, sep_string );
[ + - ][ + - ]
433 : : else
434 : : {
435 : 0 : sprintf( temp, "%d%s", begin, sep_string );
436 [ # # ][ # # ]: 0 : ret_str += temp;
[ # # ]
437 : : }
438 [ - + ]: 268 : if( fp )
439 [ # # ]: 0 : fprintf( fp, "%d%s", begin, sep_string );
440 : 268 : curr_len = curr_len + beg_len + sep_len;
441 : : }
442 : :
443 : : // Print 2nd
444 [ - + ]: 268 : if( curr_len+1+prev_len+sep_len > max_len )
445 : : {
446 [ # # ]: 0 : if( method )
447 : : {
448 [ # # ][ # # ]: 0 : PRINT_INFO( "\n" );
[ # # ][ # # ]
449 [ # # ][ # # ]: 0 : PRINT_INFO( "%s%d", tab, previous );
[ # # ][ # # ]
450 : : }
451 : : else
452 : : {
453 : 0 : sprintf( temp, "\n%s%d", tab, previous );
454 [ # # ][ # # ]: 0 : ret_str += temp;
[ # # ]
455 : : }
456 [ # # ]: 0 : if( fp )
457 [ # # ]: 0 : fprintf( fp, "\n%s%d", tab, previous );
458 : 0 : curr_len = tab_len + prev_len;
459 : : }
460 : : else
461 : : {
462 [ + - ]: 268 : if( method )
463 [ + - ][ + - ]: 268 : PRINT_INFO( " %d", previous );
[ + - ][ + - ]
464 : : else
465 : : {
466 : 0 : sprintf( temp, " %d", previous );
467 [ # # ][ # # ]: 0 : ret_str += temp;
[ # # ]
468 : : }
469 [ - + ]: 268 : if( fp )
470 [ # # ]: 0 : fprintf( fp, " %d", previous );
471 : 268 : curr_len = curr_len + 1+prev_len;
472 : : }
473 : : }
474 : : else
475 : : {
476 : : // a range of 3 or more consecutive numbers
477 [ + - ]: 150 : prev_len = int_len(previous);
478 [ + - ]: 150 : beg_len = int_len(begin);
479 : :
480 [ - + ]: 150 : if( curr_len+beg_len+prev_len+5+sep_len > max_len )
481 : : {
482 [ # # ]: 0 : if( method )
483 : : {
484 [ # # ][ # # ]: 0 : PRINT_INFO( "\n" );
[ # # ][ # # ]
485 [ # # ][ # # ]: 0 : PRINT_INFO( "%s%d to %d", tab, begin, previous );
[ # # ][ # # ]
486 : : }
487 : : else
488 : : {
489 : 0 : sprintf( temp, "\n%s%d to %d", tab, begin, previous );
490 [ # # ][ # # ]: 0 : ret_str += temp;
[ # # ]
491 : : }
492 [ # # ]: 0 : if( fp )
493 [ # # ]: 0 : fprintf( fp, "\n%s%d to %d", tab, begin, previous );
494 : 0 : curr_len = tab_len + beg_len+prev_len+4;
495 : : }
496 : : else
497 : : {
498 [ - + ]: 150 : if( comma ) // Don't print space before first item
499 : : {
500 [ # # ]: 0 : if( method )
501 [ # # ][ # # ]: 0 : PRINT_INFO( " " );
[ # # ][ # # ]
502 : : else
503 [ # # ][ # # ]: 0 : ret_str += " ";
[ # # ]
504 [ # # ]: 0 : if( fp )
505 [ # # ]: 0 : fprintf( fp, " " );
506 : 0 : curr_len++;
507 : : }
508 : :
509 [ + - ]: 150 : if( method )
510 [ + - ][ + - ]: 150 : PRINT_INFO( "%d to %d", begin, previous );
[ + - ][ + - ]
511 : : else
512 : : {
513 : 0 : sprintf( temp, "%d to %d", begin, previous );
514 [ # # ][ # # ]: 0 : ret_str += temp;
[ # # ]
515 : : }
516 [ - + ]: 150 : if( fp )
517 [ # # ]: 0 : fprintf( fp, "%d to %d", begin, previous );
518 : 150 : curr_len = curr_len + beg_len+4+prev_len;
519 : : }
520 : : }
521 : :
522 : 1350 : begin = current;
523 : 1350 : previous = current;
524 : 1350 : comma = 1;
525 : :
526 : : }
527 : :
528 : : //TODO: wrap poststring, if required
529 [ + - ]: 1350 : if (post_string) {
530 : :
531 [ + - ]: 1350 : if( method )
532 [ + - ][ + - ]: 1350 : PRINT_INFO( "%s", post_string );
[ + - ][ + - ]
533 : : else
534 [ # # ][ # # ]: 0 : ret_str += post_string;
[ # # ]
535 [ - + ]: 1350 : if( fp )
536 [ # # ]: 0 : fprintf( fp, "%s", post_string );
537 : : }
538 : :
539 [ + - ]: 1350 : delete [] tab;
540 : : }
541 : :
542 : : #define INTABS(n) ((n) >= 0 ? (n) : (-(n)))
543 : 1768 : int CubitUtil::int_len( int num )
544 : : {
545 : 1768 : int len = 0; // length of the string to hold the integer number
546 : : unsigned long n; // absolute value of the integer value
547 : :
548 : : // If the number is negative, add 1 for the negative sign
549 [ - + ]: 1768 : if (num < 0) len++;
550 : :
551 : : // Loop until the absolute value of the number reaches 0
552 : 1768 : n = INTABS(num);
553 [ + + ]: 2224 : do {
554 : : // Increment the length and divide the number by 10
555 : 2224 : len++;
556 : 2224 : n /= 10;
557 : : } while (n);
558 : :
559 : 1768 : return len;
560 : : }
561 : :
562 : : namespace
563 : : {
564 : : // Unix: Returns the TEMPDIR, TMP, or TEMP directory, whichever is set to a
565 : : // writeable directory. If neither is set, return /tmp.
566 : : // Windows: Return path returned by GetTempPath() windows function.
567 : : // If it doesn't return a writeable directory, use current directory.
568 : 0 : CubitString get_temp_directory()
569 : : {
570 : : #ifdef _WIN32
571 : :
572 : : //get a place to put the temporary file
573 : : const DWORD buf_size = MAX_PATH;
574 : : wchar_t temp_path[buf_size];
575 : : GetTempPathW(buf_size, temp_path);
576 : :
577 : : // If the path is not writeable, use the current directory instead
578 : : DWORD atts = GetFileAttributesW(temp_path);
579 : : #if _MSC_VER > 1200 // after VC6.0
580 : : if (atts == INVALID_FILE_ATTRIBUTES || // File doesn't exist
581 : : (atts & FILE_ATTRIBUTE_DIRECTORY) == 0 || // File isn't a directory
582 : : atts & FILE_ATTRIBUTE_READONLY) // File is read only
583 : : #else
584 : : if ((atts & FILE_ATTRIBUTE_DIRECTORY) == 0 || // File isn't a directory
585 : : atts & FILE_ATTRIBUTE_READONLY) // File is read only
586 : : #endif
587 : : {
588 : : if (DEBUG_FLAG(141))
589 : : {
590 : : PRINT_DEBUG_141("\nUsing cwd because ");
591 : : #if _MSC_VER > 1200
592 : : if (atts == INVALID_FILE_ATTRIBUTES)
593 : : {
594 : : PRINT_DEBUG_141("directory doesn't exist: %s\n", CubitString::toUtf8(temp_path).c_str());
595 : : }
596 : : else if ((atts & FILE_ATTRIBUTE_DIRECTORY) == 0)
597 : : {
598 : : PRINT_DEBUG_141("file isn't a directory: %s\n", CubitString::toUtf8(temp_path).c_str());
599 : : }
600 : : else if (atts & FILE_ATTRIBUTE_READONLY)
601 : : {
602 : : PRINT_DEBUG_141("directory is read only: %s\n", CubitString::toUtf8(temp_path).c_str());
603 : : }
604 : : #else
605 : : if ((atts & FILE_ATTRIBUTE_DIRECTORY) == 0)
606 : : {
607 : : PRINT_DEBUG_141("file isn't a directory: %s\n", CubitString::toUtf8(temp_path).c_str());
608 : : }
609 : : else if (atts & FILE_ATTRIBUTE_READONLY)
610 : : {
611 : : PRINT_DEBUG_141("directory is read only: %s\n", CubitString::toUtf8(temp_path).c_str());
612 : : }
613 : : #endif
614 : : }
615 : : temp_path[0] = '.';
616 : : temp_path[1] = '\0';
617 : : }
618 : : else
619 : : {
620 : : PRINT_DEBUG_141("\nUsing GetTempPath: %s\n", CubitString::toUtf8(temp_path).c_str());
621 : : }
622 : : return CubitString::toUtf8(temp_path);
623 : :
624 : : #else
625 : :
626 : 0 : const char* tmpdir = "/tmp";
627 : 0 : const char* env_tmpdir = getenv("TMPDIR");
628 [ # # ]: 0 : if (!env_tmpdir)
629 : 0 : env_tmpdir = getenv("TMP");
630 [ # # ]: 0 : if (!env_tmpdir)
631 : 0 : env_tmpdir = getenv("TEMP");
632 [ # # ]: 0 : if(env_tmpdir)
633 : 0 : tmpdir = env_tmpdir;
634 : :
635 : 0 : return tmpdir;
636 : :
637 : : #endif
638 : : }
639 : : }
640 : :
641 : 0 : CubitString CubitUtil::get_temporary_filename()
642 : : {
643 : :
644 [ # # ]: 0 : CubitString ret_str;
645 : :
646 : : #ifdef _WIN32
647 : :
648 : : //get a place to put the temporary file
649 : : CubitString temp_path = get_temp_directory();
650 : :
651 : : // make an empty temporary and return the name for it
652 : : wchar_t temp_file_name[MAX_PATH];
653 : : if( GetTempFileNameW(CubitString::toUtf16(temp_path.c_str()).c_str(), L"CBT", 0, temp_file_name) != 0 )
654 : : ret_str = CubitString::toUtf8(temp_file_name);
655 : :
656 : : #else
657 : :
658 [ # # ][ # # ]: 0 : CubitString tmpdir = get_temp_directory();
659 : 0 : const char* filepattern = "CBT.XXXXXX";
660 : : //needs to be two longer because of the "/"?
661 [ # # ][ # # ]: 0 : char *temp_file_name = new char[tmpdir.length() + strlen(filepattern) + 2];
662 [ # # ]: 0 : sprintf(temp_file_name, "%s/%s", tmpdir.c_str(), filepattern);
663 : :
664 : : // make an empty file and return the name for it
665 [ # # ]: 0 : int fd = mkstemp(temp_file_name);
666 [ # # ]: 0 : if( fd != -1 )
667 : : {
668 [ # # ][ # # ]: 0 : ret_str = temp_file_name;
[ # # ]
669 : : // release the open done by mkstemp,
670 : : // temporary file still exists
671 [ # # ]: 0 : close(fd);
672 : : }
673 [ # # ]: 0 : delete [] temp_file_name;
674 : :
675 : : #endif
676 : :
677 : 0 : return ret_str;
678 : : }
679 : :
680 : 0 : void CubitUtil::print_columns( const std::vector<CubitString>& array,
681 : : const CubitString& indent)
682 : : {
683 : : int term_height, term_width;
684 : :
685 [ # # ][ # # ]: 0 : if( ! AppUtil::instance()->get_terminal_size( term_height, term_width ) )
[ # # ]
686 : : {
687 [ # # ][ # # ]: 0 : for( size_t i = 0; i < array.size(); i++ )
688 : : {
689 [ # # ][ # # ]: 0 : PRINT_INFO("%s%s\n", indent.c_str(), array[i].c_str() );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
690 : : }
691 : 0 : return;
692 : : }
693 : :
694 : : // find lenth of longest string
695 : 0 : int maxlen = 0;
696 [ # # ][ # # ]: 0 : for( size_t i = 0; i < array.size(); i++ )
697 : : {
698 [ # # ][ # # ]: 0 : int len = CubitUtil::string_length(array[i].c_str());
[ # # ]
699 [ # # ]: 0 : if( len > maxlen )
700 : 0 : maxlen = len;
701 : : }
702 : :
703 [ # # ][ # # ]: 0 : char* const line = new char[CUBIT_MAX(maxlen,term_width)+2];
704 : :
705 : : // calculate number of columns of output
706 [ # # ][ # # ]: 0 : term_width -= string_length(indent.c_str());
707 : 0 : int width = maxlen + 1;
708 [ # # ]: 0 : int columns = term_width > width ? term_width / width : 1;
709 : :
710 : : // calculate number of rows of output
711 [ # # ]: 0 : int rows = array.size() / columns;
712 [ # # ][ # # ]: 0 : if( array.size() % columns )
713 : 0 : rows++;
714 : :
715 : : // calculate the width of one column
716 [ # # ]: 0 : if (columns > 1)
717 : 0 : width = maxlen + (term_width - columns * maxlen) / (columns - 1);
718 : : else
719 : 0 : width = term_width;
720 : :
721 : : // now write output
722 [ # # ]: 0 : for( int i = 0; i < rows; i++ )
723 : : {
724 : : size_t idx;
725 : : const char* str;
726 [ # # ]: 0 : char* ptr = line + sprintf( line, "%s", indent.c_str() );
727 [ # # ]: 0 : for(int j = 0; j < columns - 1; j++ )
728 : : {
729 : 0 : idx = j * rows + i;
730 [ # # ][ # # ]: 0 : if (idx < array.size() )
731 [ # # ][ # # ]: 0 : str = array[idx].c_str();
732 : : else
733 : 0 : str = "";
734 : :
735 : 0 : ptr += sprintf( ptr, "%-*s", width, str);
736 : : }
737 : :
738 : 0 : idx = (columns - 1) * rows + i;
739 [ # # ][ # # ]: 0 : if (idx < array.size() )
740 [ # # ][ # # ]: 0 : sprintf(ptr, "%s\n", array[idx].c_str());
741 : : else
742 : 0 : sprintf(ptr, "\n");
743 : :
744 [ # # ][ # # ]: 0 : PRINT_INFO( "%s", line );
[ # # ][ # # ]
745 : : }
746 : :
747 [ # # ]: 0 : delete [] line;
748 : : }
749 : :
750 : 0 : int CubitUtil::string_length( const char* string, int tabsize )
751 : : {
752 : 0 : int result = 0;
753 [ # # ]: 0 : for( ; *string ; string++ )
754 : : {
755 [ # # ]: 0 : if( *string == '\t' )
756 : 0 : result += tabsize;
757 [ # # ]: 0 : else if( *string >= ' ' )
758 : 0 : result ++;
759 : : }
760 : 0 : return result;
761 : : }
762 : :
763 : : //does the same thing as strdup... strdup is not supported by some
764 : : // compilers
765 : 253 : char* CubitUtil::util_strdup(const char *s1)
766 : : {
767 : : #ifdef CUBIT_NO_STRDUP
768 : : int len = strlen(s1)+1;
769 : : char* ret_char = (char*) malloc ( (unsigned long) len * sizeof(char));
770 : : strcpy(ret_char, s1);
771 : : return ret_char;
772 : : #else
773 : : #ifdef _WIN32
774 : : return _strdup(s1);
775 : : #else
776 : 253 : return strdup(s1);
777 : : #endif
778 : : #endif
779 : : }
780 : :
781 : 0 : void CubitUtil::cubit_sleep(int duration_in_seconds)
782 : : {
783 : : #ifdef _WIN32
784 : : ::Sleep(duration_in_seconds*1000);
785 : : #else
786 : 0 : sleep(duration_in_seconds);
787 : : #endif
788 : 0 : }
789 : :
790 : 0 : CubitString CubitUtil::getenv(const CubitString& var)
791 : : {
792 : : #ifdef _WIN32
793 : : return CubitString::toUtf8(_wgetenv(CubitString::toUtf16(var).c_str()));
794 : : #else
795 : 0 : return CubitString(::getenv(var.c_str()));
796 : : #endif
797 : : }
798 : :
799 : 0 : void CubitUtil::setenv(const CubitString& var, const CubitString& value)
800 : : {
801 : : #ifdef _WIN32
802 : : CubitString tmp = var + "=" + value;
803 : : _wputenv(CubitString::toUtf16(tmp).c_str());
804 : : #else
805 : 0 : ::setenv(var.c_str(), value.c_str(), 1);
806 : : #endif
807 : 0 : }
808 : :
809 : :
810 : 0 : CubitString CubitUtil::get_computer_name()
811 : : {
812 [ # # ]: 0 : CubitString name = "unknown";
813 : : #ifdef _WIN32
814 : : wchar_t machine_buf[MAX_COMPUTERNAME_LENGTH + 1];
815 : : DWORD machine_buf_length = MAX_COMPUTERNAME_LENGTH + 1;
816 : : if (::GetComputerNameW(machine_buf, &machine_buf_length))
817 : : name = CubitString::toUtf8(machine_buf);
818 : : #else
819 : : struct utsname uname_data;
820 [ # # ]: 0 : if( uname( &uname_data ) >= 0 )
821 : : {
822 [ # # ][ # # ]: 0 : name = uname_data.nodename;
[ # # ]
823 : : }
824 : : #endif
825 : 0 : return name;
826 : : }
827 : :
828 : 0 : CubitString CubitUtil::get_os()
829 : : {
830 : : #ifdef _WIN32
831 : : CubitString os = "Microsoft Windows";
832 : : OSVERSIONINFO osvi;
833 : :
834 : : ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
835 : : osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
836 : :
837 : : if(GetVersionEx(&osvi))
838 : : {
839 : : std::stringstream str;
840 : : str << " ";
841 : : str << osvi.dwMajorVersion << "." << osvi.dwMinorVersion;
842 : : str << " ";
843 : : str << osvi.szCSDVersion;
844 : : DWORD build = osvi.dwBuildNumber & 0xFFFF;
845 : : str << " (Build " << build << ")";
846 : : os += str.str().c_str();
847 : : }
848 : : #else
849 [ # # ]: 0 : CubitString os = "unknown";
850 : : struct utsname uname_data;
851 [ # # ]: 0 : if( uname( &uname_data ) >= 0 )
852 : : {
853 [ # # ][ # # ]: 0 : os = uname_data.sysname;
[ # # ]
854 [ # # ][ # # ]: 0 : os += " ";
[ # # ]
855 [ # # ][ # # ]: 0 : os += uname_data.release;
[ # # ]
856 : : }
857 : : #endif
858 : 0 : return os;
859 : : }
860 : :
861 : 0 : int CubitUtil::num_cpu()
862 : : {
863 : 0 : int num_cpu = 0;
864 : :
865 : : #ifdef _WIN32
866 : : SYSTEM_INFO sysinfo;
867 : : GetSystemInfo( &sysinfo );
868 : : num_cpu = sysinfo.dwNumberOfProcessors;
869 : : #else
870 : 0 : num_cpu = sysconf( _SC_NPROCESSORS_ONLN );
871 : : #endif
872 : :
873 : 0 : return num_cpu;
874 : : }
|
