int CUtlBuffer::VaScanf( const char* pFmt, va_list list )
{
Assert( pFmt );
if ( m_Error || !IsText() )
return 0;
int numScanned = 0;
int nLength;
char c;
char* pEnd;
while ( c = *pFmt++ )
{
// Stop if we hit the end of the buffer
if ( m_Get >= TellMaxPut() )
{
m_Error |= GET_OVERFLOW;
break;
}
switch (c)
{
case ' ':
// eat all whitespace
EatWhiteSpace();
break;
case '%':
{
// Conversion character... try to convert baby!
char type = *pFmt++;
if (type == 0)
return numScanned;
switch(type)
{
case 'c':
{
char* ch = va_arg( list, char * );
if ( CheckPeekGet( 0, sizeof(char) ) )
{
*ch = *(const char*)PeekGet();
++m_Get;
}
else
{
*ch = 0;
return numScanned;
}
}
break;
case 'i':
case 'd':
{
int* i = va_arg( list, int * );
// NOTE: This is not bullet-proof; it assumes numbers are < 128 characters
nLength = 128;
if ( !CheckArbitraryPeekGet( 0, nLength ) )
{
*i = 0;
return numScanned;
}
*i = strtol( (char*)PeekGet(), &pEnd, 10 );
int nBytesRead = (int)( pEnd - (char*)PeekGet() );
if ( nBytesRead == 0 )
return numScanned;
m_Get += nBytesRead;
}
break;
case 'x':
{
int* i = va_arg( list, int * );
// NOTE: This is not bullet-proof; it assumes numbers are < 128 characters
nLength = 128;
if ( !CheckArbitraryPeekGet( 0, nLength ) )
{
*i = 0;
return numScanned;
}
*i = strtol( (char*)PeekGet(), &pEnd, 16 );
int nBytesRead = (int)( pEnd - (char*)PeekGet() );
if ( nBytesRead == 0 )
return numScanned;
m_Get += nBytesRead;
}
break;
case 'u':
{
unsigned int* u = va_arg( list, unsigned int *);
// NOTE: This is not bullet-proof; it assumes numbers are < 128 characters
nLength = 128;
if ( !CheckArbitraryPeekGet( 0, nLength ) )
{
*u = 0;
return numScanned;
}
*u = strtoul( (char*)PeekGet(), &pEnd, 10 );
int nBytesRead = (int)( pEnd - (char*)PeekGet() );
if ( nBytesRead == 0 )
return numScanned;
m_Get += nBytesRead;
}
break;
case 'f':
{
float* f = va_arg( list, float *);
// NOTE: This is not bullet-proof; it assumes numbers are < 128 characters
nLength = 128;
if ( !CheckArbitraryPeekGet( 0, nLength ) )
{
*f = 0.0f;
return numScanned;
}
*f = (float)strtod( (char*)PeekGet(), &pEnd );
int nBytesRead = (int)( pEnd - (char*)PeekGet() );
if ( nBytesRead == 0 )
return numScanned;
m_Get += nBytesRead;
}
break;
case 's':
{
char* s = va_arg( list, char * );
GetString( s );
}
break;
default:
{
// unimplemented scanf type
Assert(0);
return numScanned;
}
break;
}
++numScanned;
}
break;
default:
{
// Here we have to match the format string character
// against what's in the buffer or we're done.
if ( !CheckPeekGet( 0, sizeof(char) ) )
return numScanned;
if ( c != *(const char*)PeekGet() )
return numScanned;
++m_Get;
}
}
}
return numScanned;
}
template<> bool str2val< double >( const string& s, double& ret )
{
// cerr << "in str2val< double >\n";
ret = strtod( s.c_str(), 0 );
return 1;
}
int extractNumber(char **stringPointer, Token *token) {
char *start = *stringPointer;
token->type = TOKEN_TYPE_NUM;
token->value.number = strtod(start, stringPointer);
return start < *stringPointer;
}
static BOOL CALLBACK options_appearance_dialog_handler(HWND hwnd,
UINT msg, WPARAM wparam, LPARAM lParam)
{
int len;
char *temp, number[6];
HWND sub;
LOG_WIN_MSG(hwnd, msg, wparam, lParam);
switch (msg) {
case WM_INITDIALOG:
sub = GetDlgItem(hwnd, IDC_PREFS_FONTDEF);
SendMessage(sub, CB_ADDSTRING, 0, (LPARAM)"Sans serif");
SendMessage(sub, CB_ADDSTRING, 0, (LPARAM)"Serif");
SendMessage(sub, CB_ADDSTRING, 0, (LPARAM)"Monospace");
SendMessage(sub, CB_ADDSTRING, 0, (LPARAM)"Cursive");
SendMessage(sub, CB_ADDSTRING, 0, (LPARAM)"Fantasy");
SendMessage(sub, CB_SETCURSEL,
(WPARAM) (nsoption_int(font_default) - 1), 0);
if ((nsoption_charp(font_sans) != NULL) &&
(nsoption_charp(font_sans)[0] != '\0')) {
sub = GetDlgItem(hwnd, IDC_PREFS_SANS);
SendMessage(sub, WM_SETTEXT, 0,
(LPARAM)nsoption_charp(font_sans));
}
if ((nsoption_charp(font_serif) != NULL) &&
(nsoption_charp(font_serif)[0] != '\0')) {
sub = GetDlgItem(hwnd, IDC_PREFS_SERIF);
SendMessage(sub, WM_SETTEXT, 0,
(LPARAM)nsoption_charp(font_serif));
}
if ((nsoption_charp(font_mono) != NULL) &&
(nsoption_charp(font_mono)[0] != '\0')) {
sub = GetDlgItem(hwnd, IDC_PREFS_MONO);
SendMessage(sub, WM_SETTEXT, 0,
(LPARAM)nsoption_charp(font_mono));
}
if ((nsoption_charp(font_cursive) != NULL) &&
(nsoption_charp(font_cursive)[0] != '\0')) {
sub = GetDlgItem(hwnd, IDC_PREFS_CURSIVE);
SendMessage(sub, WM_SETTEXT, 0,
(LPARAM)nsoption_charp(font_cursive));
}
if ((nsoption_charp(font_fantasy) != NULL) &&
(nsoption_charp(font_fantasy)[0] != '\0')) {
sub = GetDlgItem(hwnd, IDC_PREFS_FANTASY);
SendMessage(sub, WM_SETTEXT, 0,
(LPARAM)nsoption_charp(font_fantasy));
}
if (nsoption_int(font_min_size) != 0) {
sub = GetDlgItem(hwnd, IDC_PREFS_FONT_MINSIZE);
snprintf(number, 6, "%.1f", nsoption_int(font_min_size) / 10.0);
SendMessage(sub, WM_SETTEXT, 0, (LPARAM)number);
}
if (nsoption_int(font_size) != 0) {
sub = GetDlgItem(hwnd, IDC_PREFS_FONT_SIZE);
snprintf(number, 6, "%.1f", nsoption_int(font_size) / 10.0);
SendMessage(sub, WM_SETTEXT, 0, (LPARAM)number);
}
if (nsoption_int(max_fetchers) != 0) {
sub = GetDlgItem(hwnd, IDC_PREFS_FETCHERS);
snprintf(number, 6, "%d", nsoption_int(max_fetchers));
SendMessage(sub, WM_SETTEXT, 0, (LPARAM)number);
}
if (nsoption_int(max_fetchers_per_host) != 0) {
sub = GetDlgItem(hwnd, IDC_PREFS_FETCH_HOST);
snprintf(number, 6, "%d",
nsoption_int(max_fetchers_per_host));
SendMessage(sub, WM_SETTEXT, 0, (LPARAM)number);
}
if (nsoption_int(max_cached_fetch_handles) != 0) {
sub = GetDlgItem(hwnd, IDC_PREFS_FETCH_HANDLES);
snprintf(number, 6, "%d",
nsoption_int(max_cached_fetch_handles));
SendMessage(sub, WM_SETTEXT, 0, (LPARAM)number);
}
/* animation */
sub = GetDlgItem(hwnd, IDC_PREFS_NOANIMATION);
SendMessage(sub, BM_SETCHECK, (WPARAM)((nsoption_bool(animate_images))
? BST_UNCHECKED : BST_CHECKED), 0);
if (nsoption_int(minimum_gif_delay) != 0) {
sub = GetDlgItem(hwnd, IDC_PREFS_ANIMATIONDELAY);
snprintf(number, 6, "%.1f", nsoption_int(minimum_gif_delay) /
100.0);
SendMessage(sub, WM_SETTEXT, 0, (LPARAM)number);
}
break;
case WM_NOTIFY:
switch (((NMHDR FAR *)lParam)->code) {
case PSN_APPLY:
sub = GetDlgItem(hwnd, IDC_PREFS_FONT_SIZE);
len = SendMessage(sub, WM_GETTEXTLENGTH, 0, 0);
temp = malloc(len + 1);
if (temp != NULL) {
SendMessage(sub, WM_GETTEXT, (WPARAM)
(len + 1), (LPARAM) temp);
nsoption_int(font_size) = (int)
(10 * strtod(temp, NULL));
free(temp);
}
sub = GetDlgItem(hwnd, IDC_PREFS_FONT_MINSIZE);
len = SendMessage(sub, WM_GETTEXTLENGTH, 0, 0);
temp = malloc(len + 1);
if (temp != NULL) {
SendMessage(sub, WM_GETTEXT, (WPARAM)
(len + 1), (LPARAM) temp);
nsoption_set_int(font_min_size,
(int)(10 * strtod(temp, NULL)));
free(temp);
}
/* animation */
nsoption_set_bool(animate_images,
(IsDlgButtonChecked(hwnd, IDC_PREFS_NOANIMATION) == BST_CHECKED) ? true : false);
sub = GetDlgItem(hwnd, IDC_PREFS_ANIMATIONDELAY);
len = SendMessage(sub, WM_GETTEXTLENGTH, 0, 0);
temp = malloc(len + 1);
if (temp != NULL) {
SendMessage(sub, WM_GETTEXT, (WPARAM)
(len + 1), (LPARAM) temp);
nsoption_set_int(minimum_gif_delay,
(int)(100 * strtod(temp, NULL)));
free(temp);
}
break;
case UDN_DELTAPOS: {
NMUPDOWN *ud = (NMUPDOWN *)lParam;
switch(((NMHDR *)lParam)->idFrom) {
case IDC_PREFS_FONT_SIZE_SPIN:
change_spinner(GetDlgItem(hwnd, IDC_PREFS_FONT_SIZE), 0.1 * ud->iDelta, 1.0, 50.0);
return TRUE;
case IDC_PREFS_FONT_MINSIZE_SPIN:
change_spinner(GetDlgItem(hwnd, IDC_PREFS_FONT_MINSIZE), 0.1 * ud->iDelta, 1.0, 50.0);
return TRUE;
case IDC_PREFS_ANIMATIONDELAY_SPIN:
change_spinner(GetDlgItem(hwnd, IDC_PREFS_ANIMATIONDELAY), 0.1 * ud->iDelta, 0.1, 100.0);
return TRUE;
}
}
break;
}
case WM_COMMAND:
LOG(("WM_COMMAND Identifier 0x%x",LOWORD(wparam)));
switch(LOWORD(wparam)) {
case IDC_PREFS_PROXYTYPE:
sub = GetDlgItem(hwnd, IDC_PREFS_PROXYTYPE);
nsoption_set_int(http_proxy_auth,
SendMessage(sub, CB_GETCURSEL, 0, 0) - 1);
nsoption_set_bool(http_proxy,
(nsoption_int(http_proxy_auth) != -1));
nsoption_set_int(http_proxy_auth,
nsoption_int(http_proxy_auth) +
(nsoption_bool(http_proxy)) ? 0 : 1);
break;
case IDC_PREFS_SANS: {
CHOOSEFONT *cf = nsws_prefs_font_prepare(FF_SWISS, hwnd);
if (cf == NULL) {
break;
}
if (ChooseFont(cf) == TRUE) {
nsoption_set_charp(font_sans,
strdup(cf->lpLogFont->lfFaceName));
}
free(cf->lpLogFont);
free(cf);
if ((nsoption_charp(font_sans) != NULL) &&
(nsoption_charp(font_sans)[0] != '\0')) {
sub = GetDlgItem(hwnd, IDC_PREFS_SANS);
SendMessage(sub, WM_SETTEXT, 0,
(LPARAM)nsoption_charp(font_sans));
}
break;
}
case IDC_PREFS_SERIF: {
CHOOSEFONT *cf = nsws_prefs_font_prepare(FF_ROMAN, hwnd);
if (cf == NULL) {
break;
}
if (ChooseFont(cf) == TRUE) {
nsoption_set_charp(font_serif,
strdup(cf->lpLogFont->lfFaceName));
}
free(cf->lpLogFont);
free(cf);
if ((nsoption_charp(font_serif) != NULL) &&
(nsoption_charp(font_serif)[0] != '\0')) {
sub = GetDlgItem(hwnd, IDC_PREFS_SERIF);
SendMessage(sub, WM_SETTEXT, 0,
(LPARAM)nsoption_charp(font_serif));
}
break;
}
case IDC_PREFS_MONO: {
CHOOSEFONT *cf = nsws_prefs_font_prepare(FF_MODERN, hwnd);
if (cf == NULL) {
break;
}
if (ChooseFont(cf) == TRUE) {
nsoption_set_charp(font_mono,
strdup(cf->lpLogFont->lfFaceName));
}
free(cf->lpLogFont);
free(cf);
if ((nsoption_charp(font_mono) != NULL) &&
(nsoption_charp(font_mono)[0] != '\0')) {
sub = GetDlgItem(hwnd, IDC_PREFS_MONO);
SendMessage(sub, WM_SETTEXT, 0,
(LPARAM)nsoption_charp(font_mono));
}
break;
}
case IDC_PREFS_CURSIVE: {
CHOOSEFONT *cf = nsws_prefs_font_prepare(FF_SCRIPT, hwnd);
if (cf == NULL) {
break;
}
if (ChooseFont(cf) == TRUE) {
nsoption_set_charp(font_cursive,
strdup(cf->lpLogFont->lfFaceName));
}
free(cf->lpLogFont);
free(cf);
if ((nsoption_charp(font_cursive) != NULL) &&
(nsoption_charp(font_cursive)[0] != '\0')) {
sub = GetDlgItem(hwnd, IDC_PREFS_CURSIVE);
SendMessage(sub, WM_SETTEXT, 0,
(LPARAM)nsoption_charp(font_cursive));
}
break;
}
case IDC_PREFS_FANTASY: {
CHOOSEFONT *cf = nsws_prefs_font_prepare(FF_DECORATIVE, hwnd);
if (cf == NULL) {
break;
}
if (ChooseFont(cf) == TRUE) {
nsoption_set_charp(font_fantasy,
strdup(cf->lpLogFont->lfFaceName));
}
free(cf->lpLogFont);
free(cf);
if ((nsoption_charp(font_fantasy) != NULL) &&
(nsoption_charp(font_fantasy)[0] != '\0')) {
sub = GetDlgItem(hwnd, IDC_PREFS_FANTASY);
SendMessage(sub, WM_SETTEXT, 0,
(LPARAM)nsoption_charp(font_fantasy));
}
break;
}
case IDC_PREFS_FONTDEF:
sub = GetDlgItem(hwnd, IDC_PREFS_FONTDEF);
nsoption_set_int(font_default,
SendMessage(sub, CB_GETCURSEL, 0, 0) + 1);
break;
}
break;
}
return FALSE;
}
static int ParseSizeString(const char *size, double *res)
{
#define MAX_SUBSTRINGS 30
int pcre_exec_ret;
int r;
int ov[MAX_SUBSTRINGS];
int retval = 0;
char str[128];
char str2[128];
*res = 0;
pcre_exec_ret = pcre_exec(parse_regex, parse_regex_study, size, strlen(size), 0, 0,
ov, MAX_SUBSTRINGS);
if (!(pcre_exec_ret == 2 || pcre_exec_ret == 3)) {
SCLogError(SC_ERR_PCRE_MATCH, "invalid size argument - %s. Valid size "
"argument should be in the format - \n"
"xxx <- indicates it is just bytes\n"
"xxxkb or xxxKb or xxxKB or xxxkB <- indicates kilobytes\n"
"xxxmb or xxxMb or xxxMB or xxxmB <- indicates megabytes\n"
"xxxgb or xxxGb or xxxGB or xxxgB <- indicates gigabytes.\n",
size);
retval = -2;
goto end;
}
r = pcre_copy_substring((char *)size, ov, MAX_SUBSTRINGS, 1,
str, sizeof(str));
if (r < 0) {
SCLogError(SC_ERR_PCRE_GET_SUBSTRING, "pcre_copy_substring failed");
retval = -2;
goto end;
}
char *endptr, *str_ptr = str;
errno = 0;
*res = strtod(str_ptr, &endptr);
if (errno == ERANGE) {
SCLogError(SC_ERR_NUMERIC_VALUE_ERANGE, "Numeric value out of range");
retval = -1;
goto end;
} else if (endptr == str_ptr) {
SCLogError(SC_ERR_INVALID_NUMERIC_VALUE, "Invalid numeric value");
retval = -1;
goto end;
}
if (pcre_exec_ret == 3) {
r = pcre_copy_substring((char *)size, ov, MAX_SUBSTRINGS, 2,
str2, sizeof(str2));
if (r < 0) {
SCLogError(SC_ERR_PCRE_GET_SUBSTRING, "pcre_copy_substring failed");
retval = -2;
goto end;
}
if (strcasecmp(str2, "kb") == 0) {
*res *= 1024;
} else if (strcasecmp(str2, "mb") == 0) {
*res *= 1024 * 1024;
} else if (strcasecmp(str2, "gb") == 0) {
*res *= 1024 * 1024 * 1024;
} else {
/* not possible */
BUG_ON(1);
}
}
retval = 0;
end:
return retval;
}
int main( int argc , char *argv[] )
{
double val , p , p1=0.0,p2=0.0,p3=0.0 ;
double vbot,vtop,vdel ;
int code , iarg=1 , doq=0 , dod=0 , doi=0 , doz=0 , doh=0 ;
/*-- print some help for the pitiful user --*/
if( argc < 3 || strstr(argv[1],"help") != NULL ){
int ii ;
printf("\n") ;
printf("Demo program for computing NIfTI statistical functions.\n") ;
printf("Usage: nifti_stats [-q|-d|-1|-z] val CODE [p1 p2 p3]\n") ;
printf(" val can be a single number or in the form bot:top:step.\n") ;
printf(" default ==> output p = Prob(statistic < val).\n") ;
printf(" -q ==> output is 1-p.\n") ;
printf(" -d ==> output is density.\n") ;
printf(" -1 ==> output is x such that Prob(statistic < x) = val.\n") ;
printf(" -z ==> output is z such that Normal cdf(z) = p(val).\n") ;
printf(" -h ==> output is z such that 1/2-Normal cdf(z) = p(val).\n");
printf(" Allowable CODEs:\n") ;
for( ii=NIFTI_FIRST_STATCODE ; ii <= NIFTI_LAST_STATCODE ; ii++ ){
printf(" %-10s",inam[ii]); if((ii-NIFTI_FIRST_STATCODE)%6==5)printf("\n");
}
printf("\n") ;
printf(" Following CODE are distributional parameters, as needed.\n");
printf("\n") ;
printf("Results are written to stdout, 1 number per output line.\n") ;
printf("Example (piping output into AFNI program 1dplot):\n") ;
printf(" nifti_stats -d 0:4:.001 INVGAUSS 1 3 | 1dplot -dx 0.001 -stdin\n");
printf("\n") ;
printf("Author - RW Cox - SSCC/NIMH/NIH/DHHS/USA/EARTH - March 2004\n") ;
printf("\n") ;
exit(0) ;
}
/*-- check first arg to see if it is an output option;
if so, set the appropriate output flag to determine what to compute --*/
if( strcmp(argv[iarg],"-q") == 0 ){ doq = 1 ; iarg++ ; }
else if( strcmp(argv[iarg],"-d") == 0 ){ dod = 1 ; iarg++ ; }
else if( strcmp(argv[iarg],"-1") == 0 ){ doi = 1 ; iarg++ ; }
else if( strcmp(argv[iarg],"-z") == 0 ){ doz = 1 ; iarg++ ; }
else if( strcmp(argv[iarg],"-h") == 0 ){ doh = 1 ; iarg++ ; }
/*-- get the value(s) to process --*/
vbot=vtop=vdel = 0.0 ;
sscanf( argv[iarg++] , "%lf:%lf:%lf" , &vbot,&vtop,&vdel ) ;
if( vbot >= vtop ) vdel = 0.0 ;
if( vdel <= 0.0 ) vtop = vbot ;
/*-- decode the CODE into the integer signifying the distribution --*/
code = nifti_intent_code(argv[iarg++]) ;
if( code < 0 ){ fprintf(stderr,"illegal code=%s\n",argv[iarg-1]); exit(1); }
/*-- get the parameters, if present (defaults are 0) --*/
if( argc > iarg ) p1 = strtod(argv[iarg++],NULL) ;
if( argc > iarg ) p2 = strtod(argv[iarg++],NULL) ;
if( argc > iarg ) p3 = strtod(argv[iarg++],NULL) ;
/*-- loop over input value(s), compute output, write to stdout --*/
for( val=vbot ; val <= vtop ; val += vdel ){
if( doq ) /* output = 1-cdf */
p = nifti_stat2rcdf( val , code,p1,p2,p3 ) ;
else if( dod ) /* output = density */
p = 1000.0*( nifti_stat2cdf(val+.001,code,p1,p2,p3)
-nifti_stat2cdf(val ,code,p1,p2,p3)) ;
else if( doi ) /* output = inverse */
p = nifti_cdf2stat( val , code,p1,p2,p3 ) ;
else if( doz ) /* output = z score */
p = nifti_stat2zscore( val , code,p1,p2,p3 ) ;
else if( doh ) /* output = halfz score */
p = nifti_stat2hzscore( val , code,p1,p2,p3 ) ;
else /* output = cdf */
p = nifti_stat2cdf( val , code,p1,p2,p3 ) ;
printf("%.9g\n",p) ;
if( vdel <= 0.0 ) break ; /* the case of just 1 value */
}
/*-- terminus est --*/
exit(0) ;
}
void read_problem(const char *filename)
{
int elements, max_index, inst_max_index, i, j;
FILE *fp = fopen(filename,"r");
char *endptr;
char *idx, *val, *label;
if(fp == NULL)
{
fprintf(stderr,"can't open input file %s\n",filename);
exit(1);
}
prob.l = 0;
elements = 0;
max_line_len = 1024;
line = Malloc(char,max_line_len);
while(readline(fp)!=NULL)
{
char *p = strtok(line," \t"); // label
// features
while(1)
{
p = strtok(NULL," \t");
if(p == NULL || *p == '\n') // check '\n' as ' ' may be after the last feature
break;
++elements;
}
++elements;
++prob.l;
}
rewind(fp);
prob.y = Malloc(double,prob.l);
prob.x = Malloc(struct svm_node *,prob.l);
x_space = Malloc(struct svm_node,elements);
max_index = 0;
j=0;
for(i=0;i<prob.l;i++)
{
inst_max_index = -1; // strtol gives 0 if wrong format, and precomputed kernel has <index> start from 0
readline(fp);
prob.x[i] = &x_space[j];
label = strtok(line," \t\n");
if(label == NULL) // empty line
exit_input_error(i+1);
prob.y[i] = strtod(label,&endptr);
if(endptr == label || *endptr != '\0')
exit_input_error(i+1);
while(1)
{
idx = strtok(NULL,":");
val = strtok(NULL," \t");
if(val == NULL)
break;
errno = 0;
x_space[j].index = (int) strtol(idx,&endptr,10);
if(endptr == idx || errno != 0 || *endptr != '\0' || x_space[j].index <= inst_max_index)
exit_input_error(i+1);
else
inst_max_index = x_space[j].index;
errno = 0;
x_space[j].value = strtod(val,&endptr);
if(endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr)))
exit_input_error(i+1);
++j;
}
if(inst_max_index > max_index)
max_index = inst_max_index;
x_space[j++].index = -1;
}
if(param.gamma == 0 && max_index > 0)
param.gamma = 1.0/max_index;
if(param.kernel_type == PRECOMPUTED)
for(i=0;i<prob.l;i++)
{
if (prob.x[i][0].index != 0)
{
fprintf(stderr,"Wrong input format: first column must be 0:sample_serial_number\n");
exit(1);
}
if ((int)prob.x[i][0].value <= 0 || (int)prob.x[i][0].value > max_index)
{
fprintf(stderr,"Wrong input format: sample_serial_number out of range\n");
exit(1);
}
}
fclose(fp);
}
int gmx_wheel(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] plots a helical wheel representation of your sequence.",
"The input sequence is in the [REF].dat[ref] file where the first line contains",
"the number of residues and each consecutive line contains a residue "
"name."
};
output_env_t oenv;
static real rot0 = 0;
static gmx_bool bNum = TRUE;
static char *title = NULL;
static int r0 = 1;
t_pargs pa [] = {
{ "-r0", FALSE, etINT, {&r0},
"The first residue number in the sequence" },
{ "-rot0", FALSE, etREAL, {&rot0},
"Rotate around an angle initially (90 degrees makes sense)" },
{ "-T", FALSE, etSTR, {&title},
"Plot a title in the center of the wheel (must be shorter than 10 characters, or it will overwrite the wheel)" },
{ "-nn", FALSE, etBOOL, {&bNum},
"Toggle numbers" }
};
t_filenm fnm[] = {
{ efDAT, "-f", NULL, ffREAD },
{ efEPS, "-o", NULL, ffWRITE }
};
#define NFILE asize(fnm)
int i, nres;
char **resnm;
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
for (i = 1; (i < argc); i++)
{
if (std::strcmp(argv[i], "-r0") == 0)
{
r0 = std::strtol(argv[++i], NULL, 10);
fprintf(stderr, "First residue is %d\n", r0);
}
else if (std::strcmp(argv[i], "-rot0") == 0)
{
rot0 = strtod(argv[++i], NULL);
fprintf(stderr, "Initial rotation is %g\n", rot0);
}
else if (std::strcmp(argv[i], "-T") == 0)
{
title = gmx_strdup(argv[++i]);
fprintf(stderr, "Title will be '%s'\n", title);
}
else if (std::strcmp(argv[i], "-nn") == 0)
{
bNum = FALSE;
fprintf(stderr, "No residue numbers\n");
}
else
{
gmx_fatal(FARGS, "Incorrect usage of option %s", argv[i]);
}
}
nres = get_lines(ftp2fn(efDAT, NFILE, fnm), &resnm);
if (bNum)
{
wheel(ftp2fn(efEPS, NFILE, fnm), nres, resnm, r0, rot0, title);
}
else
{
wheel2(ftp2fn(efEPS, NFILE, fnm), nres, resnm, rot0, title);
}
return 0;
}
double QDecSingle::toDouble() const
{
char str[MaxStrSize] = {0};
decSingleToString(&m_data, str);
return strtod(str, 0);
}
static void /* file processing function */
process(FILE *fid) {
char line[MAXLINE+3], *s;
for (;;) {
++emess_dat.File_line;
if (!(s = fgets(line, MAXLINE, fid)))
break;
if (!strchr(s, '\n')) { /* overlong line */
int c;
strcat(s, "\n");
/* gobble up to newline */
while ((c = fgetc(fid)) != EOF && c != '\n') ;
}
if (*s == tag) {
fputs(line, stdout);
continue;
}
phi1 = dmstor(s, &s);
lam1 = dmstor(s, &s);
if (inverse) {
phi2 = dmstor(s, &s);
lam2 = dmstor(s, &s);
geod_inv();
} else {
al12 = dmstor(s, &s);
geod_S = strtod(s, &s) * to_meter;
geod_pre();
geod_for();
}
if (!*s && (s > line)) --s; /* assumed we gobbled \n */
if (pos_azi) {
if (al12 < 0.) al12 += M_TWOPI;
if (al21 < 0.) al21 += M_TWOPI;
}
if (fullout) {
printLL(phi1, lam1); TAB;
printLL(phi2, lam2); TAB;
if (oform) {
(void)printf(oform, al12 * RAD_TO_DEG); TAB;
(void)printf(oform, al21 * RAD_TO_DEG); TAB;
(void)printf(osform, geod_S * fr_meter);
} else {
(void)fputs(rtodms(pline, al12, 0, 0), stdout); TAB;
(void)fputs(rtodms(pline, al21, 0, 0), stdout); TAB;
(void)printf(osform, geod_S * fr_meter);
}
} else if (inverse)
if (oform) {
(void)printf(oform, al12 * RAD_TO_DEG); TAB;
(void)printf(oform, al21 * RAD_TO_DEG); TAB;
(void)printf(osform, geod_S * fr_meter);
} else {
(void)fputs(rtodms(pline, al12, 0, 0), stdout); TAB;
(void)fputs(rtodms(pline, al21, 0, 0), stdout); TAB;
(void)printf(osform, geod_S * fr_meter);
}
else {
printLL(phi2, lam2); TAB;
if (oform)
(void)printf(oform, al21 * RAD_TO_DEG);
else
(void)fputs(rtodms(pline, al21, 0, 0), stdout);
}
(void)fputs(s, stdout);
}
}
void log_sample(int sample, struct list_sample_data **ptr) {
static int vmstat;
static int schedstat;
char buf[4096];
char key[256];
char val[256];
char rt[256];
char wt[256];
char *m;
int c;
int p;
int mod;
static int e_fd;
ssize_t s;
ssize_t n;
struct dirent *ent;
int fd;
struct list_sample_data *sampledata;
struct ps_sched_struct *ps_prev = NULL;
sampledata = *ptr;
/* all the per-process stuff goes here */
if (!proc) {
/* find all processes */
proc = opendir("/proc");
if (!proc)
return;
procfd = dirfd(proc);
} else {
rewinddir(proc);
}
if (!vmstat) {
/* block stuff */
vmstat = openat(procfd, "vmstat", O_RDONLY);
if (vmstat == -1) {
perror("open /proc/vmstat");
exit (EXIT_FAILURE);
}
}
n = pread(vmstat, buf, sizeof(buf) - 1, 0);
if (n <= 0) {
close(vmstat);
return;
}
buf[n] = '\0';
m = buf;
while (m) {
if (sscanf(m, "%s %s", key, val) < 2)
goto vmstat_next;
if (streq(key, "pgpgin"))
sampledata->blockstat.bi = atoi(val);
if (streq(key, "pgpgout")) {
sampledata->blockstat.bo = atoi(val);
break;
}
vmstat_next:
m = bufgetline(m);
if (!m)
break;
}
if (!schedstat) {
/* overall CPU utilization */
schedstat = openat(procfd, "schedstat", O_RDONLY);
if (schedstat == -1) {
perror("open /proc/schedstat");
exit (EXIT_FAILURE);
}
}
n = pread(schedstat, buf, sizeof(buf) - 1, 0);
if (n <= 0) {
close(schedstat);
return;
}
buf[n] = '\0';
m = buf;
while (m) {
if (sscanf(m, "%s %*s %*s %*s %*s %*s %*s %s %s", key, rt, wt) < 3)
goto schedstat_next;
if (strstr(key, "cpu")) {
c = atoi((const char*)(key+3));
if (c > MAXCPUS)
/* Oops, we only have room for MAXCPUS data */
break;
sampledata->runtime[c] = atoll(rt);
sampledata->waittime[c] = atoll(wt);
if (c == cpus)
cpus = c + 1;
}
schedstat_next:
m = bufgetline(m);
if (!m)
break;
}
if (arg_entropy) {
if (!e_fd) {
e_fd = openat(procfd, "sys/kernel/random/entropy_avail", O_RDONLY);
}
if (e_fd) {
n = pread(e_fd, buf, sizeof(buf) - 1, 0);
if (n > 0) {
buf[n] = '\0';
sampledata->entropy_avail = atoi(buf);
}
}
}
while ((ent = readdir(proc)) != NULL) {
char filename[PATH_MAX];
int pid;
struct ps_struct *ps;
if ((ent->d_name[0] < '0') || (ent->d_name[0] > '9'))
continue;
pid = atoi(ent->d_name);
if (pid >= MAXPIDS)
continue;
ps = ps_first;
while (ps->next_ps) {
ps = ps->next_ps;
if (ps->pid == pid)
break;
}
/* end of our LL? then append a new record */
if (ps->pid != pid) {
_cleanup_fclose_ FILE *st = NULL;
char t[32];
struct ps_struct *parent;
ps->next_ps = calloc(1, sizeof(struct ps_struct));
if (!ps->next_ps) {
perror("calloc(ps_struct)");
exit (EXIT_FAILURE);
}
ps = ps->next_ps;
ps->pid = pid;
ps->sample = calloc(1, sizeof(struct ps_sched_struct));
if (!ps->sample) {
perror("calloc(ps_struct)");
exit (EXIT_FAILURE);
}
ps->sample->sampledata = sampledata;
pscount++;
/* mark our first sample */
ps->first = ps->sample;
ps->sample->runtime = atoll(rt);
ps->sample->waittime = atoll(wt);
/* get name, start time */
if (!ps->sched) {
sprintf(filename, "%d/sched", pid);
ps->sched = openat(procfd, filename, O_RDONLY);
if (ps->sched == -1)
continue;
}
s = pread(ps->sched, buf, sizeof(buf) - 1, 0);
if (s <= 0) {
close(ps->sched);
continue;
}
buf[s] = '\0';
if (!sscanf(buf, "%s %*s %*s", key))
continue;
strscpy(ps->name, sizeof(ps->name), key);
/* cmdline */
if (arg_show_cmdline)
pid_cmdline_strscpy(ps->name, sizeof(ps->name), pid);
/* discard line 2 */
m = bufgetline(buf);
if (!m)
continue;
m = bufgetline(m);
if (!m)
continue;
if (!sscanf(m, "%*s %*s %s", t))
continue;
ps->starttime = strtod(t, NULL) / 1000.0;
/* ppid */
sprintf(filename, "%d/stat", pid);
fd = openat(procfd, filename, O_RDONLY);
st = fdopen(fd, "r");
if (!st)
continue;
if (!fscanf(st, "%*s %*s %*s %i", &p)) {
continue;
}
ps->ppid = p;
/*
* setup child pointers
*
* these are used to paint the tree coherently later
* each parent has a LL of children, and a LL of siblings
*/
if (pid == 1)
continue; /* nothing to do for init atm */
/* kthreadd has ppid=0, which breaks our tree ordering */
if (ps->ppid == 0)
ps->ppid = 1;
parent = ps_first;
while ((parent->next_ps && parent->pid != ps->ppid))
parent = parent->next_ps;
if ((!parent) || (parent->pid != ps->ppid)) {
/* orphan */
ps->ppid = 1;
parent = ps_first->next_ps;
}
ps->parent = parent;
if (!parent->children) {
/* it's the first child */
parent->children = ps;
} else {
/* walk all children and append */
struct ps_struct *children;
children = parent->children;
while (children->next)
children = children->next;
children->next = ps;
}
}
/* else -> found pid, append data in ps */
/* below here is all continuous logging parts - we get here on every
* iteration */
/* rt, wt */
if (!ps->schedstat) {
sprintf(filename, "%d/schedstat", pid);
ps->schedstat = openat(procfd, filename, O_RDONLY);
if (ps->schedstat == -1)
continue;
}
s = pread(ps->schedstat, buf, sizeof(buf) - 1, 0);
if (s <= 0) {
/* clean up our file descriptors - assume that the process exited */
close(ps->schedstat);
if (ps->sched)
close(ps->sched);
//if (ps->smaps)
// fclose(ps->smaps);
continue;
}
buf[s] = '\0';
if (!sscanf(buf, "%s %s %*s", rt, wt))
continue;
ps->sample->next = calloc(1, sizeof(struct ps_sched_struct));
if (!ps->sample) {
perror("calloc(ps_struct)");
exit (EXIT_FAILURE);
}
ps->sample->next->prev = ps->sample;
ps->sample = ps->sample->next;
ps->last = ps->sample;
ps->sample->runtime = atoll(rt);
ps->sample->waittime = atoll(wt);
ps->sample->sampledata = sampledata;
ps->sample->ps_new = ps;
if (ps_prev) {
ps_prev->cross = ps->sample;
}
ps_prev = ps->sample;
ps->total = (ps->last->runtime - ps->first->runtime)
/ 1000000000.0;
if (!arg_pss)
goto catch_rename;
/* Pss */
if (!ps->smaps) {
sprintf(filename, "%d/smaps", pid);
fd = openat(procfd, filename, O_RDONLY);
ps->smaps = fdopen(fd, "r");
if (!ps->smaps)
continue;
setvbuf(ps->smaps, smaps_buf, _IOFBF, sizeof(smaps_buf));
}
else {
rewind(ps->smaps);
}
/* test to see if we need to skip another field */
if (skip == 0) {
if (fgets(buf, sizeof(buf), ps->smaps) == NULL) {
continue;
}
if (fread(buf, 1, 28 * 15, ps->smaps) != (28 * 15)) {
continue;
}
if (buf[392] == 'V') {
skip = 2;
}
else {
skip = 1;
}
rewind(ps->smaps);
}
while (1) {
int pss_kb;
/* skip one line, this contains the object mapped. */
if (fgets(buf, sizeof(buf), ps->smaps) == NULL) {
break;
}
/* then there's a 28 char 14 line block */
if (fread(buf, 1, 28 * 14, ps->smaps) != 28 * 14) {
break;
}
pss_kb = atoi(&buf[61]);
ps->sample->pss += pss_kb;
/* skip one more line if this is a newer kernel */
if (skip == 2) {
if (fgets(buf, sizeof(buf), ps->smaps) == NULL)
break;
}
}
if (ps->sample->pss > ps->pss_max)
ps->pss_max = ps->sample->pss;
catch_rename:
/* catch process rename, try to randomize time */
mod = (arg_hz < 4.0) ? 4.0 : (arg_hz / 4.0);
if (((samples - ps->pid) + pid) % (int)(mod) == 0) {
/* re-fetch name */
/* get name, start time */
if (!ps->sched) {
sprintf(filename, "%d/sched", pid);
ps->sched = openat(procfd, filename, O_RDONLY);
if (ps->sched == -1)
continue;
}
s = pread(ps->sched, buf, sizeof(buf) - 1, 0);
if (s <= 0) {
/* clean up file descriptors */
close(ps->sched);
if (ps->schedstat)
close(ps->schedstat);
//if (ps->smaps)
// fclose(ps->smaps);
continue;
}
buf[s] = '\0';
if (!sscanf(buf, "%s %*s %*s", key))
continue;
strscpy(ps->name, sizeof(ps->name), key);
/* cmdline */
if (arg_show_cmdline)
pid_cmdline_strscpy(ps->name, sizeof(ps->name), pid);
}
}
}
static int
startElement_METRICS(void *data, const char *el, const char **attr)
{
xmldata_t *xmldata = (xmldata_t *)data;
struct xml_tag *xt;
struct type_tag *tt;
datum_t *hash_datum = NULL;
datum_t *rdatum;
datum_t hashkey, hashval;
const char *name = NULL;
const char *metricval = NULL;
const char *metricnum = NULL;
const char *type = NULL;
int i;
hash_t *summary;
Metric_t *metric;
/* In non-scalable mode, we do not process summary data. */
if (!gmetad_config.scalable_mode) return 0;
/* Get name for hash key, and val/type for summaries. */
for(i = 0; attr[i]; i+=2)
{
xt = in_xml_list(attr[i], strlen(attr[i]));
if (!xt) continue;
switch (xt->tag)
{
case NAME_TAG:
name = attr[i+1];
hashkey.data = (void*) name;
hashkey.size = strlen(name) + 1;
break;
case TYPE_TAG:
type = attr[i+1];
break;
case SUM_TAG:
metricval = attr[i+1];
break;
case NUM_TAG:
metricnum = attr[i+1];
default:
break;
}
}
summary = xmldata->source.metric_summary;
hash_datum = hash_lookup(&hashkey, summary);
if (!hash_datum)
{
metric = &(xmldata->metric);
memset((void*) metric, 0, sizeof(*metric));
fillmetric(attr, metric, type);
}
else
{
memcpy(&xmldata->metric, hash_datum->data, hash_datum->size);
datum_free(hash_datum);
metric = &(xmldata->metric);
tt = in_type_list(type, strlen(type));
if (!tt) return 0;
switch (tt->type)
{
case INT:
case UINT:
case FLOAT:
metric->val.d += (double)
strtod(metricval, (char**) NULL);
break;
default:
break;
}
metric->num += atoi(metricnum);
}
/* Update metric in summary table. */
hashval.size = sizeof(*metric) - GMETAD_FRAMESIZE + metric->stringslen;
hashval.data = (void*) metric;
summary = xmldata->source.metric_summary;
rdatum = hash_insert(&hashkey, &hashval, summary);
if (!rdatum) {
err_msg("Could not insert %s metric", name);
return 1;
}
return 0;
}
/* Populates a Metric_t structure from a list of XML metric attribute strings.
* We need the type string here because we cannot be sure it comes before
* the metric value in the attribute list.
*/
static void
fillmetric(const char** attr, Metric_t *metric, const char* type)
{
int i;
/* INV: always points to the next free byte in metric.strings buffer. */
int edge = 0;
struct type_tag *tt;
struct xml_tag *xt;
char *metricval, *p;
/* For old versions of gmond. */
metric->slope = -1;
for(i = 0; attr[i] ; i+=2)
{
/* Only process the XML tags that gmetad is interested in */
xt = in_xml_list (attr[i], strlen(attr[i]));
if (!xt)
continue;
switch( xt->tag )
{
case SUM_TAG:
case VAL_TAG:
metricval = (char*) attr[i+1];
tt = in_type_list(type, strlen(type));
if (!tt) return;
switch (tt->type)
{
case INT:
case TIMESTAMP:
case UINT:
case FLOAT:
metric->val.d = (double)
strtod(metricval, (char**) NULL);
p = strrchr(metricval, '.');
if (p) metric->precision = (short int) strlen(p+1);
break;
case STRING:
/* We store string values in the 'valstr' field. */
break;
}
metric->valstr = addstring(metric->strings, &edge, metricval);
break;
case TYPE_TAG:
metric->type = addstring(metric->strings, &edge, attr[i+1]);
break;
case UNITS_TAG:
metric->units = addstring(metric->strings, &edge, attr[i+1]);
break;
case TN_TAG:
metric->tn = atoi(attr[i+1]);
break;
case TMAX_TAG:
metric->tmax = atoi(attr[i+1]);
break;
case DMAX_TAG:
metric->dmax = atoi(attr[i+1]);
break;
case SLOPE_TAG:
metric->slope = addstring(metric->strings, &edge, attr[i+1]);
break;
case SOURCE_TAG:
metric->source = addstring(metric->strings, &edge, attr[i+1]);
break;
case NUM_TAG:
metric->num = atoi(attr[i+1]);
break;
default:
break;
}
}
metric->stringslen = edge;
/* We are ok with growing metric values b/c we write to a full-sized
* buffer in xmldata. */
}
static int
startElement_METRIC(void *data, const char *el, const char **attr)
{
xmldata_t *xmldata = (xmldata_t *)data;
ganglia_slope_t slope = GANGLIA_SLOPE_UNSPECIFIED;
struct xml_tag *xt;
struct type_tag *tt;
datum_t *hash_datum = NULL;
datum_t *rdatum;
datum_t hashkey, hashval;
const char *name = NULL;
const char *metricval = NULL;
const char *type = NULL;
int do_summary;
int i, edge, carbon_ret;
hash_t *summary;
Metric_t *metric;
if (!xmldata->host_alive ) return 0;
/* Get name for hash key, and val/type for summaries. */
for(i = 0; attr[i]; i+=2)
{
xt = in_xml_list(attr[i], strlen(attr[i]));
if (!xt) continue;
switch (xt->tag)
{
case NAME_TAG:
name = attr[i+1];
hashkey.data = (void*) name;
hashkey.size = strlen(name) + 1;
break;
case VAL_TAG:
metricval = attr[i+1];
break;
case TYPE_TAG:
type = attr[i+1];
break;
case SLOPE_TAG:
slope = cstr_to_slope(attr[i+1]);
default:
break;
}
}
metric = &(xmldata->metric);
memset((void*) metric, 0, sizeof(*metric));
/* Summarize all numeric metrics */
do_summary = 0;
tt = in_type_list(type, strlen(type));
if (!tt) return 0;
if (tt->type==INT || tt->type==UINT || tt->type==FLOAT)
do_summary = 1;
/* Only keep metric details if we are the authority on this cluster. */
if (authority_mode(xmldata))
{
/* Save the data to a round robin database if the data source is alive
*/
fillmetric(attr, metric, type);
if (metric->dmax && metric->tn > metric->dmax)
return 0;
if (do_summary && !xmldata->ds->dead && !xmldata->rval)
{
debug_msg("Updating host %s, metric %s",
xmldata->hostname, name);
if ( gmetad_config.write_rrds == 1 )
xmldata->rval = write_data_to_rrd(xmldata->sourcename,
xmldata->hostname, name, metricval, NULL,
xmldata->ds->step, xmldata->source.localtime, slope);
if (gmetad_config.carbon_server) // if the user has specified a carbon server, send the metric to carbon as well
carbon_ret=write_data_to_carbon(xmldata->sourcename, xmldata->hostname, name, metricval,xmldata->source.localtime);
}
metric->id = METRIC_NODE;
metric->report_start = metric_report_start;
metric->report_end = metric_report_end;
edge = metric->stringslen;
metric->name = addstring(metric->strings, &edge, name);
metric->stringslen = edge;
/* Set local idea of T0. */
metric->t0 = xmldata->now;
metric->t0.tv_sec -= metric->tn;
/* Trim metric structure to the correct length. */
hashval.size = sizeof(*metric) - GMETAD_FRAMESIZE + metric->stringslen;
hashval.data = (void*) metric;
/* Update full metric in cluster host table. */
rdatum = hash_insert(&hashkey, &hashval, xmldata->host.metrics);
if (!rdatum)
{
err_msg("Could not insert %s metric", name);
}
}
/* Always update summary for numeric metrics. */
if (do_summary)
{
summary = xmldata->source.metric_summary;
hash_datum = hash_lookup(&hashkey, summary);
if (!hash_datum)
{
if (!authority_mode(xmldata))
{
metric = &(xmldata->metric);
memset((void*) metric, 0, sizeof(*metric));
fillmetric(attr, metric, type);
}
/* else we have already filled in the metric above. */
}
else
{
memcpy(&xmldata->metric, hash_datum->data, hash_datum->size);
datum_free(hash_datum);
metric = &(xmldata->metric);
switch (tt->type)
{
case INT:
case UINT:
case FLOAT:
metric->val.d += (double)
strtod(metricval, (char**) NULL);
break;
default:
break;
}
}
metric->num++;
metric->t0 = xmldata->now; /* tell cleanup thread we are using this */
/* Trim metric structure to the correct length. Tricky. */
hashval.size = sizeof(*metric) - GMETAD_FRAMESIZE + metric->stringslen;
hashval.data = (void*) metric;
/* Update metric in summary table. */
rdatum = hash_insert(&hashkey, &hashval, summary);
if (!rdatum) err_msg("Could not insert %s metric", name);
}
return 0;
}
accept_languages * parse_accept_languages(char * acceptlang) {
char * langdup; /* Duplicate of accept language for parsing */
accept_languages *langs = NULL;
char * langtok; /* Language token (language + locality + q value) */
char * saveptr; /* Save state of tokenization */
char * qdelim; /* location of the delimiter ';q=' */
char * localitydelim; /* Delimiter for locality specifier */
int x;
char * stp;
/* If the browser did not pass an HTTP_ACCEPT_LANGUAGE variable, there
is not much we can do */
if(NULL == acceptlang) {
return NULL;
}
/* Duplicate the browser supplied HTTP_ACCEPT_LANGUAGE variable */
if(NULL == (langdup = strdup(acceptlang))) {
printf("Unable to allocate memory for langdup\n");
return NULL;
}
/* Initialize the structure to contain the parsed HTTP_ACCEPT_LANGUAGE
information */
if(NULL == (langs = malloc(sizeof(accept_languages)))) {
printf("Unable to allocate memory for langs\n");
free(langdup);
return NULL;
}
langs->count = 0;
langs->languages = (accept_language **)NULL;
/* Tokenize the HTTP_ACCEPT_LANGUAGE string */
langtok = strtok_r(langdup, ",", &saveptr);
while(langtok != NULL) {
/* Bump the count and allocate memory for structures */
langs->count++;
if(NULL == langs->languages) {
/* Adding first language */
if(NULL == (langs->languages =
malloc(langs->count * sizeof(accept_language *)))) {
printf("Unable to allocate memory for first language\n");
langs->count--;
free_accept_languages(langs);
free(langdup);
return NULL;
}
}
else {
/* Adding additional language */
if(NULL == (langs->languages = realloc(langs->languages,
langs->count * sizeof(accept_language *)))) {
printf("Unable to allocate memory for additional language\n");
langs->count--;
free_accept_languages(langs);
free(langdup);
return NULL;
}
}
if(NULL == (langs->languages[ langs->count - 1] =
malloc(sizeof(accept_language)))) {
printf("Unable to allocate memory for language\n");
langs->count--;
free_accept_languages(langs);
free(langdup);
return NULL;
}
langs->languages[ langs->count - 1]->language = (char *)NULL;
langs->languages[ langs->count - 1]->locality = (char *)NULL;
langs->languages[ langs->count - 1]->q = 1.0;
/* Check to see if there is a q value */
qdelim = strstr(langtok, ACCEPT_LANGUAGE_Q_DELIMITER);
if(NULL != qdelim) { /* found a q value */
langs->languages[ langs->count - 1]->q =
strtod(qdelim + strlen(ACCEPT_LANGUAGE_Q_DELIMITER), NULL);
langtok[ qdelim - langtok] = '\0';
}
/* Check to see if there is a locality specifier */
if(NULL == (localitydelim = strchr(langtok, '-'))) {
localitydelim = strchr(langtok, '_');
}
if(NULL != localitydelim) {
/* We have a locality delimiter, so copy it */
if(NULL == (langs->languages[ langs->count - 1]->locality =
strdup(localitydelim + 1))) {
printf("Unable to allocate memory for locality '%s'\n",
langtok);
free_accept_languages(langs);
free(langdup);
return NULL;
}
/* Ensure it is upper case */
for(x = 0, stp = langs->languages[ langs->count - 1]->locality;
x < strlen(langs->languages[ langs->count - 1]->locality);
x++, stp++) {
*stp = toupper(*stp);
}
/* Then null out the delimiter so the language copy works */
*localitydelim = '\0';
}
if(NULL == (langs->languages[ langs->count - 1]->language =
strdup(langtok))) {
printf("Unable to allocate memory for language '%s'\n",
langtok);
free_accept_languages(langs);
free(langdup);
return NULL;
}
/* Get the next language token */
langtok = strtok_r(NULL, ",", &saveptr);
}
free(langdup);
return langs;
}
static char* parse_value(nx_json* parent, const char* key, char* p, nx_json_unicode_encoder encoder) {
nx_json* js;
while (1) {
switch (*p) {
case '\0':
NX_JSON_REPORT_ERROR("unexpected end of text", p);
return 0; // error
case ' ': case '\t': case '\n': case '\r':
case ',':
// skip
p++;
break;
case '{':
js=create_json(NX_JSON_OBJECT, key, parent);
p++;
while (1) {
const char* new_key;
p=parse_key(&new_key, p, encoder);
if (!p) return 0; // error
if (*p=='}') return p+1; // end of object
p=parse_value(js, new_key, p, encoder);
if (!p) return 0; // error
}
case '[':
js=create_json(NX_JSON_ARRAY, key, parent);
p++;
while (1) {
p=parse_value(js, 0, p, encoder);
if (!p) return 0; // error
if (*p==']') return p+1; // end of array
}
case ']':
return p;
case '"':
p++;
js=create_json(NX_JSON_STRING, key, parent);
js->text_value=unescape_string(p, &p, encoder);
if (!js->text_value) return 0; // propagate error
return p;
case '-': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
{
js=create_json(NX_JSON_INTEGER, key, parent);
char* pe;
js->int_value=strtol(p, &pe, 0);
if (pe==p) {
NX_JSON_REPORT_ERROR("invalid number", p);
return 0; // error
}
if (*pe=='.' || *pe=='e' || *pe=='E') { // double value
js->type=NX_JSON_DOUBLE;
js->dbl_value=strtod(p, &pe);
if (pe==p) {
NX_JSON_REPORT_ERROR("invalid number", p);
return 0; // error
}
}
else {
js->dbl_value=js->int_value;
}
return pe;
}
case 't':
if (!strncmp(p, "true", 4)) {
js=create_json(NX_JSON_BOOL, key, parent);
js->int_value=1;
return p+4;
}
NX_JSON_REPORT_ERROR("unexpected chars", p);
return 0; // error
case 'f':
if (!strncmp(p, "false", 5)) {
js=create_json(NX_JSON_BOOL, key, parent);
js->int_value=0;
return p+5;
}
NX_JSON_REPORT_ERROR("unexpected chars", p);
return 0; // error
case 'n':
if (!strncmp(p, "null", 4)) {
create_json(NX_JSON_NULL, key, parent);
return p+4;
}
NX_JSON_REPORT_ERROR("unexpected chars", p);
return 0; // error
case '/': // comment
if (p[1]=='/') { // line comment
char* ps=p;
p=strchr(p+2, '\n');
if (!p) {
NX_JSON_REPORT_ERROR("endless comment", ps);
return 0; // error
}
p++;
}
else if (p[1]=='*') { // block comment
p=skip_block_comment(p+2);
if (!p) return 0;
}
else {
NX_JSON_REPORT_ERROR("unexpected chars", p);
return 0; // error
}
break;
default:
NX_JSON_REPORT_ERROR("unexpected chars", p);
return 0; // error
}
}
}
int main(int argc, char **argv)
{
/* Set some default behaviors. */
const char *i = "rect";
const char *o = "rect";
const char *p = "rgss";
const char *f = "linear";
float rot[3] = { 0.f, 0.f, 0.f };
int n = 1024;
int c;
/* Parse the command line options. */
while ((c = getopt(argc, argv, "i:o:p:n:f:x:y:z:")) != -1)
switch (c)
{
case 'i': i = optarg; break;
case 'o': o = optarg; break;
case 'p': p = optarg; break;
case 'f': f = optarg; break;
case 'x': rot[0] = strtod(optarg, 0); break;
case 'y': rot[1] = strtod(optarg, 0); break;
case 'z': rot[2] = strtod(optarg, 0); break;
case 'n': n = strtol(optarg, 0, 0); break;
default: return usage(argv[0]);
}
int num = 1;
image *src = 0;
image *dst = 0;
image *tmp = 0;
to_img img;
to_env env;
filter fil;
/* Select the sampler. */
if (!strcmp(f, "linear")) fil = filter_linear;
else if (!strcmp(f, "nearest")) fil = filter_nearest;
else return usage(argv[0]);
/* Read the input image. */
if (optind + 2 <= argc)
{
if (!strcmp(i, "cube"))
{
tmp = image_reader(argv[optind], 6);
src = image_border(tmp);
img = cube_to_img;
}
else if (!strcmp(i, "dome"))
{
src = image_reader(argv[optind], 1);
img = dome_to_img;
}
else if (!strcmp(i, "hemi"))
{
src = image_reader(argv[optind], 1);
img = hemi_to_img;
}
else if (!strcmp(i, "ball"))
{
src = image_reader(argv[optind], 1);
img = ball_to_img;
}
else if (!strcmp(i, "rect"))
{
src = image_reader(argv[optind], 1);
img = rect_to_img;
}
else return usage(argv[0]);
}
else return usage(argv[0]);
/* Prepare the output image. */
if (src)
{
if (!strcmp(o, "cube"))
{
dst = image_alloc((num = 6), n, n, src->c, src->b, src->s);
env = cube_to_env;
}
else if (!strcmp(o, "dome"))
{
dst = image_alloc((num = 1), n, n, src->c, src->b, src->s);
env = dome_to_env;
}
else if (!strcmp(o, "hemi"))
{
dst = image_alloc((num = 1), n, n, src->c, src->b, src->s);
env = hemi_to_env;
}
else if (!strcmp(o, "ball"))
{
dst = image_alloc((num = 1), n, n, src->c, src->b, src->s);
env = ball_to_env;
}
else if (!strcmp(o, "rect"))
{
dst = image_alloc((num = 1), n, 2 * n, src->c, src->b, src->s);
env = rect_to_env;
}
else return usage(argv[0]);
}
/* Perform the remapping using the selected pattern. */
if (src && dst)
{
if (!strcmp(p, "cent"))
process(src, dst, ¢_pattern, rot, fil, img, env, num);
else if (!strcmp(p, "rgss"))
process(src, dst, &rgss_pattern, rot, fil, img, env, num);
else if (!strcmp(p, "box2"))
process(src, dst, &box2_pattern, rot, fil, img, env, num);
else if (!strcmp(p, "box3"))
process(src, dst, &box3_pattern, rot, fil, img, env, num);
else if (!strcmp(p, "box4"))
process(src, dst, &box4_pattern, rot, fil, img, env, num);
else return usage(argv[0]);
/* Write the output. */
image_writer(argv[optind + 1], dst, num);
}
return 0;
}
static config_err_t
_decode_value_raw (ipmi_sensors_config_state_data_t *state_data,
const char *threshold_input,
uint8_t *threshold_raw)
{
int8_t r_exponent, b_exponent;
int16_t m, b;
uint8_t linearization, analog_data_format;
config_err_t rv = CONFIG_ERR_FATAL_ERROR;
config_err_t ret;
double threshold_value;
char *ptr;
assert (state_data);
assert (threshold_input);
assert (threshold_raw);
if ((ret = _get_sdr_decoding_data (state_data,
&r_exponent,
&b_exponent,
&m,
&b,
&linearization,
&analog_data_format)) != CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
errno = 0;
threshold_value = strtod (threshold_input, &ptr);
if (errno
|| ptr[0] != '\0')
{
pstdout_fprintf (state_data->pstate,
stderr,
"Invalid input: %s\n",
threshold_input);
/* fatal error, should have been validated earlier */
goto cleanup;
}
if (ipmi_sensor_decode_raw_value (r_exponent,
b_exponent,
m,
b,
linearization,
analog_data_format,
threshold_value,
threshold_raw) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sensor_decode_raw_value: %s\n",
strerror (errno));
goto cleanup;
}
rv = CONFIG_ERR_SUCCESS;
cleanup:
return (rv);
}
yajl_status
yajl_do_parse(yajl_handle hand, const unsigned char * jsonText,
size_t jsonTextLen)
{
yajl_tok tok;
const unsigned char * buf;
size_t bufLen;
size_t * offset = &(hand->bytesConsumed);
*offset = 0;
around_again:
switch (yajl_bs_current(hand->stateStack)) {
case yajl_state_parse_complete:
if (hand->flags & yajl_allow_multiple_values) {
yajl_bs_set(hand->stateStack, yajl_state_got_value);
goto around_again;
}
if (!(hand->flags & yajl_allow_trailing_garbage)) {
if (*offset != jsonTextLen) {
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
offset, &buf, &bufLen);
if (tok != yajl_tok_eof) {
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
hand->parseError = "trailing garbage";
}
goto around_again;
}
}
return yajl_status_ok;
case yajl_state_lexical_error:
case yajl_state_parse_error:
return yajl_status_error;
case yajl_state_start:
case yajl_state_got_value:
case yajl_state_map_need_val:
case yajl_state_array_need_val:
case yajl_state_array_start: {
/* for arrays and maps, we advance the state for this
* depth, then push the state of the next depth.
* If an error occurs during the parsing of the nesting
* enitity, the state at this level will not matter.
* a state that needs pushing will be anything other
* than state_start */
yajl_state stateToPush = yajl_state_start;
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
offset, &buf, &bufLen);
switch (tok) {
case yajl_tok_eof:
return yajl_status_ok;
case yajl_tok_error:
yajl_bs_set(hand->stateStack, yajl_state_lexical_error);
goto around_again;
case yajl_tok_string:
if (hand->callbacks && hand->callbacks->yajl_string) {
_CC_CHK(hand->callbacks->yajl_string(hand->ctx,
buf, bufLen));
}
break;
case yajl_tok_string_with_escapes:
if (hand->callbacks && hand->callbacks->yajl_string) {
yajl_buf_clear(hand->decodeBuf);
yajl_string_decode(hand->decodeBuf, buf, bufLen);
_CC_CHK(hand->callbacks->yajl_string(
hand->ctx, yajl_buf_data(hand->decodeBuf),
yajl_buf_len(hand->decodeBuf)));
}
break;
case yajl_tok_bool:
if (hand->callbacks && hand->callbacks->yajl_boolean) {
_CC_CHK(hand->callbacks->yajl_boolean(hand->ctx,
*buf == 't'));
}
break;
case yajl_tok_null:
if (hand->callbacks && hand->callbacks->yajl_null) {
_CC_CHK(hand->callbacks->yajl_null(hand->ctx));
}
break;
case yajl_tok_left_bracket:
if (hand->callbacks && hand->callbacks->yajl_start_map) {
_CC_CHK(hand->callbacks->yajl_start_map(hand->ctx));
}
stateToPush = yajl_state_map_start;
break;
case yajl_tok_left_brace:
if (hand->callbacks && hand->callbacks->yajl_start_array) {
_CC_CHK(hand->callbacks->yajl_start_array(hand->ctx));
}
stateToPush = yajl_state_array_start;
break;
case yajl_tok_integer:
if (hand->callbacks) {
if (hand->callbacks->yajl_number) {
_CC_CHK(hand->callbacks->yajl_number(
hand->ctx,(const char *) buf, bufLen));
} else if (hand->callbacks->yajl_integer) {
int64_t i = 0;
errno = 0;
i = yajl_parse_integer(buf, (unsigned int)bufLen);
if ((i == INT64_MIN || i == INT64_MAX) &&
errno == ERANGE)
{
yajl_bs_set(hand->stateStack,
yajl_state_parse_error);
hand->parseError = "integer overflow" ;
/* try to restore error offset */
if (*offset >= bufLen) *offset -= bufLen;
else *offset = 0;
goto around_again;
}
_CC_CHK(hand->callbacks->yajl_integer(hand->ctx,
i));
}
}
break;
case yajl_tok_double:
if (hand->callbacks) {
if (hand->callbacks->yajl_number) {
_CC_CHK(hand->callbacks->yajl_number(
hand->ctx, (const char *) buf, bufLen));
} else if (hand->callbacks->yajl_double) {
double d = 0.0;
yajl_buf_clear(hand->decodeBuf);
yajl_buf_append(hand->decodeBuf, buf, bufLen);
buf = yajl_buf_data(hand->decodeBuf);
errno = 0;
d = strtod((char *) buf, NULL);
if ((d == HUGE_VAL || d == -HUGE_VAL) &&
errno == ERANGE)
{
yajl_bs_set(hand->stateStack,
yajl_state_parse_error);
hand->parseError = "numeric (floating point) "
"overflow";
/* try to restore error offset */
if (*offset >= bufLen) *offset -= bufLen;
else *offset = 0;
goto around_again;
}
_CC_CHK(hand->callbacks->yajl_double(hand->ctx,
d));
}
}
break;
case yajl_tok_right_brace: {
if (yajl_bs_current(hand->stateStack) ==
yajl_state_array_start)
{
if (hand->callbacks &&
hand->callbacks->yajl_end_array)
{
_CC_CHK(hand->callbacks->yajl_end_array(hand->ctx));
}
yajl_bs_pop(hand->stateStack);
goto around_again;
}
/* intentional fall-through */
}
case yajl_tok_colon:
case yajl_tok_comma:
case yajl_tok_right_bracket:
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
hand->parseError =
"unallowed token at this point in JSON text";
goto around_again;
default:
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
hand->parseError = "invalid token, internal error";
goto around_again;
}
/* got a value. transition depends on the state we're in. */
{
yajl_state s = yajl_bs_current(hand->stateStack);
if (s == yajl_state_start || s == yajl_state_got_value) {
yajl_bs_set(hand->stateStack, yajl_state_parse_complete);
} else if (s == yajl_state_map_need_val) {
yajl_bs_set(hand->stateStack, yajl_state_map_got_val);
} else {
yajl_bs_set(hand->stateStack, yajl_state_array_got_val);
}
}
if (stateToPush != yajl_state_start) {
yajl_bs_push(hand->stateStack, stateToPush);
}
goto around_again;
}
case yajl_state_map_start:
case yajl_state_map_need_key: {
/* only difference between these two states is that in
* start '}' is valid, whereas in need_key, we've parsed
* a comma, and a string key _must_ follow */
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
offset, &buf, &bufLen);
switch (tok) {
case yajl_tok_eof:
return yajl_status_ok;
case yajl_tok_error:
yajl_bs_set(hand->stateStack, yajl_state_lexical_error);
goto around_again;
case yajl_tok_string_with_escapes:
if (hand->callbacks && hand->callbacks->yajl_map_key) {
yajl_buf_clear(hand->decodeBuf);
yajl_string_decode(hand->decodeBuf, buf, bufLen);
buf = yajl_buf_data(hand->decodeBuf);
bufLen = yajl_buf_len(hand->decodeBuf);
}
/* intentional fall-through */
case yajl_tok_string:
if (hand->callbacks && hand->callbacks->yajl_map_key) {
_CC_CHK(hand->callbacks->yajl_map_key(hand->ctx, buf,
bufLen));
}
yajl_bs_set(hand->stateStack, yajl_state_map_sep);
goto around_again;
case yajl_tok_right_bracket:
if (yajl_bs_current(hand->stateStack) ==
yajl_state_map_start)
{
if (hand->callbacks && hand->callbacks->yajl_end_map) {
_CC_CHK(hand->callbacks->yajl_end_map(hand->ctx));
}
yajl_bs_pop(hand->stateStack);
goto around_again;
}
default:
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
hand->parseError =
"invalid object key (must be a string)";
goto around_again;
}
}
case yajl_state_map_sep: {
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
offset, &buf, &bufLen);
switch (tok) {
case yajl_tok_colon:
yajl_bs_set(hand->stateStack, yajl_state_map_need_val);
goto around_again;
case yajl_tok_eof:
return yajl_status_ok;
case yajl_tok_error:
yajl_bs_set(hand->stateStack, yajl_state_lexical_error);
goto around_again;
default:
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
hand->parseError = "object key and value must "
"be separated by a colon (':')";
goto around_again;
}
}
case yajl_state_map_got_val: {
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
offset, &buf, &bufLen);
switch (tok) {
case yajl_tok_right_bracket:
if (hand->callbacks && hand->callbacks->yajl_end_map) {
_CC_CHK(hand->callbacks->yajl_end_map(hand->ctx));
}
yajl_bs_pop(hand->stateStack);
goto around_again;
case yajl_tok_comma:
yajl_bs_set(hand->stateStack, yajl_state_map_need_key);
goto around_again;
case yajl_tok_eof:
return yajl_status_ok;
case yajl_tok_error:
yajl_bs_set(hand->stateStack, yajl_state_lexical_error);
goto around_again;
default:
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
hand->parseError = "after key and value, inside map, "
"I expect ',' or '}'";
/* try to restore error offset */
if (*offset >= bufLen) *offset -= bufLen;
else *offset = 0;
goto around_again;
}
}
case yajl_state_array_got_val: {
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
offset, &buf, &bufLen);
switch (tok) {
case yajl_tok_right_brace:
if (hand->callbacks && hand->callbacks->yajl_end_array) {
_CC_CHK(hand->callbacks->yajl_end_array(hand->ctx));
}
yajl_bs_pop(hand->stateStack);
goto around_again;
case yajl_tok_comma:
yajl_bs_set(hand->stateStack, yajl_state_array_need_val);
goto around_again;
case yajl_tok_eof:
return yajl_status_ok;
case yajl_tok_error:
yajl_bs_set(hand->stateStack, yajl_state_lexical_error);
goto around_again;
default:
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
hand->parseError =
"after array element, I expect ',' or ']'";
goto around_again;
}
}
}
abort();
return yajl_status_error;
}
int main(int argc, char *argv[])
{
int sockfd;
struct sigaction act;
char fname[BUFSIZE], timestr[BUFSIZE], buf[BUFSIZE];
char stringbuffer[50][BUFSIZE];
int i;
time_t now;
char *str, *ptr, *pEnd;
double rf_level;
struct tm *loctime;
struct stat statbuf;
FILE *f;
/* cgi variables */
int postsize;
/* print html headers */
printf("Content-Type: text/html;charset=iso-8859-1\n\n");
printf("<html><head>\n");
printf("<style type=\"text/css\">");
printf(" p { margin: 0; padding: 0;}");
printf(" h1 { font-size: 120%; padding: 0; margin-bottom: 0; } ");
printf(" form { float:left } ");
printf(" hr { clear: both } ");
printf(" </style>");
/* printf("<meta http-equiv=\"refresh\" content=\"5\">"); */
printf("</head><body>\n");
/* get post data */
str = getenv("CONTENT_LENGTH");
if (str!=NULL) postsize = atoi(str);
else postsize=0;
fgets(buf, postsize+1, stdin);
ptr=buf;
while (((*ptr)!='=')&&((*ptr)!='\0')) {
ptr++;
}
if (*ptr!='\0') ptr++;
/* setup variables */
/* setup signal handler */
act.sa_handler = sig_alrm;
act.sa_flags = 0;
sigaction(SIGALRM, &act, 0);
/* check it's valid float and greater than 0 */
errno = 0;
rf_level = strtod(ptr, &pEnd);
/* parameter was given, so send it to weather station */
//printf("%s", ptr);
if (strstr(ptr, "reset") != NULL) {
/* Parameter was reset command */
/* connect */
if ((sockfd = connect_ip(SERVER_IP, SERVER_PORT)) == -1) {
return -1;
}
/* generate parameter string */
snprintf(buf, sizeof(buf), "%s", MSG_RESET, ptr);
/* send parameters to server */
if (send_data(sockfd, buf, sizeof(buf)) != 0) {
return -1;
}
close(sockfd);
sleep(5);
printf("Reset successful!");
} else if (rf_level > 0) {
/* Parameter was RF trigger level */
/* connect */
if ((sockfd = connect_ip(SERVER_IP, SERVER_PORT)) == -1) {
return -1;
}
/* generate parameter string */
snprintf(buf, sizeof(buf), "%s;%s\r\n", MSG_SET_PARAMS, ptr);
/* send parameters to server */
if (send_data(sockfd, buf, sizeof(buf)) != 0) {
return -1;
}
close(sockfd);
sleep(1);
printf("Level set succesfully!");
}
/* fail connection on timeout */
alarm(FAILTIME);
if ((sockfd = connect_ip(SERVER_IP, SERVER_PORT)) == -1) {
return 1;
}
/* start talking to server */
if (get_data(sockfd, buf, sizeof(buf), MSG_GET_PARAMS) <= 0) {
return 1;
}
close(sockfd);
rf_level = strtod(buf, &pEnd);
/* clear interrupt */
alarm(0);
/* Page title */
printf("<h1>Weather Station Configuration Tool</h1>");
printf("<p>Version 1.0, Copyright (C) 2007 Mikko Vatanen\n</p><hr>");
/* Parameter form */
printf("<form method=\"post\" action=\"/cgi-bin/conftool\">\n");
printf("<label>RF Trigger Level: </label>");
printf("<input type=\"text\" name=\"level\" value=\"%2.2f\">\n", rf_level);
printf("<input type=\"submit\" value=\"Set level\">\n");
printf("</form>\n");
/* Reset form */
printf("<form method=\"post\" action=\"/cgi-bin/conftool\">\n");
printf("<input type=\"hidden\" name=\"level\" value=\"reset\">\n");
printf(" <input type=\"submit\" value=\"Reset WStation\">\n");
printf("</form>");
/* Refresh data */
printf("<form method=\"post\" action=\"/cgi-bin/conftool\">\n");
printf("<input type=\"hidden\" name=\"level\" value=\"\">\n");
printf(" <input type=\"submit\" value=\"Refresh page\">\n");
printf("</form>");
printf("<br><hr>");
/* tail newest data file */
now = time(NULL);
loctime = localtime(&now);
strftime(timestr, sizeof(timestr), "%F", loctime);
sprintf(fname, "/home/wwwadmin/htdocs/saa/%s/%s.%s", DATADIR, timestr, FILEEXT);
printf("<b>%s</b><br><pre>", fname);
stat(fname, &statbuf);
if ((f = fopen(fname, "r")) != NULL) {
i = 0;
if (fseek(f, statbuf.st_size - 40 * 65, SEEK_SET ) == 0) {
/* ignore partial line first */
fgets(buf, sizeof(buf), f);
/* store data for reverse order */
while (fgets(buf, sizeof(buf), f) != NULL && i < 40) {
strncpy(stringbuffer[i++], buf, BUFSIZE);
}
}
fclose(f);
}
/* Print data in reverse order */
while ( i >= 0 ) {
printf("%s", stringbuffer[i--]);
}
printf("</pre>\n");
/* print html footer */
printf("</body></html>\n");
return 0;
}
/*
** Read a variable. On error put nil on stack.
** LUA interface:
** variable = read ([format])
**
** O formato pode ter um dos seguintes especificadores:
**
** s ou S -> para string
** f ou F, g ou G, e ou E -> para reais
** i ou I -> para inteiros
**
** Estes especificadores podem vir seguidos de numero que representa
** o numero de campos a serem lidos.
*/
static void io_read (void)
{
lua_Object o = lua_getparam (1);
if (o == NULL || !lua_isstring(o)) /* free format */
{
int c;
char s[256];
while (isspace(c=fgetc(in)))
;
if (c == '\"')
{
int c, n=0;
while((c = fgetc(in)) != '\"')
{
if (c == EOF)
{
lua_pushnil ();
return;
}
s[n++] = c;
}
s[n] = 0;
}
else if (c == '\'')
{
int c, n=0;
while((c = fgetc(in)) != '\'')
{
if (c == EOF)
{
lua_pushnil ();
return;
}
s[n++] = c;
}
s[n] = 0;
}
else
{
char *ptr;
double d;
ungetc (c, in);
if (fscanf (in, "%s", s) != 1)
{
lua_pushnil ();
return;
}
d = strtod (s, &ptr);
if (!(*ptr))
{
lua_pushnumber (d);
return;
}
}
lua_pushstring (s);
return;
}
else /* formatted */
{
char *e = lua_getstring(o);
char t;
int m=0;
while (isspace(*e)) e++;
t = *e++;
while (isdigit(*e))
m = m*10 + (*e++ - '0');
if (m > 0)
{
char f[80];
char s[256];
sprintf (f, "%%%ds", m);
if (fgets (s, m, in) == NULL)
{
lua_pushnil();
return;
}
else
{
if (s[strlen(s)-1] == '\n')
s[strlen(s)-1] = 0;
}
switch (tolower(t))
{
case 'i':
{
long int l;
sscanf (s, "%ld", &l);
lua_pushnumber(l);
}
break;
case 'f': case 'g': case 'e':
{
float f;
sscanf (s, "%f", &f);
lua_pushnumber(f);
}
break;
default:
lua_pushstring(s);
break;
}
}
else
{
switch (tolower(t))
{
case 'i':
{
long int l;
if (fscanf (in, "%ld", &l) == EOF)
lua_pushnil();
else lua_pushnumber(l);
}
break;
case 'f': case 'g': case 'e':
{
float f;
if (fscanf (in, "%f", &f) == EOF)
lua_pushnil();
else lua_pushnumber(f);
}
break;
default:
{
char s[256];
if (fscanf (in, "%s", s) == EOF)
lua_pushnil();
else lua_pushstring(s);
}
break;
}
}
}
}
sch_resource_t
res_to_num(char *res_str, struct resource_type *type)
{
sch_resource_t count = SCHD_INFINITY; /* convert string resource to numeric */
sch_resource_t count2 = SCHD_INFINITY; /* convert string resource to numeric */
char *endp; /* used for strtol() */
char *endp2; /* used for strtol() */
long multiplier = 1; /* multiplier to count */
int is_size = 0; /* resource value is a size type */
int is_time = 0; /* resource value is a time spec */
if (res_str == NULL)
return SCHD_INFINITY;
if (!strcasecmp(ATR_TRUE, res_str)) {
if (type != NULL) {
type->is_boolean = 1;
type->is_non_consumable = 1;
}
count = 1;
}
else if (!strcasecmp(ATR_FALSE, res_str)) {
if (type != NULL) {
type->is_boolean = 1;
type->is_non_consumable = 1;
}
count = 0;
}
else if (!is_num(res_str)) {
if (type != NULL) {
type->is_string = 1;
type->is_non_consumable = 1;
}
count = SCHD_INFINITY;
}
else {
count = (sch_resource_t) strtod(res_str, &endp);
if (*endp == ':') { /* time resource -> convert to seconds */
count2 = (sch_resource_t) strtod(endp+1, &endp2);
if (*endp2 == ':') { /* form of HH:MM:SS */
count *= 3600;
count += count2 * 60;
count += strtol(endp2 + 1, &endp, 10);
if (*endp != '\0')
count = SCHD_INFINITY;
}
else { /* form of MM:SS */
count *= 60;
count += count2;
}
multiplier = 1;
is_time = 1;
}
else if (*endp == 'k' || *endp == 'K') {
multiplier = 1;
is_size = 1;
}
else if (*endp == 'm' || *endp == 'M') {
multiplier = MEGATOKILO;
is_size = 1;
}
else if (*endp == 'g' || *endp == 'G') {
multiplier = GIGATOKILO;
is_size = 1;
}
else if (*endp == 't' || *endp == 'T') {
multiplier = TERATOKILO;
is_size = 1;
}
else if (*endp == 'b' || *endp == 'B') {
count = ceil(count / KILO);
multiplier = 1;
is_size = 1;
}
else if (*endp == 'w') {
count = ceil(count / KILO);
multiplier = SIZEOF_WORD;
is_size = 1;
}
else /* catch all */
multiplier = 1;
if (*endp != '\0' && *(endp + 1) == 'w')
multiplier *= SIZEOF_WORD;
if (type != NULL) {
type->is_consumable = 1;
if (is_size )
type->is_size = 1;
else if (is_time)
type->is_time = 1;
else
type->is_num = 1;
}
}
return count * multiplier;
}
void CGPSSubcrible::OnRevGpsMsg(long ILongID,char strgps[],long lenth)
{
//获得字符数组
char *pchar = new char[ lenth + 1];
char *pdate = new char[5];
memcpy(pchar,strgps,lenth);
*(pchar + lenth) = '\0';
char *tok;
char *p[50] = {0};
char seps[] = ",";
int i = 0;
char *stopstr;
//获得字符串数组
tok = strtok(pchar,seps);
while( tok != NULL && i < 50)
{
p[i] = new char[strlen(tok) + 1];
strcpy(p[i],tok);
tok = strtok( NULL,seps);
i++;
}
if ( i < 10 )
{
//清除数组指针
for(int j = 0; j<i; j++)
{
delete p[j];
}
delete pchar;
delete pdate;
return;
}
GPS_Info info = {0};
// const int TIGER_COORDINATE_UNIT = 1000000;
info.latidude = strtod(p[0],&stopstr);
// info.latidude /= TIGER_COORDINATE_UNIT;
// info.latidude -= 90;
info.longitude = strtod(p[1],&stopstr);
// info.longitude /= TIGER_COORDINATE_UNIT;
// info.longitude -= 180;
info.speed = strtod(p[2],&stopstr);
info.height = strtod(p[3],&stopstr);
info.angle = strtod(p[4],&stopstr);
strncpy(pdate,p[5],4);
*(pdate+4) = '\0';
info.revTime.dwYear = strtol(pdate,&stopstr,10);
strncpy(pdate,p[5]+4,2);
*(pdate+2) = '\0';
info.revTime.dwMonth = strtol(pdate,&stopstr,10);
strncpy(pdate,p[5]+6,2);
*(pdate+2) = '\0';
info.revTime.dwDay = strtol(pdate,&stopstr,10);
strncpy(pdate,p[5]+8,2);
*(pdate+2) = '\0';
info.revTime.dwHour = strtol(pdate,&stopstr,10);
strncpy(pdate,p[5]+10,2);
*(pdate+2) = '\0';
info.revTime.dwMinute = strtol(pdate,&stopstr,10);
strncpy(pdate,p[5]+12,2);
*(pdate+2) = '\0';
info.revTime.dwSecond = strtol(pdate,&stopstr,10);
info.antennaState = (p[6][0] == '1');
info.orientationState = (p[7][0] == '1');
info.starCount = strtol(p[8],&stopstr,10);
//清除数组指针
for(int j = 0; j<i; j++)
{
delete p[j];
}
delete pchar;
delete pdate;
if(m_RecievCallBack != NULL)
{
m_RecievCallBack(ILongID,info,m_dwuserdata);
}
}
double atof(const char *s)
{
return strtod(s, (const char **) NULL);
}
void do_predict(FILE *input, FILE *output)
{
int correct = 0;
int total = 0;
double error = 0;
double sump = 0, sumt = 0, sumpp = 0, sumtt = 0, sumpt = 0;
int nr_class=get_nr_class(model_);
double *prob_estimates=NULL;
int j, n;
int nr_feature=get_nr_feature(model_);
if(model_->bias>=0)
n=nr_feature+1;
else
n=nr_feature;
if(flag_predict_probability)
{
int *labels;
if(!check_probability_model(model_))
{
fprintf(stderr, "probability output is only supported for logistic regression\n");
exit(1);
}
labels=(int *) malloc(nr_class*sizeof(int));
get_labels(model_,labels);
prob_estimates = (double *) malloc(nr_class*sizeof(double));
fprintf(output,"labels");
for(j=0;j<nr_class;j++)
fprintf(output," %d",labels[j]);
fprintf(output,"\n");
free(labels);
}
max_line_len = 1024;
line = (char *)malloc(max_line_len*sizeof(char));
while(readline(input) != NULL)
{
int i = 0;
double target_label, predict_label;
char *idx, *val, *label, *endptr;
int inst_max_index = 0; // strtol gives 0 if wrong format
label = strtok(line," \t\n");
if(label == NULL) // empty line
exit_input_error(total+1);
target_label = strtod(label,&endptr);
if(endptr == label || *endptr != '\0')
exit_input_error(total+1);
while(1)
{
if(i>=max_nr_attr-2) // need one more for index = -1
{
max_nr_attr *= 2;
x = (struct feature_node *) realloc(x,max_nr_attr*sizeof(struct feature_node));
}
idx = strtok(NULL,":");
val = strtok(NULL," \t");
if(val == NULL)
break;
errno = 0;
x[i].index = (int) strtol(idx,&endptr,10);
if(endptr == idx || errno != 0 || *endptr != '\0' || x[i].index <= inst_max_index)
exit_input_error(total+1);
else
inst_max_index = x[i].index;
errno = 0;
x[i].value = strtod(val,&endptr);
if(endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr)))
exit_input_error(total+1);
// feature indices larger than those in training are not used
if(x[i].index <= nr_feature)
++i;
}
if(model_->bias>=0)
{
x[i].index = n;
x[i].value = model_->bias;
i++;
}
x[i].index = -1;
if(flag_predict_probability)
{
int j;
predict_label = predict_probability(model_,x,prob_estimates);
fprintf(output,"%g",predict_label);
for(j=0;j<model_->nr_class;j++)
fprintf(output," %g",prob_estimates[j]);
fprintf(output,"\n");
}
else
{
predict_label = predict(model_,x);
fprintf(output,"%g\n",predict_label);
}
if(predict_label == target_label)
++correct;
error += (predict_label-target_label)*(predict_label-target_label);
sump += predict_label;
sumt += target_label;
sumpp += predict_label*predict_label;
sumtt += target_label*target_label;
sumpt += predict_label*target_label;
++total;
}
if(model_->param.solver_type==L2R_L2LOSS_SVR ||
model_->param.solver_type==L2R_L1LOSS_SVR_DUAL ||
model_->param.solver_type==L2R_L2LOSS_SVR_DUAL)
{
info("Mean squared error = %g (regression)\n",error/total);
info("Squared correlation coefficient = %g (regression)\n",
((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/
((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt))
);
}
else
info("Accuracy = %g%% (%d/%d)\n",(double) correct/total*100,correct,total);
if(flag_predict_probability)
free(prob_estimates);
}
/* process command-line arguments */
static int
process_arguments (int argc, char **argv)
{
int c;
int escape = 0;
char *temp;
int option = 0;
static struct option longopts[] = {
{"hostname", required_argument, 0, 'H'},
{"critical", required_argument, 0, 'c'},
{"warning", required_argument, 0, 'w'},
{"critical-codes", required_argument, 0, 'C'},
{"warning-codes", required_argument, 0, 'W'},
{"timeout", required_argument, 0, 't'},
{"protocol", required_argument, 0, 'P'}, /* FIXME: Unhandled */
{"port", required_argument, 0, 'p'},
{"escape", no_argument, 0, 'E'},
{"all", no_argument, 0, 'A'},
{"send", required_argument, 0, 's'},
{"expect", required_argument, 0, 'e'},
{"maxbytes", required_argument, 0, 'm'},
{"quit", required_argument, 0, 'q'},
{"jail", no_argument, 0, 'j'},
{"delay", required_argument, 0, 'd'},
{"refuse", required_argument, 0, 'r'},
{"mismatch", required_argument, 0, 'M'},
{"use-ipv4", no_argument, 0, '4'},
{"use-ipv6", no_argument, 0, '6'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{"ssl", no_argument, 0, 'S'},
{"certificate", required_argument, 0, 'D'},
{0, 0, 0, 0}
};
if (argc < 2)
usage4 (_("No arguments found"));
/* backwards compatibility */
for (c = 1; c < argc; c++) {
if (strcmp ("-to", argv[c]) == 0)
strcpy (argv[c], "-t");
else if (strcmp ("-wt", argv[c]) == 0)
strcpy (argv[c], "-w");
else if (strcmp ("-ct", argv[c]) == 0)
strcpy (argv[c], "-c");
}
if (!is_option (argv[1])) {
server_address = argv[1];
argv[1] = argv[0];
argv = &argv[1];
argc--;
}
while (1) {
c = getopt_long (argc, argv, "+hVv46EAH:s:e:q:m:c:w:t:p:C:W:d:Sr:jD:M:",
longopts, &option);
if (c == -1 || c == EOF || c == 1)
break;
switch (c) {
case '?': /* print short usage statement if args not parsable */
usage5 ();
case 'h': /* help */
print_help ();
exit (STATE_OK);
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'v': /* verbose mode */
flags |= FLAG_VERBOSE;
break;
case '4':
address_family = AF_INET;
break;
case '6':
#ifdef USE_IPV6
address_family = AF_INET6;
#else
usage4 (_("IPv6 support not available"));
#endif
break;
case 'H': /* hostname */
server_address = optarg;
break;
case 'c': /* critical */
critical_time = strtod (optarg, NULL);
flags |= FLAG_TIME_CRIT;
break;
case 'j': /* hide output */
flags |= FLAG_HIDE_OUTPUT;
break;
case 'w': /* warning */
warning_time = strtod (optarg, NULL);
flags |= FLAG_TIME_WARN;
break;
case 'C':
crit_codes = realloc (crit_codes, ++crit_codes_count);
crit_codes[crit_codes_count - 1] = optarg;
break;
case 'W':
warn_codes = realloc (warn_codes, ++warn_codes_count);
warn_codes[warn_codes_count - 1] = optarg;
break;
case 't': /* timeout */
if (!is_intpos (optarg))
usage4 (_("Timeout interval must be a positive integer"));
else
socket_timeout = atoi (optarg);
break;
case 'p': /* port */
if (!is_intpos (optarg))
usage4 (_("Port must be a positive integer"));
else
server_port = atoi (optarg);
break;
case 'E':
escape = 1;
break;
case 's':
if (escape)
server_send = np_escaped_string(optarg);
else
xasprintf(&server_send, "%s", optarg);
break;
case 'e': /* expect string (may be repeated) */
flags &= ~FLAG_EXACT_MATCH;
if (server_expect_count == 0)
server_expect = malloc (sizeof (char *) * (++server_expect_count));
else
server_expect = realloc (server_expect, sizeof (char *) * (++server_expect_count));
server_expect[server_expect_count - 1] = optarg;
break;
case 'm':
if (!is_intpos (optarg))
usage4 (_("Maxbytes must be a positive integer"));
else
maxbytes = strtol (optarg, NULL, 0);
break;
case 'q':
if (escape)
server_quit = np_escaped_string(optarg);
else
xasprintf(&server_quit, "%s\r\n", optarg);
break;
case 'r':
if (!strncmp(optarg,"ok",2))
econn_refuse_state = STATE_OK;
else if (!strncmp(optarg,"warn",4))
econn_refuse_state = STATE_WARNING;
else if (!strncmp(optarg,"crit",4))
econn_refuse_state = STATE_CRITICAL;
else
usage4 (_("Refuse must be one of ok, warn, crit"));
break;
case 'M':
if (!strncmp(optarg,"ok",2))
expect_mismatch_state = STATE_OK;
else if (!strncmp(optarg,"warn",4))
expect_mismatch_state = STATE_WARNING;
else if (!strncmp(optarg,"crit",4))
expect_mismatch_state = STATE_CRITICAL;
else
usage4 (_("Mismatch must be one of ok, warn, crit"));
break;
case 'd':
if (is_intpos (optarg))
delay = atoi (optarg);
else
usage4 (_("Delay must be a positive integer"));
break;
case 'D': /* Check SSL cert validity - days 'til certificate expiration */
#ifdef HAVE_SSL
# ifdef USE_OPENSSL /* XXX */
if ((temp=strchr(optarg,','))!=NULL) {
*temp='\0';
if (!is_intnonneg (optarg))
usage2 (_("Invalid certificate expiration period"), optarg); days_till_exp_warn = atoi(optarg);
*temp=',';
temp++;
if (!is_intnonneg (temp))
usage2 (_("Invalid certificate expiration period"), temp);
days_till_exp_crit = atoi (temp);
}
else {
days_till_exp_crit=0;
if (!is_intnonneg (optarg))
usage2 (_("Invalid certificate expiration period"), optarg);
days_till_exp_warn = atoi (optarg);
}
check_cert = TRUE;
flags |= FLAG_SSL;
break;
# endif /* USE_OPENSSL */
#endif
/* fallthrough if we don't have ssl */
case 'S':
#ifdef HAVE_SSL
flags |= FLAG_SSL;
#else
die (STATE_UNKNOWN, _("Invalid option - SSL is not available"));
#endif
break;
case 'A':
flags |= FLAG_MATCH_ALL;
break;
}
}
if (server_address == NULL)
usage4 (_("You must provide a server address"));
else if (server_address[0] != '/' && is_host (server_address) == FALSE)
die (STATE_CRITICAL, "%s %s - %s: %s\n", SERVICE, state_text(STATE_CRITICAL), _("Invalid hostname, address or socket"), server_address);
return TRUE;
}
int main(int argc, char *argv[])
{
Ecore_Evas *ee;
Evas_Object *bridge, *img;
const char *opt, *input, *output, *params;
int r = 0, w = -1, h = -1, err;
double scale = -1.0;
if (argc < 4) {
fprintf(stderr,
"Usage:\n"
"\t%s <percentage%%|WxH|w=W|h=H> <input> <output>"
" [save-params]\n"
"where save-params is evas supported parameters, like:\n"
"\tquality=85\n"
"\tcompress=9\n",
argv[0]);
return 1;
}
opt = argv[1];
input = argv[2];
output = argv[3];
params = argv[4];
if (strncasecmp(opt, "w=", 2) == 0) {
char *end = NULL;
w = strtol(opt + 2, &end, 10);
if (!end || *end != '\0') {
fprintf(stderr, "ERROR: invalid decimal integer '%s'\n",
opt + 2);
return 1;
} else if (w < 1) {
fprintf(stderr, "ERROR: invalid width %d, must be >= 1\n", w);
return 1;
}
} else if (strncasecmp(opt, "h=", 2) == 0) {
char *end = NULL;
h = strtol(opt + 2, &end, 10);
if (!end || *end != '\0') {
fprintf(stderr, "ERROR: invalid decimal integer '%s'\n",
opt + 2);
return 1;
} else if (h < 1) {
fprintf(stderr, "ERROR: invalid height %d, must be >= 1\n", h);
return 1;
}
} else if (strchr(opt, '%')) {
char *end = NULL;
scale = strtod(opt, &end);
if (!end || *end != '%') {
fprintf(stderr, "ERROR: invalid percentual '%s'\n", opt);
return 1;
} else if (scale <= 0.0) {
fprintf(stderr, "ERROR: invalid percentual %g, must be > 0.0\n",
scale);
return 1;
}
scale /= 100.0;
} else if (strchr(opt, 'x')) {
if (sscanf(opt, "%dx%d", &w, &h) != 2) {
fprintf(stderr, "ERROR: invalid size format '%s'\n", opt);
return 1;
} else if (w < 1) {
fprintf(stderr, "ERROR: invalid width %d, must be >= 1\n", w);
return 1;
} else {
fprintf(stderr, "ERROR: invalid height %d, must be >= 1\n", h);
return 1;
}
} else {
fprintf(stderr,
"ERROR: first parameter must be in format:\n"
"\tpercentage%% - example: 10%%\n"
"\tWxH - example: 1024x768\n"
"\tw=W - example: w=1024\n"
"\th=H - example: h=768\n"
"But '%s' was used!\n",
opt);
return 1;
}
ecore_evas_init();
evas_init();
ee = ecore_evas_buffer_new(1, 1);
bridge = ecore_evas_object_image_new(ee);
img = evas_object_image_add(ecore_evas_object_evas_get(bridge));
evas_object_image_smooth_scale_set(img, EINA_TRUE);
if (w > 0 && h > 0)
evas_object_image_load_size_set(img, w, h);
evas_object_image_file_set(img, input, NULL);
err = evas_object_image_load_error_get(img);
if (err != EVAS_LOAD_ERROR_NONE) {
const char *msg = evas_load_error_str(err);
fprintf(stderr, "ERROR: could not load '%s': %s\n", input, msg);
r = 1;
goto end;
}
if (w < 1 || h < 1) {
int iw, ih;
evas_object_image_size_get(img, &iw, &ih);
if (iw < 0 || ih < 0) {
fprintf(stderr, "ERROR: invalid source image size %dx%d (%s)\n",
iw, ih, input);
goto end;
}
if (scale > 0) {
w = ceil(iw * scale);
h = ceil(ih * scale);
} else if (w < 1)
w = ceil(iw * (double)h / (double)ih);
else if (h < 1)
h = ceil(ih * (double)w / (double)iw);
if (iw != w && ih != h)
evas_object_image_load_size_set(img, w, h);
}
printf("output: %s, size: %dx%d, alpha: %s, params: %s\n",
output, w, h,
evas_object_image_alpha_get(img) ? "yes" : "no",
params ? params : "<none>");
evas_object_image_fill_set(img, 0, 0, w, h);
evas_object_resize(img, w, h);
evas_object_show(img);
evas_object_image_alpha_set(bridge, evas_object_image_alpha_get(img));
evas_object_image_size_set(bridge, w, h);
ecore_evas_manual_render(ecore_evas_object_ecore_evas_get(bridge));
evas_object_image_save(bridge, output, NULL, params);
end:
evas_object_del(img);
evas_object_del(bridge);
ecore_evas_free(ee);
evas_shutdown();
ecore_evas_shutdown();
return r;
}
void readData(double *adLookUp, char* szDataFile, t_Flows* ptFlows, t_Params *ptParams)
{
char szLine[MAX_LINE_LENGTH];
char *szTok;
int nN = 0, nM = 0;
double *adData = NULL;
double *adF = NULL;
int *anF = NULL;
int *anLengths = NULL;
char *pcError = NULL;
int i = 0, j = 0, nE = 0;
FILE *ifp = NULL;
ifp = fopen(szDataFile, "r");
if(ifp){
/*read header line*/
fgets(szLine, MAX_LINE_LENGTH, ifp);
/*get read number*/
szTok = strtok(szLine, DELIM);
nN = strtol(szTok,&pcError, 10);
if(*pcError != '\0')
goto formatError;
/*get flow number*/
szTok = strtok(NULL,DELIM);
nM = strtol(szTok,&pcError, 10);
if(*pcError != '\0')
goto formatError;
adData = (double *) malloc(nN*nM*sizeof(double));
if(!adData)
goto memoryError;
adF = (double *) malloc(nN*nM*sizeof(double));
if(!adF)
goto memoryError;
anF = (int *) malloc(nN*nM*sizeof(int));
if(!anF)
goto memoryError;
anLengths = (int *) malloc(nN*sizeof(int));
if(!anLengths)
goto memoryError;
for(i = 0; i < nN; i++){
fgets(szLine, MAX_LINE_LENGTH, ifp);
szTok = strtok(szLine, DELIM);
if(ptParams->bNoIndex == FALSE){
szTok = strtok(NULL, DELIM);
}
anLengths[i] = strtol(szTok, &pcError,10);
if(*pcError != '\0')
goto formatError;
nE = anLengths[i] % 4;
anLengths[i] -= nE;
printf("%d %d %d %d\n",i, anLengths[i], nE, nM);
for(j = 0; j < anLengths[i]; j++){
double dF = 0.0;
szTok = strtok(NULL, DELIM);
dF = strtod(szTok, &pcError);
// printf("%d %s %f\n",j, szTok,dF);
if(dF >= 9.99){
//fprintf(stderr,"%d %d %f too large max flow 9.99\n",i,j,dF);
dF = 9.99;
fflush(stderr);
}
adData[i*nM + j] = dF;
anF[i*nM + j] = (int) floor((dF + DELTA)/PRECISION);
if(anF[i*nM + j] < 0){
anF[i*nM + j] = 0;
}
if(anF[i*nM + j] > BINS - 1){
anF[i*nM + j] = BINS - 1;
}
adF[i*nM + j] = distM1(adLookUp, dF);
if(*pcError != '\0')
goto formatError;
}
for(; j < nM; j++){
double dF = 0.0;
adData[i*nM + j] = dF;
anF[i*nM + j] = (int) floor((dF + DELTA)/PRECISION);
adF[i*nM + j] = distM1(adLookUp, dF);
}
}
fclose(ifp);
}
else{
printf("Failed to open file %s in readData\n",szDataFile);
fflush(stderr);
exit(EXIT_FAILURE);
}
ptFlows->anLengths = anLengths;
ptFlows->adData = adData;
ptFlows->adF = adF;
ptFlows->anF = anF;
ptFlows->nN = nN; ptFlows->nM = nM;
return;
memoryError:
fprintf(stderr, "Failed allocating memory in readData\n");
fflush(stderr);
exit(EXIT_FAILURE);
formatError:
fprintf(stderr, "Incorrect input format error\n");
fflush(stderr);
exit(EXIT_FAILURE);
}
int VDScriptInterpreter::Token() {
static char hexdig[]="0123456789ABCDEF";
char *s,c;
if (tokhold) {
int t = tokhold;
tokhold = 0;
return t;
}
do {
c=*tokstr++;
} while(c && isspace((unsigned char)c));
if (!c) {
--tokstr;
return 0;
}
// C++ style comment?
if (c=='/')
if (tokstr[0]=='/') {
while(*tokstr) ++tokstr;
return 0; // C++ comment
} else
return '/';
// string?
if (c=='"') {
const char *s = tokstr;
char *t;
long len_adjust=0;
while((c=*tokstr++) && c!='"') {
if (c=='\\') {
c = *tokstr++;
if (!c) SCRIPT_ERROR(PARSE_ERROR);
else {
if (c=='x') {
if (!isxdigit((unsigned char)tokstr[0]) || !isxdigit((unsigned char)tokstr[1]))
SCRIPT_ERROR(PARSE_ERROR);
tokstr+=2;
len_adjust += 2;
}
++len_adjust;
}
}
}
tokslit = strheap.Allocate(tokstr - s - 1 - len_adjust);
t = *tokslit;
while(s<tokstr-1) {
int val;
c = *s++;
if (c=='\\')
switch(c=*s++) {
case 'a': *t++='\a'; break;
case 'b': *t++='\b'; break;
case 'f': *t++='\f'; break;
case 'n': *t++='\n'; break;
case 'r': *t++='\r'; break;
case 't': *t++='\t'; break;
case 'v': *t++='\v'; break;
case 'x':
val = strchr(hexdig,toupper(s[0]))-hexdig;
val = (val<<4) | (strchr(hexdig,toupper(s[1]))-hexdig);
*t++ = val;
s += 2;
break;
default:
*t++ = c;
}
else
*t++ = c;
}
*t=0;
if (!c) --tokstr;
return TOK_STRING;
}
// unescaped string?
if ((c=='u' || c=='U') && *tokstr == '"') {
const char *s = ++tokstr;
while((c=*tokstr++) && c != '"')
;
if (!c) {
--tokstr;
SCRIPT_ERROR(PARSE_ERROR);
}
size_t len = tokstr - s - 1;
const VDStringA strA(VDTextWToU8(VDTextAToW(s, len)));
len = strA.size();
tokslit = strheap.Allocate(len);
memcpy(*tokslit, strA.data(), len);
(*tokslit)[len] = 0;
return TOK_STRING;
}
// look for variable/keyword
if (isIdentFirstChar(c)) {
s = szIdent;
*s++ = c;
while(isIdentNextChar(c = *tokstr++)) {
if (s>=szIdent + MAX_IDENT_CHARS)
SCRIPT_ERROR(IDENT_TOO_LONG);
*s++ = c;
}
--tokstr;
*s=0;
if (!strcmp(szIdent, "declare"))
return TOK_DECLARE;
else if (!strcmp(szIdent, "true"))
return TOK_TRUE;
else if (!strcmp(szIdent, "false"))
return TOK_FALSE;
else if (!strcmp(szIdent, "int"))
return TOK_INT;
else if (!strcmp(szIdent, "long"))
return TOK_LONG;
else if (!strcmp(szIdent, "double"))
return TOK_DOUBLE;
return TOK_IDENT;
}
// test for number: decimal (123), octal (0123), or hexadecimal (0x123)
if (isdigit((unsigned char)c)) {
sint64 v = 0;
if (c=='0' && tokstr[0] == 'x') {
// hex (base 16)
++tokstr;
while(isxdigit((unsigned char)(c = *tokstr++))) {
v = v*16 + (strchr(hexdig, toupper(c))-hexdig);
}
} else if (c=='0' && isdigit((unsigned char)tokstr[0])) {
// octal (base 8)
while((c=*tokstr++)>='0' && c<='7')
v = v*8 + (c-'0');
} else {
// check for float
const char *s = tokstr;
while(*s) {
if (*s == '.' || *s == 'e' || *s == 'E') {
// It's a float -- parse and return.
--tokstr;
tokdval = strtod(tokstr, (char **)&tokstr);
return TOK_DBLVAL;
}
if (!isdigit((unsigned char)*s))
break;
++s;
}
// decimal
v = (c-'0');
while(isdigit((unsigned char)(c=*tokstr++)))
v = v*10 + (c-'0');
}
--tokstr;
if (v > 0x7FFFFFFF) {
toklval = v;
return TOK_LONGVAL;
} else {
tokival = (int)v;
return TOK_INTVAL;
}
}
// test for symbols:
//
// charset: +-*/<>=!&|^[]~;%(),
// solitary: +-*/<>=!&|^[]~;%(),
// extra: != <= >= == && ||
//
// the '/' is handled above for comment handling
if (c=='!')
if (tokstr[0] == '=') { ++tokstr; return TOK_NOTEQ; } else return '!';
if (c=='<')
if (tokstr[0] == '=') { ++tokstr; return TOK_LESSEQ; } else return '<';
if (c=='>')
if (tokstr[0] == '=') { ++tokstr; return TOK_GRTREQ; } else return '>';
if (c=='=')
if (tokstr[0] == '=') { ++tokstr; return TOK_EQUALS; } else return '=';
if (c=='&')
if (tokstr[0] == '&') { ++tokstr; return TOK_AND; } else return '&';
if (c=='|')
if (tokstr[0] == '|') { ++tokstr; return TOK_OR; } else return '|';
if (strchr("+-*^[]~;%(),.",c))
return c;
SCRIPT_ERROR(PARSE_ERROR);
}
