static void parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only, int argc, char **argv) { isc_result_t result; isc_textregion_t tr; isc_boolean_t firstarg = ISC_TRUE; dig_lookup_t *lookup = NULL; dns_rdatatype_t rdtype; dns_rdataclass_t rdclass; isc_boolean_t open_type_class = ISC_TRUE; char batchline[MXNAME]; int bargc; char *bargv[64]; int rc; char **rv; #ifndef NOPOSIX char *homedir; char rcfile[256]; #endif char *input; int i; isc_boolean_t need_clone = ISC_TRUE; /* * The semantics for parsing the args is a bit complex; if * we don't have a host yet, make the arg apply globally, * otherwise make it apply to the latest host. This is * a bit different than the previous versions, but should * form a consistent user interface. * * First, create a "default lookup" which won't actually be used * anywhere, except for cloning into new lookups */ debug("parse_args()"); if (!is_batchfile) { debug("making new lookup"); default_lookup = make_empty_lookup(); default_lookup->adflag = ISC_TRUE; default_lookup->edns = 0; #ifndef NOPOSIX /* * Treat ${HOME}/.digrc as a special batchfile */ INSIST(batchfp == NULL); homedir = getenv("HOME"); if (homedir != NULL) { unsigned int n; n = snprintf(rcfile, sizeof(rcfile), "%s/.digrc", homedir); if (n < sizeof(rcfile)) batchfp = fopen(rcfile, "r"); } if (batchfp != NULL) { while (fgets(batchline, sizeof(batchline), batchfp) != 0) { debug("config line %s", batchline); bargc = 1; input = batchline; bargv[bargc] = next_token(&input, " \t\r\n"); while ((bargv[bargc] != NULL) && (bargc < 62)) { bargc++; bargv[bargc] = next_token(&input, " \t\r\n"); } bargv[0] = argv[0]; argv0 = argv[0]; for(i = 0; i < bargc; i++) debug(".digrc argv %d: %s", i, bargv[i]); parse_args(ISC_TRUE, ISC_TRUE, bargc, (char **)bargv); } fclose(batchfp); } #endif } if (is_batchfile && !config_only) { /* Processing '-f batchfile'. */ lookup = clone_lookup(default_lookup, ISC_TRUE); need_clone = ISC_FALSE; } else lookup = default_lookup; rc = argc; rv = argv; for (rc--, rv++; rc > 0; rc--, rv++) { debug("main parsing %s", rv[0]); if (strncmp(rv[0], "%", 1) == 0) break; if (strncmp(rv[0], "@", 1) == 0) { addresscount = getaddresses(lookup, &rv[0][1], NULL); } else if (rv[0][0] == '+') { plus_option(&rv[0][1], is_batchfile, lookup); } else if (rv[0][0] == '-') { if (rc <= 1) { if (dash_option(&rv[0][1], NULL, &lookup, &open_type_class, &need_clone, config_only, argc, argv, &firstarg)) { rc--; rv++; } } else { if (dash_option(&rv[0][1], rv[1], &lookup, &open_type_class, &need_clone, config_only, argc, argv, &firstarg)) { rc--; rv++; } } } else { /* * Anything which isn't an option */ if (open_type_class) { if (strncasecmp(rv[0], "ixfr=", 5) == 0) { rdtype = dns_rdatatype_ixfr; result = ISC_R_SUCCESS; } else { tr.base = rv[0]; tr.length = strlen(rv[0]); result = dns_rdatatype_fromtext(&rdtype, (isc_textregion_t *)&tr); if (result == ISC_R_SUCCESS && rdtype == dns_rdatatype_ixfr) { fprintf(stderr, ";; Warning, " "ixfr requires a " "serial number\n"); continue; } } if (result == ISC_R_SUCCESS) { if (lookup->rdtypeset) { fprintf(stderr, ";; Warning, " "extra type option\n"); } if (rdtype == dns_rdatatype_ixfr) { isc_uint32_t serial; lookup->rdtype = dns_rdatatype_ixfr; lookup->rdtypeset = ISC_TRUE; result = parse_uint(&serial, &rv[0][5], MAXSERIAL, "serial number"); if (result != ISC_R_SUCCESS) fatal("Couldn't parse " "serial number"); lookup->ixfr_serial = serial; lookup->section_question = plusquest; lookup->comments = pluscomm; lookup->tcp_mode = ISC_TRUE; } else { lookup->rdtype = rdtype; lookup->rdtypeset = ISC_TRUE; if (rdtype == dns_rdatatype_axfr) { lookup->section_question = plusquest; lookup->comments = pluscomm; } lookup->ixfr_serial = ISC_FALSE; } continue; } result = dns_rdataclass_fromtext(&rdclass, (isc_textregion_t *)&tr); if (result == ISC_R_SUCCESS) { if (lookup->rdclassset) { fprintf(stderr, ";; Warning, " "extra class option\n"); } lookup->rdclass = rdclass; lookup->rdclassset = ISC_TRUE; continue; } } if (!config_only) { if (need_clone) lookup = clone_lookup(default_lookup, ISC_TRUE); need_clone = ISC_TRUE; strncpy(lookup->textname, rv[0], sizeof(lookup->textname)); lookup->textname[sizeof(lookup->textname)-1]=0; lookup->trace_root = ISC_TF(lookup->trace || lookup->ns_search_only); lookup->new_search = ISC_TRUE; if (firstarg) { printgreeting(argc, argv, lookup); firstarg = ISC_FALSE; } ISC_LIST_APPEND(lookup_list, lookup, link); debug("looking up %s", lookup->textname); } /* XXX Error message */ } } /* * If we have a batchfile, seed the lookup list with the * first entry, then trust the callback in dighost_shutdown * to get the rest */ if ((batchname != NULL) && !(is_batchfile)) { if (strcmp(batchname, "-") == 0) batchfp = stdin; else batchfp = fopen(batchname, "r"); if (batchfp == NULL) { perror(batchname); if (exitcode < 8) exitcode = 8; fatal("couldn't open specified batch file"); } /* XXX Remove code dup from shutdown code */ next_line: if (fgets(batchline, sizeof(batchline), batchfp) != 0) { bargc = 1; debug("batch line %s", batchline); if (batchline[0] == '\r' || batchline[0] == '\n' || batchline[0] == '#' || batchline[0] == ';') goto next_line; input = batchline; bargv[bargc] = next_token(&input, " \t\r\n"); while ((bargv[bargc] != NULL) && (bargc < 14)) { bargc++; bargv[bargc] = next_token(&input, " \t\r\n"); } bargv[0] = argv[0]; argv0 = argv[0]; for(i = 0; i < bargc; i++) debug("batch argv %d: %s", i, bargv[i]); parse_args(ISC_TRUE, ISC_FALSE, bargc, (char **)bargv); return; } return; } /* * If no lookup specified, search for root */ if ((lookup_list.head == NULL) && !config_only) { if (need_clone) lookup = clone_lookup(default_lookup, ISC_TRUE); need_clone = ISC_TRUE; lookup->trace_root = ISC_TF(lookup->trace || lookup->ns_search_only); lookup->new_search = ISC_TRUE; strcpy(lookup->textname, "."); lookup->rdtype = dns_rdatatype_ns; lookup->rdtypeset = ISC_TRUE; if (firstarg) { printgreeting(argc, argv, lookup); firstarg = ISC_FALSE; } ISC_LIST_APPEND(lookup_list, lookup, link); } if (!need_clone) destroy_lookup(lookup); }
static void append_driver_list_table(const char *header, const astring *dirname, core_file *indexfile, const summary_file *listhead, const astring *tempheader, const astring *tempfooter) { const summary_file *curfile, *prevfile; int width = 100 / (2 + list_count); int listnum; /* output a header */ core_fprintf(indexfile, "\t<h2>%s</h2>\n", header); /* start the table */ core_fprintf(indexfile, "\t<p><table width=\"90%%\">\n"); core_fprintf(indexfile, "\t\t<tr>\n\t\t\t<th width=\"%d%%\">Source</th><th width=\"%d%%\">Driver</th>", width, width); for (listnum = 0; listnum < list_count; listnum++) core_fprintf(indexfile, "<th width=\"%d%%\">%s</th>", width, lists[listnum].version); core_fprintf(indexfile, "\n\t\t</tr>\n"); /* if nothing, print a default message */ if (listhead == NULL) { core_fprintf(indexfile, "\t\t<tr>\n\t\t\t"); core_fprintf(indexfile, "<td colspan=\"%d\" align=\"center\">(No regressions detected)</td>", list_count + 2); core_fprintf(indexfile, "\n\t\t</tr>\n"); } /* iterate over files */ for (prevfile = NULL, curfile = listhead; curfile != NULL; prevfile = curfile, curfile = curfile->next) { int rowspan = 0, uniqueshots = 0; char pngdiffname[40]; /* if this is the first entry in this source file, count how many rows we need to span */ if (prevfile == NULL || strcmp(prevfile->source, curfile->source) != 0) { const summary_file *cur; for (cur = curfile; cur != NULL; cur = cur->next) if (strcmp(cur->source, curfile->source) == 0) rowspan++; else break; } /* create screenshots if necessary */ pngdiffname[0] = 0; for (listnum = 0; listnum < list_count; listnum++) if (curfile->matchbitmap[listnum] == listnum) uniqueshots++; if (uniqueshots > 1) { sprintf(pngdiffname, "compare_%s.png", curfile->name); if (generate_png_diff(curfile, dirname, pngdiffname) != 0) pngdiffname[0] = 0; } /* create a linked file */ create_linked_file(dirname, curfile, prevfile, curfile->next, (pngdiffname[0] == 0) ? NULL : pngdiffname, tempheader, tempfooter); /* create a row */ core_fprintf(indexfile, "\t\t<tr>\n\t\t\t"); if (rowspan > 0) core_fprintf(indexfile, "<td rowspan=\"%d\">%s</td>", rowspan, curfile->source); core_fprintf(indexfile, "<td><a href=\"%s.html\">%s</a></td>", curfile->name, curfile->name); for (listnum = 0; listnum < list_count; listnum++) { int unique_index = -1; if (pngdiffname[0] != 0) unique_index = get_unique_index(curfile, listnum); if (unique_index != -1) core_fprintf(indexfile, "<td><span style=\"%s\"> </span> %s [<a href=\"%s\" target=\"blank\">%d</a>]</td>", status_color[curfile->status[listnum]], status_text[curfile->status[listnum]], pngdiffname, unique_index); else core_fprintf(indexfile, "<td><span style=\"%s\"> </span> %s</td>", status_color[curfile->status[listnum]], status_text[curfile->status[listnum]]); } core_fprintf(indexfile, "\n\t\t</tr>\n"); /* also print the name and source file */ printf("%s %s\n", curfile->name, curfile->source); } /* end of table */ core_fprintf(indexfile, "</table></p>\n"); }
static void PrDoDirective ( char *DirectiveToken, char **Next) { char *Token = AslGbl_MainTokenBuffer; char *Token2 = NULL; char *End; UINT64 Value; ACPI_SIZE TokenOffset; int Directive; ACPI_STATUS Status; if (!DirectiveToken) { goto SyntaxError; } Directive = PrMatchDirective (DirectiveToken); if (Directive == ASL_DIRECTIVE_NOT_FOUND) { PrError (ASL_ERROR, ASL_MSG_UNKNOWN_DIRECTIVE, THIS_TOKEN_OFFSET (DirectiveToken)); DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID "#%s: Unknown directive\n", AslGbl_CurrentLineNumber, DirectiveToken); return; } /* * Emit a line directive into the preprocessor file (.pre) after * every matched directive. This is passed through to the compiler * so that error/warning messages are kept in sync with the * original source file. */ FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\" // #%s\n", AslGbl_CurrentLineNumber, AslGbl_Files[ASL_FILE_INPUT].Filename, AslGbl_DirectiveInfo[Directive].Name); /* * If we are currently ignoring this block and we encounter a #else or * #elif, we must ignore their blocks also if the parent block is also * being ignored. */ if (AslGbl_IgnoringThisCodeBlock) { switch (Directive) { case PR_DIRECTIVE_ELSE: case PR_DIRECTIVE_ELIF: if (AslGbl_DirectiveStack && AslGbl_DirectiveStack->IgnoringThisCodeBlock) { PrDbgPrint ("Ignoring", AslGbl_DirectiveInfo[Directive].Name); return; } break; default: break; } } /* * Need to always check for #else, #elif, #endif regardless of * whether we are ignoring the current code block, since these * are conditional code block terminators. */ switch (Directive) { case PR_DIRECTIVE_ELSE: AslGbl_IgnoringThisCodeBlock = !(AslGbl_IgnoringThisCodeBlock); PrDbgPrint ("Executing", "else block"); return; case PR_DIRECTIVE_ELIF: AslGbl_IgnoringThisCodeBlock = !(AslGbl_IgnoringThisCodeBlock); Directive = PR_DIRECTIVE_IF; if (AslGbl_IgnoringThisCodeBlock == TRUE) { /* Not executing the ELSE part -- all done here */ PrDbgPrint ("Ignoring", "elif block"); return; } /* * After this, we will execute the IF part further below. * First, however, pop off the original #if directive. */ if (ACPI_FAILURE (PrPopDirective ())) { PrError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, THIS_TOKEN_OFFSET (DirectiveToken)); } PrDbgPrint ("Executing", "elif block"); break; case PR_DIRECTIVE_ENDIF: PrDbgPrint ("Executing", "endif"); /* Pop the owning #if/#ifdef/#ifndef */ if (ACPI_FAILURE (PrPopDirective ())) { PrError (ASL_ERROR, ASL_MSG_ENDIF_MISMATCH, THIS_TOKEN_OFFSET (DirectiveToken)); } return; default: break; } /* Most directives have at least one argument */ if (AslGbl_DirectiveInfo[Directive].ArgCount >= 1) { Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next); if (!Token) { goto SyntaxError; } } if (AslGbl_DirectiveInfo[Directive].ArgCount >= 2) { Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next); if (!Token2) { goto SyntaxError; } } /* * At this point, if we are ignoring the current code block, * do not process any more directives (i.e., ignore them also.) * For "if" style directives, open/push a new block anyway. We * must do this to keep track of #endif directives */ if (AslGbl_IgnoringThisCodeBlock) { switch (Directive) { case PR_DIRECTIVE_IF: case PR_DIRECTIVE_IFDEF: case PR_DIRECTIVE_IFNDEF: PrPushDirective (Directive, Token); PrDbgPrint ("Ignoring", AslGbl_DirectiveInfo[Directive].Name); break; default: break; } return; } /* * Execute the directive */ PrDbgPrint ("Begin execution", AslGbl_DirectiveInfo[Directive].Name); switch (Directive) { case PR_DIRECTIVE_IF: TokenOffset = Token - AslGbl_MainTokenBuffer; /* Need to expand #define macros in the expression string first */ Status = PrResolveIntegerExpression ( &AslGbl_CurrentLineBuffer[TokenOffset-1], &Value); if (ACPI_FAILURE (Status)) { return; } PrPushDirective (Directive, Token); if (!Value) { AslGbl_IgnoringThisCodeBlock = TRUE; } DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID "Resolved #if: %8.8X%8.8X %s\n", AslGbl_CurrentLineNumber, ACPI_FORMAT_UINT64 (Value), AslGbl_IgnoringThisCodeBlock ? "<Skipping Block>" : "<Executing Block>"); break; case PR_DIRECTIVE_IFDEF: PrPushDirective (Directive, Token); if (!PrMatchDefine (Token)) { AslGbl_IgnoringThisCodeBlock = TRUE; } PrDbgPrint ("Evaluated", "ifdef"); break; case PR_DIRECTIVE_IFNDEF: PrPushDirective (Directive, Token); if (PrMatchDefine (Token)) { AslGbl_IgnoringThisCodeBlock = TRUE; } PrDbgPrint ("Evaluated", "ifndef"); break; case PR_DIRECTIVE_DEFINE: /* * By definition, if first char after the name is a paren, * this is a function macro. */ TokenOffset = Token - AslGbl_MainTokenBuffer + strlen (Token); if (*(&AslGbl_CurrentLineBuffer[TokenOffset]) == '(') { #ifndef MACROS_SUPPORTED AcpiOsPrintf ( "%s ERROR - line %u: #define macros are not supported yet\n", AslGbl_CurrentLineBuffer, AslGbl_LogicalLineNumber); exit(1); #else PrAddMacro (Token, Next); #endif } else { /* Use the remainder of the line for the #define */ Token2 = *Next; if (Token2) { while ((*Token2 == ' ') || (*Token2 == '\t')) { Token2++; } End = Token2; while (*End != '\n') { End++; } *End = 0; } else { Token2 = ""; } #if 0 Token2 = PrGetNextToken (NULL, "\n", /*PR_TOKEN_SEPARATORS,*/ Next); if (!Token2) { Token2 = ""; } #endif DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID "New #define: %s->%s\n", AslGbl_LogicalLineNumber, Token, Token2); PrAddDefine (Token, Token2, FALSE); } break; case PR_DIRECTIVE_ERROR: /* Note: No macro expansion */ PrError (ASL_ERROR, ASL_MSG_ERROR_DIRECTIVE, THIS_TOKEN_OFFSET (Token)); AslGbl_SourceLine = 0; AslGbl_NextError = AslGbl_ErrorLog; CmCleanupAndExit (); exit(1); case PR_DIRECTIVE_INCLUDE: Token = PrGetNextToken (NULL, " \"<>", Next); if (!Token) { goto SyntaxError; } DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID "Start #include file \"%s\"\n", AslGbl_CurrentLineNumber, Token, AslGbl_CurrentLineNumber); PrDoIncludeFile (Token); break; case PR_DIRECTIVE_INCLUDEBUFFER: Token = PrGetNextToken (NULL, " \"<>", Next); if (!Token) { goto SyntaxError; } Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next); if (!Token2) { goto SyntaxError; } DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID "Start #includebuffer input from file \"%s\", buffer name %s\n", AslGbl_CurrentLineNumber, Token, Token2); PrDoIncludeBuffer (Token, Token2); break; case PR_DIRECTIVE_LINE: TokenOffset = Token - AslGbl_MainTokenBuffer; Status = PrResolveIntegerExpression ( &AslGbl_CurrentLineBuffer[TokenOffset-1], &Value); if (ACPI_FAILURE (Status)) { return; } DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID "User #line invocation %s\n", AslGbl_CurrentLineNumber, Token); AslGbl_CurrentLineNumber = (UINT32) Value; /* Emit #line into the preprocessor file */ FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n", AslGbl_CurrentLineNumber, AslGbl_Files[ASL_FILE_INPUT].Filename); break; case PR_DIRECTIVE_PRAGMA: if (!strcmp (Token, "disable")) { Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next); if (!Token) { goto SyntaxError; } TokenOffset = Token - AslGbl_MainTokenBuffer; AslDisableException (&AslGbl_CurrentLineBuffer[TokenOffset]); } else if (!strcmp (Token, "message")) { Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next); if (!Token) { goto SyntaxError; } TokenOffset = Token - AslGbl_MainTokenBuffer; AcpiOsPrintf ("%s\n", &AslGbl_CurrentLineBuffer[TokenOffset]); } else { PrError (ASL_ERROR, ASL_MSG_UNKNOWN_PRAGMA, THIS_TOKEN_OFFSET (Token)); return; } break; case PR_DIRECTIVE_UNDEF: DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID "#undef: %s\n", AslGbl_CurrentLineNumber, Token); PrRemoveDefine (Token); break; case PR_DIRECTIVE_WARNING: PrError (ASL_WARNING, ASL_MSG_WARNING_DIRECTIVE, THIS_TOKEN_OFFSET (Token)); AslGbl_SourceLine = 0; AslGbl_NextError = AslGbl_ErrorLog; break; default: /* Should never get here */ DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID "Unrecognized directive: %u\n", AslGbl_CurrentLineNumber, Directive); break; } return; SyntaxError: PrError (ASL_ERROR, ASL_MSG_DIRECTIVE_SYNTAX, THIS_TOKEN_OFFSET (DirectiveToken)); return; }
int main(int argc, char** argv) { IplImage* img = NULL; IplImage* dst = NULL; IplImage* dst2 = NULL; IplImage* dst3 = NULL; IplImage* dst4 = NULL; IplImage* dst5 = NULL; char* cha = "./temp/";//le dossier de base DIR* rep = NULL; struct dirent* fichierLu = NULL; /* Déclaration d'un pointeur vers la structure dirent. */ struct dirent* repLu = NULL; /* Déclaration d'un pointeur vers la structure dirent. */ char* ch; rep = opendir(cha); if (rep == NULL) { exit(1); } while((repLu = readdir(rep)) != NULL ) { while (strcmp(repLu->d_name, ".") == 0 || strcmp(repLu->d_name, "..") == 0) { repLu = readdir(rep); printf("%s\n",repLu->d_name); } DIR* rep2 = NULL; ch = concat(cha,repLu->d_name); rep2 = opendir(ch); char* c = ch; c = concat(ch,"/"); while ((fichierLu = readdir(rep2)) != NULL ) { if (strcmp(fichierLu->d_name, ".") != 0 && strcmp(fichierLu->d_name, "..") != 0) { printf("Le fichier lu s'appelle %s\n", fichierLu->d_name); ch = concat(c,fichierLu->d_name); img = cvLoadImage( ch , CV_LOAD_IMAGE_COLOR); if (img == NULL) { printf("Oups j'ai eu un problème.\n"); return -1; } IplImage *hsv; hsv = cvCloneImage(img); cvCvtColor(img, hsv, CV_BGR2HSV); IplImage *hsv2; hsv2 = cvCloneImage(img); cvCvtColor(img, hsv2, CV_BGR2HSV); IplImage *hsv3; hsv3 = cvCloneImage(img); cvCvtColor(img, hsv3, CV_BGR2HSV); IplImage *maskrouge; maskrouge = cvCreateImage(cvGetSize(img), img->depth, 1); IplImage *maskbleu; maskbleu = cvCreateImage(cvGetSize(img), img->depth, 1); IplImage *maskblanc; maskblanc = cvCreateImage(cvGetSize(img), img->depth, 1); int h1=0, s1=200, v1= 80; int h2=106, s2=138; int h3=350, s3=83; cvInRangeS(hsv, cvScalar(h1 -tolerance, s1 - tolerance, v1 - tolerance, 0.0), cvScalar(h1 + tolerance, s1 + tolerance, v1 + tolerance, 0.0), maskrouge); cvInRangeS(hsv2, cvScalar(h2 -tolerance, s2 - tolerance, 0, 0.0), cvScalar(h2 + tolerance, s2 + tolerance, 255, 0.0), maskbleu); cvInRangeS(hsv3, cvScalar(h3 -tolerance, s3 - tolerance, 0, 0.0), cvScalar(h3 + tolerance, s3 + tolerance, 255, 0.0), maskblanc); //IplConvKernel *kernel; //kernel = cvCreateStructuringElementEx(5, 5, 2, 2, CV_SHAPE_ELLIPSE, NULL); //cvDilate(maskrouge, maskrouge, kernel, 1); //cvDilate(maskbleu, maskbleu, kernel, 1); //cvDilate(maskblanc, maskblanc, kernel, 1);cvDilate(maskrouge, maskrouge, kernel, 1); //cvDilate(maskbleu, maskbleu, kernel, 1); //cvDilate(maskblanc, maskblanc, kernel, 1); //cvErode(maskrouge, maskrouge, kernel, 1); // affichage dst = cvCreateImage(cvSize( img->width / 6, img->height / 6 ), img->depth,img->nChannels ); dst2 = cvCreateImage(cvSize( maskrouge->width / 6, maskrouge->height / 6 ), maskrouge->depth,maskrouge->nChannels ); dst3 = cvCreateImage(cvSize( maskbleu->width / 6, maskbleu->height / 6 ), maskbleu->depth,maskbleu->nChannels ); dst4 = cvCreateImage(cvSize( maskblanc->width / 6, maskblanc->height / 6 ), maskblanc->depth,maskblanc->nChannels ); //dst5 = cvCreateImage(cvSize( hsv->width / 2, hsv->height / 2 ), hsv->depth, hsv->nChannels ); cvResize(img, dst, CV_INTER_AREA ); cvResize(maskrouge, dst2, CV_INTER_AREA ); cvResize(maskbleu, dst3, CV_INTER_AREA ); cvResize(maskblanc, dst4, CV_INTER_AREA ); //cvResize(hsv, dst5, CV_INTER_AREA ); cvShowImage("test1",dst); cvShowImage("test2",dst2); cvShowImage("test3",dst3); cvShowImage("test4",dst4); //cvShowImage("test5",dst5); cvMoveWindow("test1" ,0,0); cvMoveWindow("test2" ,dst->width,dst->height+60); cvMoveWindow("test3" ,dst->width,0); cvMoveWindow("test4" ,0,dst->height+60); //cvMoveWindow("test5" , 0, 0); cvWaitKey(0); cvReleaseImage(&maskrouge); cvReleaseImage(&maskbleu); cvReleaseImage(&maskblanc); cvReleaseImage(&hsv); cvReleaseImage(&hsv2); cvReleaseImage(&hsv3); cvReleaseImage(&img); cvReleaseImage(&dst); cvReleaseImage(&dst2); cvReleaseImage(&dst3); cvReleaseImage(&dst4); cvReleaseImage(&dst5); cvDestroyWindow("test1"); cvDestroyWindow("test2"); cvDestroyWindow("test3"); cvDestroyWindow("test4"); //cvDestroyWindow("test5"); } } } if (closedir(rep) == -1) exit(-1); return 0; }
int main(int argc, char *argv[]) { struct test_case *tc; FILE *input_file; int i; if (argc != 2) { ovs_fatal(0, "usage: test-stp INPUT.STP\n"); } file_name = argv[1]; input_file = fopen(file_name, "r"); if (!input_file) { ovs_fatal(errno, "error opening \"%s\"", file_name); } tc = new_test_case(); for (i = 0; i < 26; i++) { char name[2]; name[0] = 'a' + i; name[1] = '\0'; new_lan(tc, name); } for (line_number = 1; fgets(line, sizeof line, input_file); line_number++) { char *newline, *hash; newline = strchr(line, '\n'); if (newline) { *newline = '\0'; } hash = strchr(line, '#'); if (hash) { *hash = '\0'; } pos = line; if (!get_token()) { continue; } if (match("bridge")) { struct bridge *bridge; int bridge_no, port_no; bridge_no = must_get_int(); if (bridge_no < tc->n_bridges) { bridge = tc->bridges[bridge_no]; } else if (bridge_no == tc->n_bridges) { bridge = new_bridge(tc, must_get_int()); } else { err("bridges must be numbered consecutively from 0"); } if (match("^")) { stp_set_bridge_priority(bridge->stp, must_get_int()); } if (match("=")) { for (port_no = 0; port_no < STP_MAX_PORTS; port_no++) { struct stp_port *p = stp_get_port(bridge->stp, port_no); if (!token || match("X")) { stp_port_disable(p); } else if (match("_")) { /* Nothing to do. */ } else { struct lan *lan; int path_cost; if (!strcmp(token, "0")) { lan = NULL; } else if (strlen(token) == 1 && islower((unsigned char)*token)) { lan = tc->lans[*token - 'a']; } else { err("%s is not a valid LAN name " "(0 or a lowercase letter)", token); } get_token(); path_cost = match(":") ? must_get_int() : 10; if (port_no < bridge->n_ports) { stp_port_set_path_cost(p, path_cost); stp_port_enable(p); reconnect_port(bridge, port_no, lan); } else if (port_no == bridge->n_ports) { new_port(bridge, lan, path_cost); } else { err("ports must be numbered consecutively"); } if (match("^")) { stp_port_set_priority(p, must_get_int()); } } } } } else if (match("run")) { simulate(tc, must_get_int()); } else if (match("dump")) { dump(tc); } else if (match("tree")) { tree(tc); } else if (match("check")) { struct bridge *b; struct stp *stp; int bridge_no, port_no; bridge_no = must_get_int(); if (bridge_no >= tc->n_bridges) { err("no bridge numbered %d", bridge_no); } b = tc->bridges[bridge_no]; stp = b->stp; must_match("="); if (match("rootid")) { uint64_t rootid; must_match(":"); rootid = must_get_int(); if (match("^")) { rootid |= (uint64_t) must_get_int() << 48; } else { rootid |= UINT64_C(0x8000) << 48; } if (stp_get_designated_root(stp) != rootid) { warn("%s: root %"PRIx64", not %"PRIx64, stp_get_name(stp), stp_get_designated_root(stp), rootid); } } if (match("root")) { if (stp_get_root_path_cost(stp)) { warn("%s: root path cost of root is %u but should be 0", stp_get_name(stp), stp_get_root_path_cost(stp)); } if (!stp_is_root_bridge(stp)) { warn("%s: root is %"PRIx64", not %"PRIx64, stp_get_name(stp), stp_get_designated_root(stp), stp_get_bridge_id(stp)); } for (port_no = 0; port_no < b->n_ports; port_no++) { struct stp_port *p = stp_get_port(stp, port_no); enum stp_state state = stp_port_get_state(p); if (!(state & (STP_DISABLED | STP_FORWARDING))) { warn("%s: root port %d in state %s", stp_get_name(b->stp), port_no, stp_state_name(state)); } } } else { for (port_no = 0; port_no < STP_MAX_PORTS; port_no++) { struct stp_port *p = stp_get_port(stp, port_no); enum stp_state state; if (token == NULL || match("D")) { state = STP_DISABLED; } else if (match("B")) { state = STP_BLOCKING; } else if (match("Li")) { state = STP_LISTENING; } else if (match("Le")) { state = STP_LEARNING; } else if (match("F")) { state = STP_FORWARDING; } else if (match("_")) { continue; } else { err("unknown port state %s", token); } if (stp_port_get_state(p) != state) { warn("%s port %d: state is %s but should be %s", stp_get_name(stp), port_no, stp_state_name(stp_port_get_state(p)), stp_state_name(state)); } if (state == STP_FORWARDING) { struct stp_port *root_port = stp_get_root_port(stp); if (match(":")) { int root_path_cost = must_get_int(); if (p != root_port) { warn("%s: port %d is not the root port", stp_get_name(stp), port_no); if (!root_port) { warn("%s: (there is no root port)", stp_get_name(stp)); } else { warn("%s: (port %d is the root port)", stp_get_name(stp), stp_port_no(root_port)); } } else if (root_path_cost != stp_get_root_path_cost(stp)) { warn("%s: root path cost is %u, should be %d", stp_get_name(stp), stp_get_root_path_cost(stp), root_path_cost); } } else if (p == root_port) { warn("%s: port %d is the root port but " "not expected to be", stp_get_name(stp), port_no); } } } } if (n_warnings) { exit(EXIT_FAILURE); } } if (get_token()) { err("trailing garbage on line"); } } free(token); for (i = 0; i < tc->n_lans; i++) { struct lan *lan = tc->lans[i]; free((char *) lan->name); free(lan); } for (i = 0; i < tc->n_bridges; i++) { struct bridge *bridge = tc->bridges[i]; stp_destroy(bridge->stp); free(bridge); } free(tc); return 0; }
/* format a JSON object */ static void format_json_key(FILE *fp, mj_t *obj, const int psigs) { int64_t birthtime; int64_t duration; time_t now; char tbuf[32]; char *s; mj_t *sub; int i; if (pgp_get_debug_level(__FILE__)) { mj_asprint(&s, obj, MJ_HUMAN); (void) fprintf(stderr, "formatobj: json is '%s'\n", s); free(s); } if (obj->c == 2 && obj->value.v[1].type == MJ_STRING && strcmp(obj->value.v[1].value.s, "[REVOKED]") == 0) { /* whole key has been rovoked - just return */ return; } pobj(fp, &obj->value.v[mj_object_find(obj, "header", 0, 2) + 1], 0); p(fp, " ", NULL); pobj(fp, &obj->value.v[mj_object_find(obj, "key bits", 0, 2) + 1], 0); p(fp, "/", NULL); pobj(fp, &obj->value.v[mj_object_find(obj, "pka", 0, 2) + 1], 0); p(fp, " ", NULL); pobj(fp, &obj->value.v[mj_object_find(obj, "key id", 0, 2) + 1], 0); birthtime = (int64_t)strtoll(obj->value.v[mj_object_find(obj, "birthtime", 0, 2) + 1].value.s, NULL, 10); p(fp, " ", ptimestr(tbuf, sizeof(tbuf), birthtime), NULL); duration = (int64_t)strtoll(obj->value.v[mj_object_find(obj, "duration", 0, 2) + 1].value.s, NULL, 10); if (duration > 0) { now = time(NULL); p(fp, " ", (birthtime + duration < now) ? "[EXPIRED " : "[EXPIRES ", ptimestr(tbuf, sizeof(tbuf), birthtime + duration), "]", NULL); } p(fp, "\n", "Key fingerprint: ", NULL); pobj(fp, &obj->value.v[mj_object_find(obj, "fingerprint", 0, 2) + 1], 0); p(fp, "\n", NULL); /* go to field after \"duration\" */ for (i = mj_object_find(obj, "duration", 0, 2) + 2; i < mj_arraycount(obj) ; i += 2) { if (strcmp(obj->value.v[i].value.s, "uid") == 0) { sub = &obj->value.v[i + 1]; p(fp, "uid", NULL); pobj(fp, &sub->value.v[0], (psigs) ? 4 : 14); /* human name */ pobj(fp, &sub->value.v[1], 1); /* any revocation */ p(fp, "\n", NULL); } else if (strcmp(obj->value.v[i].value.s, "encryption") == 0) { sub = &obj->value.v[i + 1]; p(fp, "encryption", NULL); pobj(fp, &sub->value.v[0], 1); /* size */ p(fp, "/", NULL); pobj(fp, &sub->value.v[1], 0); /* alg */ p(fp, " ", NULL); pobj(fp, &sub->value.v[2], 0); /* id */ p(fp, " ", ptimestr(tbuf, sizeof(tbuf), (time_t)strtoll(sub->value.v[3].value.s, NULL, 10)), "\n", NULL); } else if (strcmp(obj->value.v[i].value.s, "sig") == 0) { sub = &obj->value.v[i + 1]; p(fp, "sig", NULL); pobj(fp, &sub->value.v[0], 8); /* size */ p(fp, " ", ptimestr(tbuf, sizeof(tbuf), (time_t)strtoll(sub->value.v[1].value.s, NULL, 10)), " ", NULL); /* time */ pobj(fp, &sub->value.v[2], 0); /* human name */ p(fp, "\n", NULL); } else { fprintf(stderr, "weird '%s'\n", obj->value.v[i].value.s); pobj(fp, &obj->value.v[i], 0); /* human name */ } } p(fp, "\n", NULL); }
static void grok_node(struct cfg_comp *c, merlin_node *node) { unsigned int i; int sel_id = -1; if (!node) return; switch (node->type) { case MODE_NOC: node->flags = MERLIN_NODE_DEFAULT_MASTER_FLAGS; break; case MODE_PEER: node->flags = MERLIN_NODE_DEFAULT_PEER_FLAGS; break; case MODE_POLLER: node->flags = MERLIN_NODE_DEFAULT_POLLER_FLAGS; break; } node->data_timeout = pulse_interval * 2; /* a sane default */ for (i = 0; i < c->vars; i++) { struct cfg_var *v = c->vlist[i]; if (!v->value) cfg_error(c, v, "Variable must have a value\n"); if (node->type != MODE_NOC && (!strcmp(v->key, "hostgroup") || !strcmp(v->key, "hostgroups"))) { sel_id = add_selection(v->value, node); } else if (!strcmp(v->key, "address") || !strcmp(v->key, "host")) { if (resolve(v->value, &node->sain.sin_addr) < 0) cfg_error(c, v, "Unable to resolve '%s'\n", v->value); } else if (!strcmp(v->key, "port")) { node->sain.sin_port = htons((unsigned short)atoi(v->value)); if (!node->sain.sin_port) cfg_error(c, v, "Illegal value for port: %s\n", v->value); } else if (!strcmp(v->key, "data_timeout")) { char *endptr; node->data_timeout = (unsigned int)strtol(v->value, &endptr, 10); if (*endptr != 0) cfg_error(c, v, "Illegal value for data_timeout: %s\n", v->value); } else if (grok_node_flag(&node->flags, v->key, v->value) < 0) { cfg_error(c, v, "Unknown variable\n"); } } for (i = 0; i < c->nested; i++) { struct cfg_comp *comp = c->nest[i]; if (!strcmp(comp->name, "object_config")) { node->csync = calloc(1, sizeof(*node->csync)); if (!node->csync) cfg_error(comp, NULL, "Failed to allocate memory for confsync struct"); grok_confsync_compound(comp, node->csync); continue; } /* this is for 'mon oconf push' only */ if (!strcmp(comp->name, "sync")) { continue; } cfg_error(comp, NULL, "Unknown compound statement in node object"); } node->last_action = -1; if (node->type == MODE_POLLER && sel_id == -1) { cfg_error(c, NULL, "Missing 'hostgroup' variable in poller definition\n"); } }
int process_mic_status( struct pbsnode *pnode, char **str_ptr) { char *str = *str_ptr; int rc = PBSE_NONE; pbs_attribute temp; int mic_count = 0; dynamic_string *single_mic_status = get_dynamic_string(-1, NULL); char mic_id_buf[MAXLINE]; memset(&temp, 0, sizeof(temp)); if ((rc = decode_arst(&temp, NULL, NULL, NULL, 0)) != PBSE_NONE) { log_record(PBSEVENT_DEBUG, PBS_EVENTCLASS_NODE, __func__, "cannot initialize attribute"); *str_ptr = move_past_mic_status(str); return(rc); } for (str = str + strlen(str) + 1; str != NULL && str[0] != '\0'; str += strlen(str) + 1) { if (!strcmp(str, END_MIC_STATUS)) break; if (!strncmp(str, "mic_id=", strlen("mic_id="))) { if ((rc = save_single_mic_status(single_mic_status, &temp)) != PBSE_NONE) break; snprintf(mic_id_buf, sizeof(mic_id_buf), "mic[%d]=%s", mic_count, str); append_dynamic_string(single_mic_status, mic_id_buf); mic_count++; } else { append_char_to_dynamic_string(single_mic_status, ';'); append_dynamic_string(single_mic_status, str); } } rc = save_single_mic_status(single_mic_status, &temp); if (mic_count > pnode->nd_nmics) { pnode->nd_nmics_free += mic_count - pnode->nd_nmics; pnode->nd_nmics = mic_count; if (mic_count > pnode->nd_nmics_alloced) { struct jobinfo *tmp = (struct jobinfo *)calloc(mic_count, sizeof(struct jobinfo)); if (tmp == NULL) return(ENOMEM); memcpy(tmp, pnode->nd_micjobs, sizeof(struct jobinfo) * pnode->nd_nmics_alloced); free(pnode->nd_micjobs); pnode->nd_micjobs = tmp; pnode->nd_nmics_alloced = mic_count; } } *str_ptr = move_past_mic_status(str); node_micstatus_list(&temp, pnode, ATR_ACTION_ALTER); return(rc); } /* END process_mic_status() */
int process_status_info( char *nd_name, dynamic_string *status_info) { char *str; char *name = nd_name; struct pbsnode *current; long mom_job_sync = FALSE; long auto_np = FALSE; long down_on_error = FALSE; int dont_change_state = FALSE; pbs_attribute temp; int rc = PBSE_NONE; int send_hello = FALSE; get_svr_attr_l(SRV_ATR_MomJobSync, &mom_job_sync); get_svr_attr_l(SRV_ATR_AutoNodeNP, &auto_np); get_svr_attr_l(SRV_ATR_DownOnError, &down_on_error); /* Before filling the "temp" pbs_attribute, initialize it. * The second and third parameter to decode_arst are never * used, so just leave them empty. (GBS) */ memset(&temp, 0, sizeof(temp)); if ((rc = decode_arst(&temp, NULL, NULL, NULL, 0)) != PBSE_NONE) { log_record(PBSEVENT_DEBUG, PBS_EVENTCLASS_NODE, __func__, "cannot initialize attribute"); return(rc); } /* if original node cannot be found do not process the update */ if ((current = find_nodebyname(nd_name)) == NULL) return(PBSE_NONE); /* loop over each string */ for (str = status_info->str; str != NULL && *str; str += strlen(str) + 1) { /* these two options are for switching nodes */ if (!strncmp(str, NUMA_KEYWORD, strlen(NUMA_KEYWORD))) { /* if we've already processed some, save this before moving on */ if (str != status_info->str) save_node_status(current, &temp); dont_change_state = FALSE; if ((current = get_numa_from_str(str, current)) == NULL) break; else continue; } else if (!strncmp(str, "node=", strlen("node="))) { /* if we've already processed some, save this before moving on */ if (str != status_info->str) save_node_status(current, &temp); dont_change_state = FALSE; if ((current = get_node_from_str(str, name, current)) == NULL) break; else { /* There is a race condition if using a mom hierarchy and manually * shutting down a non-level 1 mom: if its message that the mom is * shutting down gets there before its last status update, the node * can incorrectly be set as free again. For that reason, only set * a mom back up if its reporting for itself. */ if ((strcmp(name, str + strlen("node=")) != 0) && (current->nd_mom_reported_down == TRUE)) { dont_change_state = TRUE; } current->nd_mom_reported_down = FALSE; continue; } } /* add the info to the "temp" pbs_attribute */ #ifdef NVIDIA_GPUS else if (!strcmp(str, START_GPU_STATUS)) { is_gpustat_get(current, &str); } #endif else if (!strcmp(str, START_MIC_STATUS)) { process_mic_status(current, &str); } else if (!strcmp(str, "first_update=true")) { /* mom is requesting that we send the mom hierarchy file to her */ remove_hello(&hellos, current->nd_name); send_hello = TRUE; #ifdef NVIDIA_GPUS /* reset gpu data in case mom reconnects with changed gpus */ clear_nvidia_gpus(current); #endif /* NVIDIA_GPUS */ } else if ((rc = decode_arst(&temp, NULL, NULL, str, 0)) != PBSE_NONE) { DBPRT(("is_stat_get: cannot add attributes\n")); free_arst(&temp); break; } if (!strncmp(str, "state", 5)) { if (dont_change_state == FALSE) process_state_str(current, str); } else if ((allow_any_mom == TRUE) && (!strncmp(str, "uname", 5))) { process_uname_str(current, str); } else if (!strncmp(str, "me", 2)) /* shorter str compare than "message" */ { if ((!strncmp(str, "message=ERROR", 13)) && (down_on_error == TRUE)) { update_node_state(current, INUSE_DOWN); dont_change_state = TRUE; } } else if ((mom_job_sync == TRUE) && (!strncmp(str, "jobdata=", 8))) { /* update job attributes based on what the MOM gives us */ update_job_data(current, str + strlen("jobdata=")); } else if ((mom_job_sync == TRUE) && (!strncmp(str, "jobs=", 5))) { /* walk job list reported by mom */ size_t len = strlen(str) + strlen(current->nd_name) + 2; char *jobstr = (char *)calloc(1, len); sync_job_info *sji = (sync_job_info *)calloc(1, sizeof(sync_job_info)); if ((jobstr != NULL)&&(sji != NULL)) { sprintf(jobstr, "%s:%s", current->nd_name, str+5); sji->input = jobstr; sji->timestamp = time(NULL); /* sji must be freed in sync_node_jobs */ enqueue_threadpool_request(sync_node_jobs, sji); } else { if( jobstr != NULL) { free(jobstr); } if(sji != NULL) { free(sji); } } } else if (auto_np) { if (!(strncmp(str, "ncpus=", 6))) { handle_auto_np(current, str); } } } /* END processing strings */ if (current != NULL) { save_node_status(current, &temp); unlock_node(current, __func__, NULL, 0); } if ((rc == PBSE_NONE) && (send_hello == TRUE)) rc = SEND_HELLO; return(rc); } /* END process_status_info() */
int main(int argc, char **argv) { SDDS_TABLE SDDS_table; SCANNED_ARG *scanned; long i, i_arg, index, points, lsb_first, bytes_per_number; char *input, *output, buffer[BUFSIZE]; char *signal_name, *ptr, *parameter_name; char *mpl_title, *mpl_topline, *descrip_text, *descrip_contents; FILE *fpi; long code, binary; double xIncrement, xZero, yMultiplier, yZero; char *xUnits, *yUnits; double *time, *data; short columnMajorOrder=0; unsigned long majorOrderFlag; xUnits = yUnits = NULL; argc = scanargs(&scanned, argc, argv); if (argc<3) bomb(NULL, USAGE); input = output = signal_name = NULL; mpl_title = mpl_topline = descrip_text = descrip_contents = NULL; binary = 0; for (i_arg=1; i_arg<argc; i_arg++) { if (scanned[i_arg].arg_type==OPTION) { delete_chars(scanned[i_arg].list[0], "_"); /* process options here */ switch (match_string(scanned[i_arg].list[0], option, N_OPTIONS, 0)) { case SET_MAJOR_ORDER: majorOrderFlag=0; scanned[i_arg].n_items--; if (scanned[i_arg].n_items>0 && (!scanItemList(&majorOrderFlag, scanned[i_arg].list+1, &scanned[i_arg].n_items, 0, "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER, "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL))) SDDS_Bomb("invalid -majorOrder syntax/values"); if (majorOrderFlag&SDDS_COLUMN_MAJOR_ORDER) columnMajorOrder=1; else if (majorOrderFlag&SDDS_ROW_MAJOR_ORDER) columnMajorOrder=0; break; case SET_SIGNAL_NAME: if (scanned[i_arg].n_items!=2) bomb("invalid -signal_name syntax", USAGE); signal_name = scanned[i_arg].list[1]; break; case SET_DESCRIPTION: if (scanned[i_arg].n_items!=3) bomb("invalid -description syntax", USAGE); descrip_text = scanned[i_arg].list[1]; descrip_contents = scanned[i_arg].list[2]; break; case SET_MPL_LABELS: if (scanned[i_arg].n_items!=3) bomb("invalid -mpl_labels syntax", USAGE); mpl_title = scanned[i_arg].list[1]; mpl_topline = scanned[i_arg].list[2]; break; default: bomb("invalid option seen", USAGE); break; } } else { if (!input) input = scanned[i_arg].list[0]; else if (!output) output = scanned[i_arg].list[0]; else bomb("too many filenames", USAGE); } } if (!input) SDDS_Bomb("input file not seen"); if (!output) SDDS_Bomb("output file not seen"); if (!signal_name) signal_name = "V"; fpi = fopen_e(input, "r", 0); if (fread(buffer, 1, strlen(TEK_PreambleString), fpi)!=strlen(TEK_PreambleString) || strncmp(TEK_PreambleString, buffer, strlen(TEK_PreambleString))!=0) SDDS_Bomb("file does not appear to be in Tektronix format"); parameter_name = buffer; while ((code=GetNextItem(buffer, BUFSIZE, fpi))<3) { if (!(ptr=strchr(buffer, ':'))) SDDS_Bomb("error parsing input file--missing colon on parameter tag"); *ptr++ = 0; if (strcmp(TEK_DataMarker, parameter_name)==0) break; index = 0; while (TEK_parameter[index].TEK_name) { if (strcmp(TEK_parameter[index].TEK_name, parameter_name)==0) break; index++; } if (!TEK_parameter[index].TEK_name) { fprintf(stderr, "warning: parameter %s is not recognized\n", parameter_name); continue; } if (TEK_parameter[index].value_string) { fprintf(stderr, "error: duplicate entries for parameter %s\n", parameter_name); exit(1); } SDDS_RemovePadding(ptr); SDDS_CopyString(&TEK_parameter[index].value_string, ptr); if (code==2 || code==3) break; } if (code!=2) SDDS_Bomb("unexpected end of file"); if (fread(buffer, 1, strlen(TEK_DataMarker), fpi)!=strlen(TEK_DataMarker) || strncmp(TEK_DataMarker, buffer, strlen(TEK_DataMarker))!=0) SDDS_Bomb("CURVE item missing or not in right place"); if (!SDDS_InitializeOutput(&SDDS_table, SDDS_BINARY, 0, descrip_text, descrip_contents, output)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); SDDS_table.layout.data_mode.column_major = columnMajorOrder; index = 0; while (TEK_parameter[index].TEK_name) { if (!TEK_parameter[index].value_string) { index++; continue; } if (strcmp(TEK_parameter[index].TEK_name, TEK_XIncrementName)==0) { if (sscanf(TEK_parameter[index].value_string, "%lf", &xIncrement)!=1) SDDS_Bomb("unable to scan value for x increment"); } else if (strcmp(TEK_parameter[index].TEK_name, TEK_XZeroName)==0) { if (sscanf(TEK_parameter[index].value_string, "%lf", &xZero)!=1) SDDS_Bomb("unable to scan value for x zero"); } else if (strcmp(TEK_parameter[index].TEK_name, TEK_YZeroName)==0) { if (sscanf(TEK_parameter[index].value_string, "%lf", &yZero)!=1) SDDS_Bomb("unable to scan value for y zero"); } else if (strcmp(TEK_parameter[index].TEK_name, TEK_YMultiplierName)==0) { if (sscanf(TEK_parameter[index].value_string, "%lf", &yMultiplier)!=1) SDDS_Bomb("unable to scan value for y multiplier"); } else if (strcmp(TEK_parameter[index].TEK_name, TEK_XUnitsName)==0) { xUnits = TEK_parameter[index].value_string; str_tolower(xUnits); } else if (strcmp(TEK_parameter[index].TEK_name, TEK_YUnitsName)==0) { yUnits = TEK_parameter[index].value_string; str_tolower(yUnits); } else if (strcmp(TEK_parameter[index].TEK_name, TEK_PointsName)==0) { if (sscanf(TEK_parameter[index].value_string, "%ld", &points)!=1) SDDS_Bomb("unable to scan value for number of points"); } else if (strcmp(TEK_parameter[index].TEK_name, TEK_EncodingName)==0) { if (strcmp(TEK_parameter[index].value_string, "ASCII")==0) binary = 0; else if (strcmp(TEK_parameter[index].value_string, "BINARY")==0) binary = 1; else SDDS_Bomb("data encoding is neither ASCII nor BINARY"); } else if (strcmp(TEK_parameter[index].TEK_name, TEK_BytesPerNumberName)==0) { if (sscanf(TEK_parameter[index].value_string, "%ld", &bytes_per_number)!=1) SDDS_Bomb("unable to scan value bytes per number"); } else if (strcmp(TEK_parameter[index].TEK_name, TEK_ByteOrderName)==0) { lsb_first = 1; if (strcmp(TEK_parameter[index].value_string, "LSB")!=0) lsb_first = 0; } if (SDDS_DefineParameter(&SDDS_table, TEK_parameter[index].SDDS_name, NULL, NULL, TEK_parameter[index].TEK_name, NULL, TEK_parameter[index].type, TEK_parameter[index].value_string)<0) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); index++; } if (mpl_title && (SDDS_DefineParameter(&SDDS_table, "mplTitle", NULL, NULL, NULL, NULL, SDDS_STRING, mpl_title)<0 || SDDS_DefineParameter(&SDDS_table, "mplTopline", NULL, NULL, NULL, NULL, SDDS_STRING, mpl_topline)<0)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); if (SDDS_DefineColumn(&SDDS_table, "t", NULL, xUnits, NULL, NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&SDDS_table, signal_name, NULL, yUnits, NULL, NULL, SDDS_DOUBLE, 0)<0 || !SDDS_WriteLayout(&SDDS_table) || !SDDS_StartTable(&SDDS_table, points)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); data = tmalloc(sizeof(*data)*points); time = tmalloc(sizeof(*time)*points); if (!binary) { for (i=0; i<points; i++) { if (!(code=GetNextItem(buffer, BUFSIZE, fpi))) SDDS_Bomb("insufficient data in input file"); if (code==4) { points = i; break; } time[i] = xZero + i*xIncrement; if (sscanf(buffer, "%lf", data+i)!=1) SDDS_Bomb("invalid data in input file"); data[i] = yZero + data[i]*yMultiplier; } } else { short sdata; fread(buffer, sizeof(char), 4, fpi); for (i=0; i<points; i++) { if (fread(&sdata, sizeof(sdata), 1, fpi)!=1) { fprintf(stderr, "file ends unexpectedly\n"); points = i; break; } time[i] = xZero + i*xIncrement; data[i] = sdata; data[i] = yZero + data[i]*yMultiplier; } } if (!SDDS_SetColumn(&SDDS_table, SDDS_SET_BY_NAME, time, points, "t") || !SDDS_SetColumn(&SDDS_table, SDDS_SET_BY_NAME, data, points, signal_name) || !SDDS_WriteTable(&SDDS_table) || !SDDS_Terminate(&SDDS_table)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); return(0); }
static int config_connection_request(struct config_connection *conn, const char *const *args) { struct config_export_context *ctx; struct master_service_settings_output output; struct config_filter filter; const char *path, *error, *module, *const *wanted_modules; ARRAY(const char *) modules; bool is_master = FALSE; /* [<args>] */ t_array_init(&modules, 4); memset(&filter, 0, sizeof(filter)); for (; *args != NULL; args++) { if (strncmp(*args, "service=", 8) == 0) filter.service = *args + 8; else if (strncmp(*args, "module=", 7) == 0) { module = *args + 7; if (strcmp(module, "master") == 0) is_master = TRUE; array_append(&modules, &module, 1); } else if (strncmp(*args, "lname=", 6) == 0) filter.local_name = *args + 6; else if (strncmp(*args, "lip=", 4) == 0) { if (net_addr2ip(*args + 4, &filter.local_net) == 0) { filter.local_bits = IPADDR_IS_V4(&filter.local_net) ? 32 : 128; } } else if (strncmp(*args, "rip=", 4) == 0) { if (net_addr2ip(*args + 4, &filter.remote_net) == 0) { filter.remote_bits = IPADDR_IS_V4(&filter.remote_net) ? 32 : 128; } } } array_append_zero(&modules); wanted_modules = array_count(&modules) == 1 ? NULL : array_idx(&modules, 0); if (is_master) { /* master reads configuration only when reloading settings */ path = master_service_get_config_path(master_service); if (config_parse_file(path, TRUE, NULL, &error) <= 0) { o_stream_nsend_str(conn->output, t_strconcat("\nERROR ", error, "\n", NULL)); config_connection_destroy(conn); return -1; } } o_stream_cork(conn->output); ctx = config_export_init(wanted_modules, CONFIG_DUMP_SCOPE_SET, 0, config_request_output, conn->output); config_export_by_filter(ctx, &filter); config_export_get_output(ctx, &output); if (output.specific_services != NULL) { const char *const *s; for (s = output.specific_services; *s != NULL; s++) { o_stream_nsend_str(conn->output, t_strdup_printf("service=%s\t", *s)); } } if (output.service_uses_local) o_stream_nsend_str(conn->output, "service-uses-local\t"); if (output.service_uses_remote) o_stream_nsend_str(conn->output, "service-uses-remote\t"); if (output.used_local) o_stream_nsend_str(conn->output, "used-local\t"); if (output.used_remote) o_stream_nsend_str(conn->output, "used-remote\t"); o_stream_nsend_str(conn->output, "\n"); if (config_export_finish(&ctx) < 0) { config_connection_destroy(conn); return -1; } o_stream_nsend_str(conn->output, "\n"); o_stream_uncork(conn->output); return 0; }
void material_draw_callback(void *ptr) { OBJMATERIAL *objmaterial = (OBJMATERIAL *) ptr; PROGRAM *program = objmaterial->program; unsigned int i = 0; while (i != program->uniform_count) { if (!strcmp(program->uniform_array[i].name, "DIFFUSE")) { glUniform1i(program->uniform_array[i].location, 1); } else if (!strcmp(program->uniform_array[i].name, "MODELVIEWPROJECTIONMATRIX")) { glUniformMatrix4fv(program->uniform_array[i].location, 1, GL_FALSE, (float *)GFX_get_modelview_projection_matrix()); } else if (!strcmp(program->uniform_array[i].name, "DISSOLVE")) { glUniform1f(program->uniform_array[i].location, objmaterial->dissolve); } else if (!strcmp(program->uniform_array[i].name, "AMBIENT_COLOR")) { glUniform3fv(program->uniform_array[i].location, 1, (float *)&objmaterial->ambient); } else if (!strcmp(program->uniform_array[i].name, "DIFFUSE_COLOR")) { glUniform3fv(program->uniform_array[i].location, 1, (float *)&objmaterial->diffuse); } else if (!strcmp(program->uniform_array[i].name, "SPECULAR_COLOR")) { glUniform3fv(program->uniform_array[i].location, 1, (float *)&objmaterial->specular); } else if (!strcmp(program->uniform_array[i].name, "SHININESS")) { glUniform1f(program->uniform_array[i].location, objmaterial->specular_exponent * 0.128f); } else if (!strcmp(program->uniform_array[i].name, "MODELVIEWMATRIX")) { glUniformMatrix4fv(program->uniform_array[i].location, 1, GL_FALSE, (float *)GFX_get_modelview_matrix()); } else if (!strcmp(program->uniform_array[i].name, "PROJECTIONMATRIX")) { glUniformMatrix4fv(program->uniform_array[i].location, 1, GL_FALSE, (float *)GFX_get_projection_matrix()); } else if (!strcmp(program->uniform_array[i].name, "NORMALMATRIX")) { glUniformMatrix3fv(program->uniform_array[i].location, 1, GL_FALSE, (float *)GFX_get_normal_matrix()); } else if (!strcmp(program->uniform_array[i].name, "LIGHTPOSITION")) { vec3 position = { 0.0f, -3.0f, 10.0f }; vec3 eyeposition = { 0.0f, 0.0f, 0.0f }; vec3_multiply_mat4(&eyeposition, &position, &gfx.modelview_matrix[gfx.modelview_matrix_index - 1]); glUniform3fv(program->uniform_array[i].location, 1, (float *)&eyeposition); } ++i; } }
int main(int argc, char *argv[]) { /* TODO: refactor main() function */ static const int quit = 0; char dir[PATH_MAX]; char **files = NULL; int nfiles = 0; if(get_cwd(dir, sizeof(dir)) == NULL) { perror("getcwd"); return -1; } (void)vifm_chdir(dir); args_parse(&vifm_args, argc, argv, dir); args_process(&vifm_args, 1); if(strcmp(vifm_args.lwin_path, "-") == 0 || strcmp(vifm_args.rwin_path, "-") == 0) { files = read_stream_lines(stdin, &nfiles, 1, NULL, NULL); if(reopen_term_stdin() != 0) { return EXIT_FAILURE; } } (void)setlocale(LC_ALL, ""); srand(time(NULL)); cfg_init(); if(vifm_args.logging) { init_logger(1, vifm_args.startup_log_path); } init_filelists(); regs_init(); cfg_discover_paths(); reinit_logger(cfg.log_file); /* Commands module also initializes bracket notation and variables. */ init_commands(); init_builtin_functions(); update_path_env(1); if(init_status(&cfg) != 0) { puts("Error during session status initialization."); return -1; } /* Tell file type module what function to use to check availability of * external programs. */ ft_init(&external_command_exists); /* This should be called before loading any configuration file. */ ft_reset(curr_stats.exec_env_type == EET_EMULATOR_WITH_X); init_option_handlers(); if(!vifm_args.no_configs) { /* vifminfo must be processed this early so that it can restore last visited * directory. */ read_info_file(0); } ipc_init(vifm_args.server_name, &parse_received_arguments); /* Export chosen server name to parsing unit. */ { var_val_t value = { .string = (char *)ipc_get_name() }; var_t var = var_new(VTYPE_STRING, value); setvar("v:servername", var); var_free(var); } args_process(&vifm_args, 0); bg_init(); fops_init(&enter_prompt_mode, &prompt_msg_custom); set_view_path(&lwin, vifm_args.lwin_path); set_view_path(&rwin, vifm_args.rwin_path); if(need_to_switch_active_pane(vifm_args.lwin_path, vifm_args.rwin_path)) { swap_view_roles(); } load_initial_directory(&lwin, dir); load_initial_directory(&rwin, dir); /* Force split view when two paths are specified on command-line. */ if(vifm_args.lwin_path[0] != '\0' && vifm_args.rwin_path[0] != '\0') { curr_stats.number_of_windows = 2; } /* Prepare terminal for further operations. */ curr_stats.original_stdout = reopen_term_stdout(); if(curr_stats.original_stdout == NULL) { return -1; } if(!setup_ncurses_interface()) { return -1; } { const colmgr_conf_t colmgr_conf = { .max_color_pairs = COLOR_PAIRS, .max_colors = COLORS, .init_pair = &init_pair, .pair_content = &pair_content, .pair_in_use = &pair_in_use, .move_pair = &move_pair, }; colmgr_init(&colmgr_conf); } init_modes(); init_undo_list(&undo_perform_func, NULL, &ui_cancellation_requested, &cfg.undo_levels); load_view_options(curr_view); curr_stats.load_stage = 1; if(!vifm_args.no_configs) { load_scheme(); cfg_load(); if(strcmp(vifm_args.lwin_path, "-") == 0) { flist_custom_set(&lwin, "-", dir, files, nfiles); } else if(strcmp(vifm_args.rwin_path, "-") == 0) { flist_custom_set(&rwin, "-", dir, files, nfiles); } } /* Load colors in any case to load color pairs. */ cs_load_pairs(); cs_write(); setup_signals(); /* Ensure trash directories exist, it might not have been called during * configuration file sourcing if there is no `set trashdir=...` command. */ (void)set_trash_dir(cfg.trash_dir); check_path_for_file(&lwin, vifm_args.lwin_path, vifm_args.lwin_handle); check_path_for_file(&rwin, vifm_args.rwin_path, vifm_args.rwin_handle); curr_stats.load_stage = 2; /* Update histories of the views to ensure that their current directories, * which might have been set using command-line parameters, are stored in the * history. This is not done automatically as history manipulation should be * postponed until views are fully loaded, otherwise there is no correct * information about current file and relative cursor position. */ flist_hist_save(&lwin, NULL, NULL, -1); flist_hist_save(&rwin, NULL, NULL, -1); /* Trigger auto-commands for initial directories. */ vle_aucmd_execute("DirEnter", lwin.curr_dir, &lwin); vle_aucmd_execute("DirEnter", rwin.curr_dir, &rwin); update_screen(UT_FULL); modes_update(); /* Run startup commands after loading file lists into views, so that commands * like +1 work. */ exec_startup_commands(&vifm_args); curr_stats.load_stage = 3; event_loop(&quit); return 0; } /* Checks whether pair is being used at the moment. Returns non-zero if so and * zero otherwise. */ static int pair_in_use(short int pair) { int i; for(i = 0; i < MAXNUM_COLOR; ++i) { if(cfg.cs.pair[i] == pair || lwin.cs.pair[i] == pair || rwin.cs.pair[i] == pair) { return 1; } } return 0; }
void gui_key_flush (int paste) { int i, key, last_key_used, insert_ok, undo_done; static char key_str[64] = { '\0' }; static int length_key_str = 0; char key_temp[2], *key_utf, *input_old, *ptr_char, *next_char, *ptr_error; char utf_partial_char[16]; struct t_gui_buffer *old_buffer; /* if paste pending or bracketed paste detected, just return */ if (gui_key_paste_pending || gui_key_paste_bracketed) return; /* if buffer is empty, just return */ if (gui_key_buffer_size == 0) return; /* * if there's no paste pending, then we use buffer and do actions * according to keys */ gui_key_last_activity_time = time (NULL); last_key_used = -1; undo_done = 0; old_buffer = NULL; for (i = 0; i < gui_key_buffer_size; i++) { key = gui_key_buffer[i]; insert_ok = 1; utf_partial_char[0] = '\0'; if (gui_mouse_event_pending || (key < 32) || (key == 127)) { if (gui_mouse_event_pending) { insert_ok = 0; key_str[0] = (char)key; key_str[1] = '\0'; length_key_str = 1; } else if (key < 32) { insert_ok = 0; key_str[0] = '\x01'; key_str[1] = (char)key + '@'; key_str[2] = '\0'; length_key_str = 2; } else if (key == 127) { key_str[0] = '\x01'; key_str[1] = '?'; key_str[2] = '\0'; length_key_str = 2; } } else { if (local_utf8) { key_str[length_key_str] = (char)key; key_str[length_key_str + 1] = '\0'; length_key_str++; /* * replace invalid chars by "?", but NOT last char of * string, if it is incomplete UTF-8 char (another char * will be added to the string on next iteration) */ ptr_char = key_str; while (ptr_char && ptr_char[0]) { (void) utf8_is_valid (ptr_char, &ptr_error); if (!ptr_error) break; next_char = utf8_next_char (ptr_error); if (next_char && next_char[0]) { ptr_char = ptr_error; while (ptr_char < next_char) { ptr_char[0] = '?'; ptr_char++; } } else { strcpy (utf_partial_char, ptr_char); ptr_char[0] = '\0'; break; } ptr_char = next_char; } } else { /* convert input to UTF-8 */ key_temp[0] = (char)key; key_temp[1] = '\0'; key_utf = string_iconv_to_internal (NULL, key_temp); strcat (key_str, key_utf); } } if (key_str[0]) { hook_signal_send ("key_pressed", WEECHAT_HOOK_SIGNAL_STRING, key_str); if (gui_current_window->buffer->text_search != GUI_TEXT_SEARCH_DISABLED) input_old = (gui_current_window->buffer->input_buffer) ? strdup (gui_current_window->buffer->input_buffer) : strdup (""); else input_old = NULL; old_buffer = gui_current_window->buffer; if ((gui_key_pressed (key_str) != 0) && (insert_ok) && (!gui_cursor_mode)) { if (!paste || !undo_done) gui_buffer_undo_snap (gui_current_window->buffer); gui_input_insert_string (gui_current_window->buffer, key_str, -1); gui_input_text_changed_modifier_and_signal (gui_current_window->buffer, (!paste || !undo_done) ? 1 : 0, 1); /* stop completion */ undo_done = 1; } /* incremental text search in buffer */ if ((old_buffer == gui_current_window->buffer) && (gui_current_window->buffer->text_search != GUI_TEXT_SEARCH_DISABLED) && ((input_old == NULL) || (gui_current_window->buffer->input_buffer == NULL) || (strcmp (input_old, gui_current_window->buffer->input_buffer) != 0))) { /* * if following conditions are all true, then do not search * again (search will not find any result and can take some time * on a buffer with many lines): * - old search was not successful * - searching a string (not a regex) * - current input is longer than old input * - beginning of current input is exactly equal to old input. */ if (!gui_current_window->buffer->text_search_found && !gui_current_window->buffer->text_search_regex && (input_old != NULL) && (input_old[0]) && (gui_current_window->buffer->input_buffer != NULL) && (gui_current_window->buffer->input_buffer[0]) && (strlen (gui_current_window->buffer->input_buffer) > strlen (input_old)) && (strncmp (gui_current_window->buffer->input_buffer, input_old, strlen (input_old)) == 0)) { /* * do not search text in buffer, just alert about text not * found */ if (CONFIG_BOOLEAN(config_look_search_text_not_found_alert)) printf ("\a"); } else { gui_window_search_restart (gui_current_window); } } if (input_old) free (input_old); } /* prepare incomplete UTF-8 char for next iteration */ if (utf_partial_char[0]) strcpy (key_str, utf_partial_char); else key_str[0] = '\0'; length_key_str = strlen (key_str); /* set last key used in buffer if combo buffer is empty */ if (gui_key_grab || gui_mouse_event_pending || !gui_key_combo_buffer[0]) last_key_used = i; } if (last_key_used == gui_key_buffer_size - 1) gui_key_buffer_reset (); else if (last_key_used >= 0) gui_key_buffer_remove (0, last_key_used + 1); if (!gui_key_grab && !gui_mouse_event_pending) gui_key_combo_buffer[0] = '\0'; }
// 处理客户端请求,服务器核心控制逻辑 void accept_request(int client) { char buf[1024]; int numchars; char method[255]; char url[255]; char path[512]; size_t i, j; struct stat st; int cgi = 0; /* becomes true if server decides this is a CGI * program */ char *query_string = NULL; numchars = get_line(client, buf, sizeof(buf)); // 读取请求行 i = 0; j = 0; while (!ISspace(buf[j]) && (i < sizeof(method) - 1)) { method[i] = buf[j]; i++; j++; } // 循环截取出请求方法 method[i] = '\0'; if (strcasecmp(method, "GET") && strcasecmp(method, "POST")) // 只接收GET和POST请求 { unimplemented(client); // 响应未实现页面 return; } if (strcasecmp(method, "POST") == 0) // POST请求 cgi = 1; i = 0; while (ISspace(buf[j]) && (j < sizeof(buf))) // 刚才截取method后j定位到后面的一个空格处,现在一直向后移动j直到指向非空白字符 j++; while (!ISspace(buf[j]) && (i < sizeof(url) - 1) && (j < sizeof(buf))) { url[i] = buf[j]; i++; j++; } // 循环截取出请求的url资源 url[i] = '\0'; if (strcasecmp(method, "GET") == 0) // GET请求 { query_string = url; // 查询字符串在url中的?号后面 while ((*query_string != '?') && (*query_string != '\0')) // 一直移动到?号处 query_string++; if (*query_string == '?') { cgi = 1; *query_string = '\0'; // ?号置为\0,url就切出来了 query_string++; // 查询字符串从?后面一个字符开始 } } sprintf(path, "htdocs%s", url); // htdocs/url/ htdocs/res.html if (path[strlen(path) - 1] == '/') // 最后一个字符是‘/’,默认访问该目录下的 index.html 页面 strcat(path, "index.html"); if (stat(path, &st) == -1) { // 获取文件详细信息失败 while ((numchars > 0) && strcmp("\n", buf)) /* read & discard headers */ // 读取剩下的请求头 numchars = get_line(client, buf, sizeof(buf)); not_found(client); // 404 } else { if ((st.st_mode & S_IFMT) == S_IFDIR) // 是一个目录,默认访问该目录下的 index.html 页面 strcat(path, "/index.html"); if ((st.st_mode & S_IXUSR) || (st.st_mode & S_IXGRP) || (st.st_mode & S_IXOTH) ) // 这个资源有执行权限 包括 所有者 同组 其他人 cgi = 1; if (!cgi) serve_file(client, path); // 请求的是个页面,返回这页面 else execute_cgi(client, path, method, query_string); // cgi程序,可以执行这个程序,处理过程交给cgi程序 } close(client); // 关闭client socket }
int is_gpustat_get( struct pbsnode *np, /* I (modified) */ char **str_ptr) /* I (modified) */ { int rc; pbs_attribute temp; char *gpuid; char *str = *str_ptr; char log_buf[LOCAL_LOG_BUF_SIZE]; int gpuidx = -1; char gpuinfo[2048]; int need_delimiter; int reportedgpucnt = 0; int startgpucnt = 0; int drv_ver; if (LOGLEVEL >= 7) { sprintf(log_buf, "received gpu status from node %s", (np != NULL) ? np->nd_name : "NULL"); log_record(PBSEVENT_SCHED, PBS_EVENTCLASS_REQUEST, __func__, log_buf); } /* save current gpu count for node */ startgpucnt = np->nd_ngpus; /* * Before filling the "temp" pbs_attribute, initialize it. * The second and third parameter to decode_arst are never * used, so just leave them empty. (GBS) */ memset(&temp, 0, sizeof(temp)); memset(gpuinfo, 0, 2048); rc = DIS_SUCCESS; if (decode_arst(&temp, NULL, NULL, NULL, 0)) { DBPRT(("is_gpustat_get: cannot initialize attribute\n")); return(DIS_NOCOMMIT); } str += strlen(str) + 1; for (; str != NULL && *str; str += strlen(str) + 1) { /* add the info to the "temp" attribute */ /* get timestamp */ if (!strncmp(str, "timestamp=", 10)) { if (decode_arst(&temp, NULL, NULL, str, 0)) { DBPRT(("is_gpustat_get: cannot add attributes\n")); free_arst(&temp); *str_ptr = move_past_gpu_status(str); return(DIS_NOCOMMIT); } continue; } /* get driver version, if there is one */ if (!strncmp(str, "driver_ver=", 11)) { if (decode_arst(&temp, NULL, NULL, str, 0)) { DBPRT(("is_gpustat_get: cannot add attributes\n")); free_arst(&temp); *str_ptr = move_past_gpu_status(str); return(DIS_NOCOMMIT); } drv_ver = atoi(str + 11); continue; } else if (!strcmp(str, END_GPU_STATUS)) { break; } /* gpuid must come before the rest or we will be in trouble */ if (!strncmp(str, "gpuid=", 6)) { if (strlen(gpuinfo) > 0) { if (decode_arst(&temp, NULL, NULL, gpuinfo, 0)) { DBPRT(("is_gpustat_get: cannot add attributes\n")); free_arst(&temp); *str_ptr = move_past_gpu_status(str); return(DIS_NOCOMMIT); } memset(gpuinfo, 0, 2048); } gpuid = &str[6]; /* * Get this gpus index, if it does not yet exist then find an empty entry. * We need to allow for the gpu status results being returned in * different orders since the nvidia order may change upon mom's reboot */ gpuidx = gpu_entry_by_id(np, gpuid, TRUE); if (gpuidx == -1) { /* * Failure - we could not get / create a nd_gpusn entry for this gpu, * log an error message. */ if (LOGLEVEL >= 3) { sprintf(log_buf, "Failed to get/create entry for gpu %s on node %s\n", gpuid, np->nd_name); log_ext(-1, __func__, log_buf, LOG_DEBUG); } free_arst(&temp); *str_ptr = move_past_gpu_status(str); return(DIS_SUCCESS); } sprintf(gpuinfo, "gpu[%d]=gpu_id=%s;", gpuidx, gpuid); need_delimiter = FALSE; reportedgpucnt++; np->nd_gpusn[gpuidx].driver_ver = drv_ver; /* mark that this gpu node is not virtual */ np->nd_gpus_real = TRUE; /* * if we have not filled in the gpu_id returned by the mom node * then fill it in */ if ((gpuidx >= 0) && (np->nd_gpusn[gpuidx].gpuid == NULL)) { np->nd_gpusn[gpuidx].gpuid = strdup(gpuid); } } else { if (need_delimiter) { strcat(gpuinfo, ";"); } strcat(gpuinfo, str); need_delimiter = TRUE; } /* check current gpu mode and determine gpu state */ if (!memcmp(str, "gpu_mode=", 9)) { if ((!memcmp(str + 9, "Normal", 6)) || (!memcmp(str + 9, "Default", 7))) { np->nd_gpusn[gpuidx].mode = gpu_normal; if (gpu_has_job(np, gpuidx)) { np->nd_gpusn[gpuidx].state = gpu_shared; } else { np->nd_gpusn[gpuidx].inuse = 0; np->nd_gpusn[gpuidx].state = gpu_unallocated; } } else if ((!memcmp(str + 9, "Exclusive", 9)) || (!memcmp(str + 9, "Exclusive_Thread", 16))) { np->nd_gpusn[gpuidx].mode = gpu_exclusive_thread; if (gpu_has_job(np, gpuidx)) { np->nd_gpusn[gpuidx].state = gpu_exclusive; } else { np->nd_gpusn[gpuidx].inuse = 0; np->nd_gpusn[gpuidx].state = gpu_unallocated; } } else if (!memcmp(str + 9, "Exclusive_Process", 17)) { np->nd_gpusn[gpuidx].mode = gpu_exclusive_process; if (gpu_has_job(np, gpuidx)) { np->nd_gpusn[gpuidx].state = gpu_exclusive; } else { np->nd_gpusn[gpuidx].inuse = 0; np->nd_gpusn[gpuidx].state = gpu_unallocated; } } else if (!memcmp(str + 9, "Prohibited", 10)) { np->nd_gpusn[gpuidx].mode = gpu_prohibited; np->nd_gpusn[gpuidx].state = gpu_unavailable; } else { /* unknown mode, default to prohibited */ np->nd_gpusn[gpuidx].mode = gpu_prohibited; np->nd_gpusn[gpuidx].state = gpu_unavailable; if (LOGLEVEL >= 3) { sprintf(log_buf, "GPU %s has unknown mode on node %s", gpuid, np->nd_name); log_ext(-1, __func__, log_buf, LOG_DEBUG); } } /* add gpu_mode so it gets added to the pbs_attribute */ if (need_delimiter) { strcat(gpuinfo, ";"); } switch (np->nd_gpusn[gpuidx].state) { case gpu_unallocated: strcat (gpuinfo, "gpu_state=Unallocated"); break; case gpu_shared: strcat (gpuinfo, "gpu_state=Shared"); break; case gpu_exclusive: strcat (gpuinfo, "gpu_state=Exclusive"); break; case gpu_unavailable: strcat (gpuinfo, "gpu_state=Unavailable"); break; } } } /* end of while disrst */ if (strlen(gpuinfo) > 0) { if (decode_arst(&temp, NULL, NULL, gpuinfo, 0)) { DBPRT(("is_gpustat_get: cannot add attributes\n")); free_arst(&temp); *str_ptr = move_past_gpu_status(str); return(DIS_NOCOMMIT); } } /* maintain the gpu count, if it has changed we need to update the nodes file */ if (reportedgpucnt != startgpucnt) { np->nd_ngpus = reportedgpucnt; /* update the nodes file */ update_nodes_file(np); } node_gpustatus_list(&temp, np, ATR_ACTION_ALTER); *str_ptr = move_past_gpu_status(str); return(DIS_SUCCESS); } /* END is_gpustat_get() */
/* read keys from ssh key files */ static int readsshkeys(netpgp_t *netpgp, char *homedir, const char *needseckey) { pgp_keyring_t *pubring; pgp_keyring_t *secring; struct stat st; unsigned hashtype; char *hash; char f[MAXPATHLEN]; char *filename; if ((filename = netpgp_getvar(netpgp, "sshkeyfile")) == NULL) { /* set reasonable default for RSA key */ (void) snprintf(f, sizeof(f), "%s/id_rsa.pub", homedir); filename = f; } else if (strcmp(&filename[strlen(filename) - 4], ".pub") != 0) { /* got ssh keys, check for pub file name */ (void) snprintf(f, sizeof(f), "%s.pub", filename); filename = f; } /* check the pub file exists */ if (stat(filename, &st) != 0) { (void) fprintf(stderr, "readsshkeys: bad pubkey filename '%s'\n", filename); return 0; } if ((pubring = calloc(1, sizeof(*pubring))) == NULL) { (void) fprintf(stderr, "readsshkeys: bad alloc\n"); return 0; } /* openssh2 keys use md5 by default */ hashtype = PGP_HASH_MD5; if ((hash = netpgp_getvar(netpgp, "hash")) != NULL) { /* openssh 2 hasn't really caught up to anything else yet */ if (netpgp_strcasecmp(hash, "md5") == 0) { hashtype = PGP_HASH_MD5; } else if (netpgp_strcasecmp(hash, "sha1") == 0) { hashtype = PGP_HASH_SHA1; } else if (netpgp_strcasecmp(hash, "sha256") == 0) { hashtype = PGP_HASH_SHA256; } } if (!pgp_ssh2_readkeys(netpgp->io, pubring, NULL, filename, NULL, hashtype)) { free(pubring); (void) fprintf(stderr, "readsshkeys: can't read %s\n", filename); return 0; } if (netpgp->pubring == NULL) { netpgp->pubring = pubring; } else { pgp_append_keyring(netpgp->pubring, pubring); } if (needseckey) { netpgp_setvar(netpgp, "sshpubfile", filename); /* try to take the ".pub" off the end */ if (filename == f) { f[strlen(f) - 4] = 0x0; } else { (void) snprintf(f, sizeof(f), "%.*s", (int)strlen(filename) - 4, filename); filename = f; } if ((secring = calloc(1, sizeof(*secring))) == NULL) { free(pubring); (void) fprintf(stderr, "readsshkeys: bad alloc\n"); return 0; } if (!pgp_ssh2_readkeys(netpgp->io, pubring, secring, NULL, filename, hashtype)) { free(pubring); free(secring); (void) fprintf(stderr, "readsshkeys: can't read sec %s\n", filename); return 0; } netpgp->secring = secring; netpgp_setvar(netpgp, "sshsecfile", filename); } return 1; }
/*ARGSUSED*/ int TXLload(GENmodel *inModel, CKTcircuit *ckt) { TXLmodel *model = (TXLmodel *)inModel; TXLinstance *here; TXLine *tx, *tx2; int k, l; int time, time2; double h, h1, f; int hint; double hf; NODE *nd; double v, v1, g; int cond1; CKTnode *node; VI_list_txl *vi, *vi_before; int i, before, delta; double gmin; /* dc solution */ /* debug printf("before txlload\n"); SMPprint(ckt->CKTmatrix, NULL); */ h = ckt->CKTdelta; h1 = 0.5 * h; time2 = (int) (ckt->CKTtime * 1e12); hint = (int)(h * 1e12); hf = h * 1e12; time = (int) ((ckt->CKTtime - ckt->CKTdelta) * 1e12); cond1= ckt->CKTmode & MODEDC; gmin = 0.1 * ckt->CKTgmin; /* dc solution */ for( ; model != NULL; model = model->TXLnextModel ) { for (here = model->TXLinstances; here != NULL ; here=here->TXLnextInstance) { tx = here->txline; *here->TXLposPosptr += gmin; /* dc solution */ *here->TXLnegNegptr += gmin; *here->TXLnegPosptr += gmin; *here->TXLposNegptr += gmin; if (cond1 || tx->vi_head == NULL) continue; if (time < tx->vi_tail->time) { time = tx->vi_tail->time; hint = time2 - time; } vi_before = tx->vi_tail; before = tx->vi_tail->time; if (time > tx->vi_tail->time) { copy_tx(tx, here->txline2); add_new_vi_txl(here, ckt, time); delta = time - before; nd = tx->in_node; v = vi_before->v_i; nd->V = tx->vi_tail->v_i; v1 = nd->V; nd->dv = (v1 - v) / delta; nd = tx->out_node; v = vi_before->v_o; v1 = nd->V = tx->vi_tail->v_o; nd->dv = (v1 - v) / delta; if (tx->lsl) continue; update_cnv_txl(tx, delta); if (tx->ext) update_delayed_cnv_txl(tx, delta); } } } model = (TXLmodel *)inModel; for( ; model != NULL; model = model->TXLnextModel ) { for (here = model->TXLinstances; here != NULL ; here=here->TXLnextInstance) { tx = here->txline; tx2 = here->txline2; if (!tx->lsl && hf > tx->taul) { fprintf(stderr, "your time step is too large for TXL tau.\n"); /* fprintf(stderr, "please decrease max time step in .tran card.\n"); fprintf(stderr, ".tran tstep tstop tstart tmax.\n"); fprintf(stderr, "make tmax smaller than %e and try again.\n", tx->taul * 1e-12); return (1111); */ fprintf(stderr, "tmax is now set to %e.\n", 0.9 * tx->taul * 1e-12); ckt->CKTmaxStep = 0.9 * tx->taul * 1e-12; } if (cond1) { if (here->TXLlengthgiven) g = model->R * here->TXLlength; else g = model->R * here->TXLmodPtr->length; *(here->TXLposIbr1ptr) += 1.0; *(here->TXLnegIbr2ptr) += 1.0; *(here->TXLibr1Ibr1ptr) += 1.0; *(here->TXLibr1Ibr2ptr) += 1.0; *(here->TXLibr2Posptr) += 1.0; *(here->TXLibr2Negptr) -= 1.0; *(here->TXLibr2Ibr1ptr) -= g; continue; } /* dc setup */ if (here->TXLdcGiven == 0 && !cond1) { nd = tx->in_node; for (node = ckt->CKTnodes;node; node = node->next) { if (strcmp(nd->name->id, node->name) == 0) { tx->dc1 = tx2->dc1 = ckt->CKTrhsOld[node->number]; nd->V = tx->dc1; break; } } nd = tx->out_node; for (node = ckt->CKTnodes;node; node = node->next) { if (strcmp(nd->name->id, node->name) == 0) { tx->dc2 = tx2->dc2 = ckt->CKTrhsOld[node->number]; nd->V = tx->dc2; break; } } here->TXLdcGiven = 1; vi = new_vi_txl(); vi->time = 0; vi->i_i = *(ckt->CKTrhsOld + here->TXLibr1); vi->i_o = *(ckt->CKTrhsOld + here->TXLibr2); vi->v_i = tx->dc1; vi->v_o = tx->dc2; for (i = 0; i < 3; i++) { tx->h1_term[i].cnv_i = - tx->dc1 * tx->h1_term[i].c / tx->h1_term[i].x; tx->h1_term[i].cnv_o = - tx->dc2 * tx->h1_term[i].c / tx->h1_term[i].x; } for (i = 0; i < 3; i++) { tx->h2_term[i].cnv_i = 0.0; tx->h2_term[i].cnv_o = 0.0; } for (i = 0; i < 6; i++) { tx->h3_term[i].cnv_i = - tx->dc1 * tx->h3_term[i].c / tx->h3_term[i].x; tx->h3_term[i].cnv_o = - tx->dc2 * tx->h3_term[i].c / tx->h3_term[i].x; } vi->next = NULL; tx->vi_tail = vi; tx->vi_head = vi; here->txline2->vi_tail = vi; here->txline2->vi_head = vi; } /* change 6,6 1/18/93 *(here->TXLibr1Ibr1ptr) -= 1.0; *(here->TXLibr2Ibr2ptr) -= 1.0; *(here->TXLposIbr1ptr) += 1.0; *(here->TXLnegIbr2ptr) += 1.0; *(here->TXLibr1Posptr) += tx->sqtCdL + h1 * tx->h1C; *(here->TXLibr2Negptr) += tx->sqtCdL + h1 * tx->h1C; */ *(here->TXLibr1Ibr1ptr) = -1.0; *(here->TXLibr2Ibr2ptr) = -1.0; *(here->TXLposIbr1ptr) = 1.0; *(here->TXLnegIbr2ptr) = 1.0; *(here->TXLibr1Posptr) = tx->sqtCdL + h1 * tx->h1C; *(here->TXLibr2Negptr) = tx->sqtCdL + h1 * tx->h1C; k = here->TXLibr1; l = here->TXLibr2; copy_tx(tx2, tx); if (right_consts_txl(tx2, time, time2, h, h1, k, l, ckt)) { if (tx->lsl) { f = ratio[0] * tx->h3_aten; *(here->TXLibr1Negptr) = -f; *(here->TXLibr2Posptr) = -f; f = ratio[0] * tx->h2_aten; *(here->TXLibr1Ibr2ptr) = -f; *(here->TXLibr2Ibr1ptr) = -f; } else { tx->ext = 1; tx->ratio = ratio[0]; if (ratio[0] > 0.0) { f = ratio[0] * (h1 * (tx->h3_term[0].c + tx->h3_term[1].c + tx->h3_term[2].c + tx->h3_term[3].c + tx->h3_term[4].c + tx->h3_term[5].c ) + tx->h3_aten); *(here->TXLibr1Negptr) = -f; *(here->TXLibr2Posptr) = -f; f = ratio[0] * (h1 * ( tx->h2_term[0].c + tx->h2_term[1].c + tx->h2_term[2].c ) + tx->h2_aten); *(here->TXLibr1Ibr2ptr) = -f; *(here->TXLibr2Ibr1ptr) = -f; } } } else tx->ext = 0; } } if (cond1) return (OK); /* debug printf("after txlload\n"); SMPprint(ckt->CKTmatrix, NULL); */ return(OK); }
int flock_main(int argc UNUSED_PARAM, char **argv) { int mode, opt, fd; enum { OPT_s = (1 << 0), OPT_x = (1 << 1), OPT_n = (1 << 2), OPT_u = (1 << 3), OPT_c = (1 << 4), }; #if ENABLE_LONG_OPTS static const char getopt_longopts[] ALIGN1 = "shared\0" No_argument "s" "exclusive\0" No_argument "x" "unlock\0" No_argument "u" "nonblock\0" No_argument "n" ; applet_long_options = getopt_longopts; #endif opt_complementary = "-1"; opt = getopt32(argv, "+sxnu"); argv += optind; if (argv[1]) { fd = open(argv[0], O_RDONLY|O_NOCTTY|O_CREAT, 0666); if (fd < 0 && errno == EISDIR) fd = open(argv[0], O_RDONLY|O_NOCTTY); if (fd < 0) bb_perror_msg_and_die("can't open '%s'", argv[0]); //TODO? close_on_exec_on(fd); } else { fd = xatoi_positive(argv[0]); } argv++; /* If it is "flock FILE -c PROG", then -c isn't caught by getopt32: * we use "+" in order to support "flock -opt FILE PROG -with-opts", * we need to remove -c by hand. */ if (argv[0] && argv[0][0] == '-' && ( (argv[0][1] == 'c' && !argv[0][2]) || (ENABLE_LONG_OPTS && strcmp(argv[0] + 1, "-command") == 0) ) ) { argv++; if (argv[1]) bb_error_msg_and_die("-c takes only one argument"); opt |= OPT_c; } if (OPT_s == LOCK_SH && OPT_x == LOCK_EX && OPT_n == LOCK_NB && OPT_u == LOCK_UN) { /* With suitably matched constants, mode setting is much simpler */ mode = opt & (LOCK_SH + LOCK_EX + LOCK_NB + LOCK_UN); if (!(mode & ~LOCK_NB)) mode |= LOCK_EX; } else { if (opt & OPT_u) mode = LOCK_UN; else if (opt & OPT_s) mode = LOCK_SH; else mode = LOCK_EX; if (opt & OPT_n) mode |= LOCK_NB; } if (flock(fd, mode) != 0) { if (errno == EWOULDBLOCK) return EXIT_FAILURE; bb_perror_nomsg_and_die(); } if (argv[0]) { int rc; if (opt & OPT_c) { /* -c 'PROG ARGS' means "run sh -c 'PROG ARGS'" */ argv -= 2; argv[0] = (char*)get_shell_name(); argv[1] = (char*)"-c"; /* argv[2] = "PROG ARGS"; */ /* argv[3] = NULL; */ } rc = spawn_and_wait(argv); if (rc < 0) bb_simple_perror_msg(argv[0]); return rc; } return EXIT_SUCCESS; }
int read_s3hypseg_line(char *line, seg_hyp_line_t * seg_hyp_line, lm_t * lm, dict_t * dict) { char *p, str[128]; conf_srch_hyp_t *hyp_word, *tail, *g, *h; int sum, t, i; s3wid_t wid; p = line; if (!get_word(&p, str)) { printf("failed to read sequence number in the line: %s\n", line); return HYPSEG_FAILURE; } strcpy(seg_hyp_line->seq, str); if (!get_word(&p, str) || strcmp(str, "S")) E_FATAL("failed to read S in the line: %s\n", line); get_word(&p, str); if (!get_word(&p, str) || strcmp(str, "T")) E_FATAL("failed to read T in the line: %s\n", line); if (!get_word(&p, str)) E_FATAL("failed to read ascr+lscr in the line: %s\n", line); sum = atoi(str); if (!get_word(&p, str) || strcmp(str, "A")) E_FATAL("failed to read A in the line: %s\n", line); if (!get_word(&p, str)) E_FATAL("failed to read ascr in the line: %s\n", line); seg_hyp_line->ascr = atoi(str); if (!get_word(&p, str) || strcmp(str, "L")) E_FATAL("failed to read L in the line: %s\n", line); if (!get_word(&p, str)) E_FATAL("failed to read lscr in the line: %s\n", line); seg_hyp_line->lscr = atoi(str); #if 0 if (!get_word(&p, str) || strcmp(str, "0")) { E_FATAL("failed to find 0 in the line: %s\n", line); } #endif if (seg_hyp_line->ascr + seg_hyp_line->lscr != sum) { E_FATAL("the sum of ascr and lscr %d is wrong (%d): %s\n", seg_hyp_line->ascr + seg_hyp_line->lscr, sum, line); } seg_hyp_line->wordlist = NULL; seg_hyp_line->wordno = 0; seg_hyp_line->nfr = 0; seg_hyp_line->cscore = WORST_CONFIDENCE_SCORE; tail = NULL; while (1) { if (!get_word(&p, str)) E_FATAL("failed to read sf or nfr in the line: %s\n", line); t = atoi(str); if (!get_word(&p, str)) { seg_hyp_line->nfr = t; break; } if ((hyp_word = (conf_srch_hyp_t *) ckd_calloc(1, sizeof(conf_srch_hyp_t))) == NULL || (hyp_word->sh.word = (char *) ckd_calloc(1024, sizeof(char))) == NULL) { E_FATAL("fail to allocate memory\n"); } hyp_word->sh.sf = t; hyp_word->sh.ascr = atoi(str); hyp_word->next = NULL; if (!get_word(&p, str)) E_FATAL("failed to read lscr in the line: %s\n", line); hyp_word->sh.lscr = atoi(str); if (!get_word(&p, str)) E_FATAL("failed to read word in the line: %s\n", line); strcpy(hyp_word->sh.word, str); for (i = strlen(str) - 1; i >= 0; i--) if (str[i] == '(') break; if (i >= 0) str[i] = '\0'; if (dict) { wid = dict_wordid(dict, str); if (wid == BAD_S3WID) { E_FATAL("String %s doesn't exists in the dictionary\n", str); } hyp_word->sh.id = wid; } hyp_word->compound = 0; hyp_word->matchtype = 0; seg_hyp_line->wordno++; if (seg_hyp_line->wordlist == NULL) seg_hyp_line->wordlist = hyp_word; else tail->next = hyp_word; tail = hyp_word; } if (seg_hyp_line->wordlist == NULL) { printf("word list is NULL\n"); return HYPSEG_FAILURE; } g = seg_hyp_line->wordlist; for (h = g->next; h; h = h->next) { g->sh.ef = h->sh.sf - 1; g = h; } g->sh.ef = seg_hyp_line->nfr; sum = 0; for (h = seg_hyp_line->wordlist; h; h = h->next) sum += h->sh.ascr; if (sum != seg_hyp_line->ascr) { E_FATAL ("the ascr of words is not equal to the ascr of utt: %s (sum %d != tot %d). \n", line, sum, seg_hyp_line->ascr); } sum = 0; for (h = seg_hyp_line->wordlist; h; h = h->next) sum += h->sh.lscr; if (sum != seg_hyp_line->lscr) E_WARN ("the lscr of words is not equal to the lscr of utt: %s %d %d\n", seg_hyp_line->seq, sum, seg_hyp_line->lscr); for (h = seg_hyp_line->wordlist; h; h = h->next) { if (h->sh.ef < h->sh.sf) { E_FATAL("word %s ef (%d) <= sf (%d)in the line: %s\n", h->sh.word, h->sh.ef, h->sh.sf, line); } } return HYPSEG_SUCCESS; }
static m64p_error ParseCommandLineFinal(int argc, const char **argv) { int i; /* parse commandline options */ for (i = 1; i < argc; i++) { int ArgsLeft = argc - i - 1; if (strcmp(argv[i], "--noosd") == 0) { int Osd = 0; (*ConfigSetParameter)(l_ConfigCore, "OnScreenDisplay", M64TYPE_BOOL, &Osd); } else if (strcmp(argv[i], "--osd") == 0) { int Osd = 1; (*ConfigSetParameter)(l_ConfigCore, "OnScreenDisplay", M64TYPE_BOOL, &Osd); } else if (strcmp(argv[i], "--fullscreen") == 0) { int Fullscreen = 1; (*ConfigSetParameter)(l_ConfigVideo, "Fullscreen", M64TYPE_BOOL, &Fullscreen); } else if (strcmp(argv[i], "--windowed") == 0) { int Fullscreen = 0; (*ConfigSetParameter)(l_ConfigVideo, "Fullscreen", M64TYPE_BOOL, &Fullscreen); } else if (strcmp(argv[i], "--nospeedlimit") == 0) { int EnableSpeedLimit = 0; if (g_CoreAPIVersion < 0x020001) DebugMessage(M64MSG_WARNING, "core library doesn't support --nospeedlimit"); else { if ((*CoreDoCommand)(M64CMD_CORE_STATE_SET, M64CORE_SPEED_LIMITER, &EnableSpeedLimit) != M64ERR_SUCCESS) DebugMessage(M64MSG_ERROR, "core gave error while setting --nospeedlimit option"); } } else if ((strcmp(argv[i], "--corelib") == 0 || strcmp(argv[i], "--configdir") == 0 || strcmp(argv[i], "--datadir") == 0) && ArgsLeft >= 1) { /* these are handled in ParseCommandLineInitial */ i++; } else if (strcmp(argv[i], "--resolution") == 0 && ArgsLeft >= 1) { const char *res = argv[i+1]; int xres, yres; i++; if (sscanf(res, "%ix%i", &xres, &yres) != 2) DebugMessage(M64MSG_WARNING, "couldn't parse resolution '%s'", res); else { (*ConfigSetParameter)(l_ConfigVideo, "ScreenWidth", M64TYPE_INT, &xres); (*ConfigSetParameter)(l_ConfigVideo, "ScreenHeight", M64TYPE_INT, &yres); } } else if (strcmp(argv[i], "--cheats") == 0 && ArgsLeft >= 1) { if (strcmp(argv[i+1], "all") == 0) l_CheatMode = CHEAT_ALL; else if (strcmp(argv[i+1], "list") == 0) l_CheatMode = CHEAT_SHOW_LIST; else { l_CheatMode = CHEAT_LIST; l_CheatNumList = (char*) argv[i+1]; } i++; } else if (strcmp(argv[i], "--plugindir") == 0 && ArgsLeft >= 1) { g_PluginDir = argv[i+1]; i++; } else if (strcmp(argv[i], "--sshotdir") == 0 && ArgsLeft >= 1) { (*ConfigSetParameter)(l_ConfigCore, "ScreenshotPath", M64TYPE_STRING, argv[i+1]); i++; } else if (strcmp(argv[i], "--gfx") == 0 && ArgsLeft >= 1) { g_GfxPlugin = argv[i+1]; i++; } else if (strcmp(argv[i], "--audio") == 0 && ArgsLeft >= 1) { g_AudioPlugin = argv[i+1]; i++; } else if (strcmp(argv[i], "--input") == 0 && ArgsLeft >= 1) { g_InputPlugin = argv[i+1]; i++; } else if (strcmp(argv[i], "--rsp") == 0 && ArgsLeft >= 1) { g_RspPlugin = argv[i+1]; i++; } else if (strcmp(argv[i], "--emumode") == 0 && ArgsLeft >= 1) { int emumode = atoi(argv[i+1]); i++; if (emumode < 0 || emumode > 2) { DebugMessage(M64MSG_WARNING, "invalid --emumode value '%i'", emumode); continue; } if (emumode == 2 && !(g_CoreCapabilities & M64CAPS_DYNAREC)) { DebugMessage(M64MSG_WARNING, "Emulator core doesn't support Dynamic Recompiler."); emumode = 1; } (*ConfigSetParameter)(l_ConfigCore, "R4300Emulator", M64TYPE_INT, &emumode); } else if (strcmp(argv[i], "--savestate") == 0 && ArgsLeft >= 1) { l_SaveStatePath = argv[i+1]; i++; } else if (strcmp(argv[i], "--testshots") == 0 && ArgsLeft >= 1) { l_TestShotList = ParseNumberList(argv[i+1], NULL); i++; } else if (strcmp(argv[i], "--set") == 0 && ArgsLeft >= 1) { if (SetConfigParameter(argv[i+1]) != 0) return M64ERR_INPUT_INVALID; i++; } else if (strcmp(argv[i], "--debug") == 0) { l_LaunchDebugger = 1; } else if (strcmp(argv[i], "--core-compare-send") == 0) { l_CoreCompareMode = 1; } else if (strcmp(argv[i], "--core-compare-recv") == 0) { l_CoreCompareMode = 2; } else if (strcmp(argv[i], "--nosaveoptions") == 0) { l_SaveOptions = 0; } #define PARSE_GB_CART_PARAM(param, key) \ else if (strcmp(argv[i], param) == 0) \ { \ ConfigSetParameter(l_ConfigTransferPak, key, M64TYPE_STRING, argv[i+1]); \ i++; \ } PARSE_GB_CART_PARAM("--gb-rom-1", "GB-rom-1") PARSE_GB_CART_PARAM("--gb-ram-1", "GB-ram-1") PARSE_GB_CART_PARAM("--gb-rom-2", "GB-rom-2") PARSE_GB_CART_PARAM("--gb-ram-2", "GB-ram-2") PARSE_GB_CART_PARAM("--gb-rom-3", "GB-rom-3") PARSE_GB_CART_PARAM("--gb-ram-3", "GB-ram-3") PARSE_GB_CART_PARAM("--gb-rom-4", "GB-rom-4") PARSE_GB_CART_PARAM("--gb-ram-4", "GB-ram-4") #undef PARSE_GB_CART_PARAM else if (strcmp(argv[i], "--dd-ipl-rom") == 0) { ConfigSetParameter(l_Config64DD, "IPL-ROM", M64TYPE_STRING, argv[i+1]); i++; } else if (strcmp(argv[i], "--dd-disk") == 0) { ConfigSetParameter(l_Config64DD, "Disk", M64TYPE_STRING, argv[i+1]); i++; } else if (ArgsLeft == 0) { /* this is the last arg, it should be a ROM filename */ l_ROMFilepath = argv[i]; return M64ERR_SUCCESS; } else if (strcmp(argv[i], "--verbose") == 0) { g_Verbose = 1; } else { DebugMessage(M64MSG_WARNING, "unrecognized command-line parameter '%s'", argv[i]); } /* continue argv loop */ } /* missing ROM filepath */ DebugMessage(M64MSG_ERROR, "no ROM filepath given"); return M64ERR_INPUT_INVALID; }
DWARFMappedHash::MemoryTable::Result DWARFMappedHash::MemoryTable::GetHashDataForName (const char *name, lldb::offset_t* hash_data_offset_ptr, Pair &pair) const { pair.key = m_data.GetU32 (hash_data_offset_ptr); pair.value.clear(); // If the key is zero, this terminates our chain of HashData objects // for this hash value. if (pair.key == 0) return eResultEndOfHashData; // There definitely should be a string for this string offset, if // there isn't, there is something wrong, return and error const char *strp_cstr = m_string_table.PeekCStr (pair.key); if (strp_cstr == NULL) { *hash_data_offset_ptr = UINT32_MAX; return eResultError; } const uint32_t count = m_data.GetU32 (hash_data_offset_ptr); const size_t min_total_hash_data_size = count * m_header.header_data.GetMinimumHashDataByteSize(); if (count > 0 && m_data.ValidOffsetForDataOfSize (*hash_data_offset_ptr, min_total_hash_data_size)) { // We have at least one HashData entry, and we have enough // data to parse at least "count" HashData entries. // First make sure the entire C string matches... const bool match = strcmp (name, strp_cstr) == 0; if (!match && m_header.header_data.HashDataHasFixedByteSize()) { // If the string doesn't match and we have fixed size data, // we can just add the total byte size of all HashData objects // to the hash data offset and be done... *hash_data_offset_ptr += min_total_hash_data_size; } else { // If the string does match, or we don't have fixed size data // then we need to read the hash data as a stream. If the // string matches we also append all HashData objects to the // value array. for (uint32_t i=0; i<count; ++i) { DIEInfo die_info; if (m_header.Read(m_data, hash_data_offset_ptr, die_info)) { // Only happened if the HashData of the string matched... if (match) pair.value.push_back (die_info); } else { // Something went wrong while reading the data *hash_data_offset_ptr = UINT32_MAX; return eResultError; } } } // Return the correct response depending on if the string matched // or not... if (match) return eResultKeyMatch; // The key (cstring) matches and we have lookup results! else return eResultKeyMismatch; // The key doesn't match, this function will get called // again for the next key/value or the key terminator // which in our case is a zero .debug_str offset. } else { *hash_data_offset_ptr = UINT32_MAX; return eResultError; } }
afs_int32 uss_kauth_SetFields(char *username, char *expirestring, char *reuse, char *failures, char *lockout) { #ifdef USS_KAUTH_DB static char rn[] = "uss_kauth_SetFields"; #endif afs_int32 code; char misc_auth_bytes[4]; int i; afs_int32 flags = 0; Date expiration = 0; afs_int32 lifetime = 0; afs_int32 maxAssociates = -1; afs_int32 was_spare = 0; char instance = '\0'; int pwexpiry; int nfailures, locktime, hrs, mins; if (strlen(username) > uss_UserLen) { fprintf(stderr, "%s: * User field in add cmd too long (max is %d chars; truncated value is '%s')\n", uss_whoami, uss_UserLen, uss_User); return (-1); } strcpy(uss_User, username); code = uss_kauth_CheckUserName(); if (code) return (code); /* no point in doing this any sooner than necessary */ for (i = 0; i < 4; misc_auth_bytes[i++] = 0); pwexpiry = atoi(expirestring); if (pwexpiry < 0 || pwexpiry > 254) { fprintf(stderr, "Password lifetime range must be [0..254] days.\n"); fprintf(stderr, "Zero represents an unlimited lifetime.\n"); fprintf(stderr, "Continuing with default lifetime == 0 for user %s.\n", username); pwexpiry = 0; } misc_auth_bytes[0] = pwexpiry + 1; if (!strcmp(reuse, "noreuse")) { misc_auth_bytes[1] = KA_NOREUSEPW; } else { misc_auth_bytes[1] = KA_REUSEPW; if (strcmp(reuse, "reuse")) fprintf(stderr, "must specify \"reuse\" or \"noreuse\": \"reuse\" assumed\n"); } nfailures = atoi(failures); if (nfailures < 0 || nfailures > 254) { fprintf(stderr, "Failure limit must be in [0..254].\n"); fprintf(stderr, "Zero represents unlimited login attempts.\n"); fprintf(stderr, "Continuing with limit == 254 for user %s.\n", username); misc_auth_bytes[2] = 255; } else misc_auth_bytes[2] = nfailures + 1; hrs = 0; if (strchr(lockout, ':')) sscanf(lockout, "%d:%d", &hrs, &mins); else sscanf(lockout, "%d", &mins); locktime = hrs*60 + mins; if (hrs < 0 || hrs > 36 || mins < 0) { fprintf(stderr,"Lockout times must be either minutes or hh:mm.\n"); fprintf(stderr,"Lockout times must be less than 36 hours.\n"); return KABADCMD; } else if (locktime > 36*60) { fprintf(stderr, "Lockout times must be either minutes or hh:mm.\n"); fprintf(stderr, "Lockout times must be less than 36 hours.\n"); fprintf(stderr, "Continuing with lock time == forever for user %s.\n", username); misc_auth_bytes[3] = 1; } else { locktime = (locktime * 60 + 511) >> 9; /* ceil(l*60/512) */ misc_auth_bytes[3] = locktime + 1; } if (uss_SkipKaserver) { if (uss_verbose) printf("[Skipping Kaserver as requested]\n"); return 0; } /* * Make sure the module has been initialized before we start trying * to talk to AuthServers. */ if (!initDone) { code = InitThisModule(); if (code) exit(code); } if (!uss_DryRun) { if (uss_verbose) fprintf(stderr, "Setting options for '%s' in database.\n", username); was_spare = pack_long(misc_auth_bytes); if (was_spare || flags || expiration || lifetime || (maxAssociates >= 0)) { if (!expiration) expiration = uss_Expires; code = ubik_KAM_SetFields(uconn_kauthP, 0, username, &instance, flags, expiration, lifetime, maxAssociates, was_spare, /* spare */ 0); } else fprintf(stderr, "Must specify one of the optional parameters. Continuing...\n"); if (code) { afs_com_err(uss_whoami, code, "calling KAM_SetFields for %s", username); return (code); } } /*Not a dry run */ else fprintf(stderr, "\t[Dry run - user '%s' NOT changed.]\n", username); return (0); } /*uss_kauth_SetFields */
int rrd_resize(int argc, char **argv) { char *infilename,outfilename[11]="resize.rrd"; FILE *infile,*outfile; rrd_t rrdold,rrdnew; rrd_value_t buffer; int version; unsigned long l,rra; long modify; unsigned long target_rra; int grow=0,shrink=0; char *endptr; infilename=argv[1]; if (!strcmp(infilename,"resize.rrd")) { rrd_set_error("resize.rrd is a reserved name"); return(-1); } if (argc!=5) { rrd_set_error("wrong number of parameters"); return(-1); } target_rra=strtol(argv[2],&endptr,0); if (!strcmp(argv[3],"GROW")) grow=1; else if (!strcmp(argv[3],"SHRINK")) shrink=1; else { rrd_set_error("I can only GROW or SHRINK"); return(-1); } modify=strtol(argv[4],&endptr,0); if ((modify<1)) { rrd_set_error("Please grow or shrink with at least 1 row"); return(-1); } if (shrink) modify = -modify; if (rrd_open(infilename, &infile, &rrdold, RRD_READWRITE)==-1) { rrd_set_error("could not open RRD"); return(-1); } if (LockRRD(infile) != 0) { rrd_set_error("could not lock original RRD"); rrd_free(&rrdold); fclose(infile); return(-1); } if (target_rra >= rrdold.stat_head->rra_cnt) { rrd_set_error("no such RRA in this RRD"); rrd_free(&rrdold); fclose(infile); return(-1); } if (modify < 0) if ((long)rrdold.rra_def[target_rra].row_cnt <= -modify) { rrd_set_error("This RRA is not that big"); rrd_free(&rrdold); fclose(infile); return(-1); } rrdnew.stat_head = rrdold.stat_head; rrdnew.ds_def = rrdold.ds_def; rrdnew.rra_def = rrdold.rra_def; rrdnew.live_head = rrdold.live_head; rrdnew.pdp_prep = rrdold.pdp_prep; rrdnew.cdp_prep = rrdold.cdp_prep; rrdnew.rra_ptr = rrdold.rra_ptr; version = atoi(rrdold.stat_head->version); switch (version) { case 3: break; case 1: rrdold.stat_head->version[3]='3'; break; default: { rrd_set_error("Do not know how to handle RRD version %s",rrdold.stat_head->version); rrd_free(&rrdold); fclose(infile); return(-1); } } if ((outfile=fopen(outfilename,"wb"))==NULL) { rrd_set_error("Can't create '%s'",outfilename); return(-1); } if (LockRRD(outfile) != 0) { rrd_set_error("could not lock new RRD"); rrd_free(&rrdold); fclose(infile); fclose(outfile); return(-1); } fwrite(rrdnew.stat_head, sizeof(stat_head_t),1,outfile); fwrite(rrdnew.ds_def,sizeof(ds_def_t),rrdnew.stat_head->ds_cnt,outfile); fwrite(rrdnew.rra_def,sizeof(rra_def_t),rrdnew.stat_head->rra_cnt,outfile); fwrite(rrdnew.live_head,sizeof(live_head_t),1,outfile); fwrite(rrdnew.pdp_prep,sizeof(pdp_prep_t),rrdnew.stat_head->ds_cnt,outfile); fwrite(rrdnew.cdp_prep,sizeof(cdp_prep_t),rrdnew.stat_head->ds_cnt*rrdnew.stat_head->rra_cnt,outfile); fwrite(rrdnew.rra_ptr,sizeof(rra_ptr_t),rrdnew.stat_head->rra_cnt,outfile); /* Move the CDPs from the old to the new database. ** This can be made (much) faster but isn't worth the effort. Clarity ** is much more important. */ /* Move data in unmodified RRAs */ l=0; for (rra=0;rra<target_rra;rra++) { l+=rrdnew.stat_head->ds_cnt * rrdnew.rra_def[rra].row_cnt; } while (l>0) { fread(&buffer,sizeof(rrd_value_t),1,infile); fwrite(&buffer,sizeof(rrd_value_t),1,outfile); l--; } /* Move data in this RRA, either removing or adding some rows */ if (modify>0) { /* Adding extra rows; insert unknown values just after the ** current row number. */ l = rrdnew.stat_head->ds_cnt * (rrdnew.rra_ptr[target_rra].cur_row+1); while (l>0) { fread(&buffer,sizeof(rrd_value_t),1,infile); fwrite(&buffer,sizeof(rrd_value_t),1,outfile); l--; } buffer=DNAN; l=rrdnew.stat_head->ds_cnt * modify; while (l>0) { fwrite(&buffer,sizeof(rrd_value_t),1,outfile); l--; } } else { /* Removing rows. Normally this would be just after the cursor ** however this may also mean that we wrap to the beginning of ** the array. */ signed long int remove_end=0; remove_end=(rrdnew.rra_ptr[target_rra].cur_row-modify)%rrdnew.rra_def[target_rra].row_cnt; if (remove_end <= (signed long int)rrdnew.rra_ptr[target_rra].cur_row) { while (remove_end >= 0) { fseek(infile,sizeof(rrd_value_t)*rrdnew.stat_head->ds_cnt,SEEK_CUR); rrdnew.rra_ptr[target_rra].cur_row--; rrdnew.rra_def[target_rra].row_cnt--; remove_end--; modify++; } remove_end=rrdnew.rra_def[target_rra].row_cnt-1; } for (l=0;l<=rrdnew.rra_ptr[target_rra].cur_row;l++) { unsigned int tmp; for (tmp=0;tmp<rrdnew.stat_head->ds_cnt;tmp++) { fread(&buffer,sizeof(rrd_value_t),1,infile); fwrite(&buffer,sizeof(rrd_value_t),1,outfile); } } while (modify<0) { fseek(infile,sizeof(rrd_value_t)*rrdnew.stat_head->ds_cnt,SEEK_CUR); rrdnew.rra_def[target_rra].row_cnt--; modify++; } } /* Move the rest of the CDPs */ while (1) { fread(&buffer,sizeof(rrd_value_t),1,infile); if (feof(infile)) break; fwrite(&buffer,sizeof(rrd_value_t),1,outfile); } rrdnew.rra_def[target_rra].row_cnt += modify; fseek(outfile,sizeof(stat_head_t)+sizeof(ds_def_t)*rrdnew.stat_head->ds_cnt,SEEK_SET); fwrite(rrdnew.rra_def,sizeof(rra_def_t),rrdnew.stat_head->rra_cnt, outfile); fseek(outfile,sizeof(live_head_t),SEEK_CUR); fseek(outfile,sizeof(pdp_prep_t)*rrdnew.stat_head->ds_cnt,SEEK_CUR); fseek(outfile,sizeof(cdp_prep_t)*rrdnew.stat_head->ds_cnt*rrdnew.stat_head->rra_cnt,SEEK_CUR); fwrite(rrdnew.rra_ptr,sizeof(rra_ptr_t),rrdnew.stat_head->rra_cnt, outfile); fclose(outfile); rrd_free(&rrdold); fclose(infile); return(0); }
int mca_io_base_delete(const char *filename, struct opal_info_t *info) { int err; opal_list_t *selectable; opal_list_item_t *item; avail_io_t *avail, selected; /* Announce */ opal_output_verbose(10, ompi_io_base_framework.framework_output, "io:base:delete: deleting file: %s", filename); /* See if a set of component was requested by the MCA parameter. Don't check for error. */ /* Compute the intersection of all of my available components with the components from all the other processes in this file */ /* JMS CONTINUE HERE */ /* See if there were any listed in the MCA parameter; parse them and check them all */ err = OMPI_ERROR; opal_output_verbose(10, ompi_io_base_framework.framework_output, "io:base:delete: Checking all available modules"); selectable = check_components(&ompi_io_base_framework.framework_components, filename, info, NULL, 0); /* Upon return from the above, the modules list will contain the list of modules that returned (priority >= 0). If we have no io modules available, it's an error */ if (NULL == selectable) { /* There's no modules available. Doh! */ /* show_help */ return OMPI_ERROR; } /* Do some kind of collective operation to find a module that everyone has available */ #if 1 /* For the moment, just take the top module off the list */ /* MSC actually take the buttom */ item = opal_list_remove_last(selectable); avail = (avail_io_t *) item; selected = *avail; OBJ_RELEASE(avail); #else /* JMS CONTINUE HERE */ #endif /* Everything left in the selectable list is therefore unwanted, and we call their unquery() method (because they all had query() invoked, but will never have init() invoked in this scope). */ for (item = opal_list_remove_first(selectable); item != NULL; item = opal_list_remove_first(selectable)) { avail = (avail_io_t *) item; unquery(avail, filename, info); OBJ_RELEASE(item); } OBJ_RELEASE(selectable); if (!strcmp (selected.ai_component.v2_0_0.io_version.mca_component_name, "ompio")) { int ret; opal_mutex_lock(&ompi_mpi_ompio_bootstrap_mutex); if (OMPI_SUCCESS != (ret = mca_base_framework_open(&ompi_fs_base_framework, 0))) { opal_mutex_unlock(&ompi_mpi_ompio_bootstrap_mutex); return err; } opal_mutex_unlock(&ompi_mpi_ompio_bootstrap_mutex); if (OMPI_SUCCESS != (ret = mca_fs_base_find_available(OPAL_ENABLE_PROGRESS_THREADS, 1))) { return err; } } /* Finally -- delete the file with the selected component */ if (OMPI_SUCCESS != (err = delete_file(&selected, filename, info))) { return err; } /* Announce the winner */ opal_output_verbose(10, ompi_io_base_framework.framework_output, "io:base:delete: Selected io component %s", selected.ai_component.v2_0_0.io_version.mca_component_name); return OMPI_SUCCESS; }
void makeCuts(const IloNumVarArray vars, IloExprArray lhs, IloNumArray rhs) { IloNumVar x11, x12, x13, x14, x15; IloNumVar x21, x22, x23, x24, x25; IloNumVar x31, x32, x33, x34, x35; IloNumVar x41, x42, x43, x44, x45; IloNumVar x51, x52, x53, x54, x55; IloNumVar w11, w12, w13, w14, w15; IloNumVar w21, w22, w23, w24, w25; IloNumVar w31, w32, w33, w34, w35; IloNumVar w41, w42, w43, w44, w45; IloNumVar w51, w52, w53, w54, w55; IloInt num = vars.getSize(); for (IloInt i = 0; i < num; i++) { if ( strcmp(vars[i].getName(), "X11") == 0 ) x11 = vars[i]; else if ( strcmp(vars[i].getName(), "X12") == 0 ) x12 = vars[i]; else if ( strcmp(vars[i].getName(), "X13") == 0 ) x13 = vars[i]; else if ( strcmp(vars[i].getName(), "X14") == 0 ) x14 = vars[i]; else if ( strcmp(vars[i].getName(), "X15") == 0 ) x15 = vars[i]; else if ( strcmp(vars[i].getName(), "X21") == 0 ) x21 = vars[i]; else if ( strcmp(vars[i].getName(), "X22") == 0 ) x22 = vars[i]; else if ( strcmp(vars[i].getName(), "X23") == 0 ) x23 = vars[i]; else if ( strcmp(vars[i].getName(), "X24") == 0 ) x24 = vars[i]; else if ( strcmp(vars[i].getName(), "X25") == 0 ) x25 = vars[i]; else if ( strcmp(vars[i].getName(), "X31") == 0 ) x31 = vars[i]; else if ( strcmp(vars[i].getName(), "X32") == 0 ) x32 = vars[i]; else if ( strcmp(vars[i].getName(), "X33") == 0 ) x33 = vars[i]; else if ( strcmp(vars[i].getName(), "X34") == 0 ) x34 = vars[i]; else if ( strcmp(vars[i].getName(), "X35") == 0 ) x35 = vars[i]; else if ( strcmp(vars[i].getName(), "X41") == 0 ) x41 = vars[i]; else if ( strcmp(vars[i].getName(), "X42") == 0 ) x42 = vars[i]; else if ( strcmp(vars[i].getName(), "X43") == 0 ) x43 = vars[i]; else if ( strcmp(vars[i].getName(), "X44") == 0 ) x44 = vars[i]; else if ( strcmp(vars[i].getName(), "X45") == 0 ) x45 = vars[i]; else if ( strcmp(vars[i].getName(), "X51") == 0 ) x51 = vars[i]; else if ( strcmp(vars[i].getName(), "X52") == 0 ) x52 = vars[i]; else if ( strcmp(vars[i].getName(), "X53") == 0 ) x53 = vars[i]; else if ( strcmp(vars[i].getName(), "X54") == 0 ) x54 = vars[i]; else if ( strcmp(vars[i].getName(), "X55") == 0 ) x55 = vars[i]; else if ( strcmp(vars[i].getName(), "W11") == 0 ) w11 = vars[i]; else if ( strcmp(vars[i].getName(), "W12") == 0 ) w12 = vars[i]; else if ( strcmp(vars[i].getName(), "W13") == 0 ) w13 = vars[i]; else if ( strcmp(vars[i].getName(), "W14") == 0 ) w14 = vars[i]; else if ( strcmp(vars[i].getName(), "W15") == 0 ) w15 = vars[i]; else if ( strcmp(vars[i].getName(), "W21") == 0 ) w21 = vars[i]; else if ( strcmp(vars[i].getName(), "W22") == 0 ) w22 = vars[i]; else if ( strcmp(vars[i].getName(), "W23") == 0 ) w23 = vars[i]; else if ( strcmp(vars[i].getName(), "W24") == 0 ) w24 = vars[i]; else if ( strcmp(vars[i].getName(), "W25") == 0 ) w25 = vars[i]; else if ( strcmp(vars[i].getName(), "W31") == 0 ) w31 = vars[i]; else if ( strcmp(vars[i].getName(), "W32") == 0 ) w32 = vars[i]; else if ( strcmp(vars[i].getName(), "W33") == 0 ) w33 = vars[i]; else if ( strcmp(vars[i].getName(), "W34") == 0 ) w34 = vars[i]; else if ( strcmp(vars[i].getName(), "W35") == 0 ) w35 = vars[i]; else if ( strcmp(vars[i].getName(), "W41") == 0 ) w41 = vars[i]; else if ( strcmp(vars[i].getName(), "W42") == 0 ) w42 = vars[i]; else if ( strcmp(vars[i].getName(), "W43") == 0 ) w43 = vars[i]; else if ( strcmp(vars[i].getName(), "W44") == 0 ) w44 = vars[i]; else if ( strcmp(vars[i].getName(), "W45") == 0 ) w45 = vars[i]; else if ( strcmp(vars[i].getName(), "W51") == 0 ) w51 = vars[i]; else if ( strcmp(vars[i].getName(), "W52") == 0 ) w52 = vars[i]; else if ( strcmp(vars[i].getName(), "W53") == 0 ) w53 = vars[i]; else if ( strcmp(vars[i].getName(), "W54") == 0 ) w54 = vars[i]; else if ( strcmp(vars[i].getName(), "W55") == 0 ) w55 = vars[i]; } lhs.add(x21 - x22); rhs.add(0.0); lhs.add(x22 - x23); rhs.add(0.0); lhs.add(x23 - x24); rhs.add(0.0); lhs.add(2.08*x11 + 2.98*x21 + 3.47*x31 + 2.24*x41 + 2.08*x51 + 0.25*w11 + 0.25*w21 + 0.25*w31 + 0.25*w41 + 0.25*w51); rhs.add(20.25); lhs.add(2.08*x12 + 2.98*x22 + 3.47*x32 + 2.24*x42 + 2.08*x52 + 0.25*w12 + 0.25*w22 + 0.25*w32 + 0.25*w42 + 0.25*w52); rhs.add(20.25); lhs.add(2.08*x13 + 2.98*x23 + 3.47*x33 + 2.24*x43 + 2.08*x53 + 0.25*w13 + 0.25*w23 + 0.25*w33 + 0.25*w43 + 0.25*w53); rhs.add(20.25); lhs.add(2.08*x14 + 2.98*x24 + 3.47*x34 + 2.24*x44 + 2.08*x54 + 0.25*w14 + 0.25*w24 + 0.25*w34 + 0.25*w44 + 0.25*w54); rhs.add(20.25); lhs.add(2.08*x15 + 2.98*x25 + 3.47*x35 + 2.24*x45 + 2.08*x55 + 0.25*w15 + 0.25*w25 + 0.25*w35 + 0.25*w45 + 0.25*w55); rhs.add(16.25); }
int main() { system("title 60_Cascallar_Autrán_Manuel"); FILE *fich; ///////////////////////////////////////////////ler datos do ficheiro fich=fopen("59.dat","rb"); if(!fich) { printf("ERRO! o ficheiro non se puido abrir\n"); system("pause"); return 1; } int x=0; struct datos baloncesto; struct novos partidos[32]= {0}; int h=0; int t=0; int cont=0; int i; do { fread(&baloncesto, sizeof(struct datos), 1,fich); if(!feof(fich)) { h=0; t=0; for(i=0; i<cont; i++) { if(strcmp(partidos[i].equipo,baloncesto.local)==0) { h=1; if(baloncesto.plocal>baloncesto.pvisit) partidos[i].ganados++; if(baloncesto.plocal<baloncesto.pvisit) partidos[i].perdidos++; } if(strcmp(partidos[i].equipo,baloncesto.visitante)==0) { t=1; if(baloncesto.pvisit>baloncesto.plocal) partidos[i].ganados++; if(baloncesto.pvisit<baloncesto.plocal) partidos[i].perdidos++; } } if(h==0) { strcpy(partidos[cont].equipo,baloncesto.local); if(baloncesto.plocal>baloncesto.pvisit) partidos[cont].ganados++; if(baloncesto.plocal<baloncesto.pvisit) partidos[cont].perdidos++; cont++; } if(t==0) { strcpy(partidos[cont].equipo,baloncesto.visitante); if(baloncesto.pvisit>baloncesto.plocal) partidos[cont].ganados++; if(baloncesto.pvisit<baloncesto.plocal) partidos[cont].perdidos++; cont++; } } } while(!feof(fich)); //comprobar os equipos e os partidos ganados e perdidos por cada un deles. for(i=0; i<cont; i++) { printf("%40s %3d %3d\n",partidos[i].equipo,partidos[i].ganados,partidos[i].perdidos); } system("pause"); //fechar o ficheiro if(fclose(fich)) { printf("ERRO! O ficheiro non puido ser cerrado\n"); system("pause"); return 1; } ////////////////////////////////////////////////////////Introducir datos no ficheiro fich=fopen("60.txt","w"); if(!fich) { printf("ERRO! o ficheiro non se puido abrir\n"); system("pause"); return 1; } //introducir os partidos coas suas respectivas cantidades de partidos ganados e perdidos for(x=0; partidos[x].equipo[0]!=0; x++) { fprintf(fich,"%40s %3d %3d\n",partidos[x].equipo,partidos[x].ganados,partidos[x].perdidos); } if(fclose(fich)) { printf("ERRO! O ficheiro non puido ser cerrado\n"); system("pause"); return 1; } }
// 配置环境变量,创建子进程,执行cgi程序 void execute_cgi(int client, const char *path, const char *method, const char *query_string) { char buf[1024]; int cgi_output[2]; int cgi_input[2]; pid_t pid; int status; int i; char c; int numchars = 1; int content_length = -1; buf[0] = 'A'; buf[1] = '\0'; if (strcasecmp(method, "GET") == 0) // GET while ((numchars > 0) && strcmp("\n", buf)) /* read & discard headers */ numchars = get_line(client, buf, sizeof(buf)); // 只处理了请求首行,忽略后面的请求头 else /* POST */ { numchars = get_line(client, buf, sizeof(buf)); // 读取请求头中的header属性 while ((numchars > 0) && strcmp("\n", buf)) { buf[15] = '\0'; if (strcasecmp(buf, "Content-Length:") == 0) // Content-Length:后面的数字切出来 content_length = atoi(&(buf[16])); numchars = get_line(client, buf, sizeof(buf)); } if (content_length == -1) { // Content-Length获取失败,该请求有问题 bad_request(client); // 400 return; } } sprintf(buf, "HTTP/1.0 200 OK\r\n"); // 响应首行 send(client, buf, strlen(buf), 0); if (pipe(cgi_output) < 0) { // 打开管道 cannot_execute(client); return; } if (pipe(cgi_input) < 0) { // 打开管道 cannot_execute(client); return; } if ( (pid = fork()) < 0 ) { // 创建子进程 cannot_execute(client); return; } if (pid == 0) /* child: CGI script */ { // 子进程开始执行 char meth_env[255]; char query_env[255]; char length_env[255]; dup2(cgi_output[1], 1); // 复制到标准输出 dup2(cgi_input[0], 0); // 复制到标准输入 close(cgi_output[0]); close(cgi_input[1]); // 关闭不需要的描述符 // 添加几个环境变量 sprintf(meth_env, "REQUEST_METHOD=%s", method); putenv(meth_env); if (strcasecmp(method, "GET") == 0) { sprintf(query_env, "QUERY_STRING=%s", query_string); putenv(query_env); } else { /* POST */ sprintf(length_env, "CONTENT_LENGTH=%d", content_length); putenv(length_env); } // 准备工作完毕,开始执行cgi程序 execl(path, path, NULL); exit(0); } else { /* parent */ // 父进程代码 close(cgi_output[1]); close(cgi_input[0]); // 关闭不需要的描述符 if (strcasecmp(method, "POST") == 0) for (i = 0; i < content_length; i++) { recv(client, &c, 1, 0); write(cgi_input[1], &c, 1); // 读取剩下的请求头写给子进程的cgi程序 } while (read(cgi_output[0], &c, 1) > 0) send(client, &c, 1, 0); // 读取cgi程序的输出发送给客户端 close(cgi_output[0]); close(cgi_input[1]); // 使用完毕,关闭描述符 waitpid(pid, &status, 0); // 等待子进程退出 } }
main(int argc, char *argv[]) { FILE *fp, *outFile; int i; int unix2Dos; prog = argv[0]; /* program name as called */ unix2Dos = 1; i = 1; if (argc > 1) { if (strcmp(argv[1], "--help") == 0) { usage(); } else if (strcmp(argv[1], "--dos2unix") == 0) { unix2Dos = 0; } else if (strcmp(argv[1], "--unix2dos") == 0) { unix2Dos = 1; } else { usage(); } } else usage(); i ++; if (i == argc) translate(stdin, stdout, unix2Dos); else { while (i < argc) { char tmpFile[512]; sprintf(tmpFile, "%s.tmp", argv[i]); fp = fopen(argv[i], "rb"); if (!fp) { fprintf(stderr, "Cannot open %s.\n", argv[i]); i ++; continue; } outFile = fopen(tmpFile, "wb"); if (!outFile) { fprintf(stderr, "Cannot open %s.\n", tmpFile); exit(1); } translate(fp, outFile, unix2Dos); if (warning) /* unix2dos acting on a possible DOS file */ { fprintf(stderr,"%s: %s may have already been in DOS format. Not converted.\n", prog, argv[i]); warning = 0; } fclose(fp); fclose(outFile); #ifdef _WINDOWS remove(argv[i]); #else unlink(argv[i]); #endif rename(tmpFile, argv[i]); i ++; } } }
bool BinkPlayer::loadFile(const Common::String &filename) { _fname = filename; if (_demo) { // The demo uses a .lab suffix _fname += ".lab"; return MoviePlayer::loadFile(_fname); } _fname += ".m4b"; Common::SeekableReadStream *stream = SearchMan.createReadStreamForMember(_fname); if (!stream) { warning("BinkPlayer::loadFile(): Can't create stream for: %s", _fname.c_str()); return false; } // set the default start of the bink video in case there is no SMUSH header uint32 startBinkPos = 0x0; // clear existing subtitles _subtitles.clear(); char header[6]; // read the first 5 bytes of the header stream->read(header, 5); header[5] = 0; if (!strcmp(header, "SMUSH")) { // handle SMUSH header unsigned char smushHeader[0x2000]; // read the first part uint32 consumed = 16; stream->read(smushHeader, consumed); // decode the first part for (unsigned int i = 0; i < consumed; i++) { smushHeader[i] ^= 0xd2; } Common::MemoryReadStream msStart(smushHeader, consumed); TextSplitter tsStart("", &msStart); // extract the length / the start of the following BINK header tsStart.scanString("%d", 1, &startBinkPos); assert(startBinkPos < sizeof(smushHeader)); // read the rest (5 bytes less because of the string "SMUSH" at the beginning) stream->read(smushHeader+consumed, startBinkPos - consumed - 5); // decode the reset for (unsigned int i = consumed; i < startBinkPos - 5; i++) { smushHeader[i] ^= 0xd2; } consumed = startBinkPos - 5; Common::MemoryReadStream msSmush(smushHeader, consumed); TextSplitter tsSmush("", &msSmush); // skip the first line which contains the length tsSmush.nextLine(); tsSmush.expectString("BEGINDATA"); while (!tsSmush.checkString("ENDOFDATA")) { unsigned int start, end; char textId[256]; // extract single subtitle entry tsSmush.scanString("%d\t%d\t%s", 3, &start, &end, textId); Subtitle st(start, end, textId); _subtitles.push_back(st); } tsSmush.expectString("ENDOFDATA"); } // set current subtitle index to the first subtitle _subtitleIndex = _subtitles.begin(); if (!bikCheck(stream, startBinkPos)) { warning("BinkPlayer::loadFile(): Could not find BINK header for: %s", _fname.c_str()); delete stream; return false; } Common::SeekableReadStream *bink = nullptr; bink = new Common::SeekableSubReadStream(stream, startBinkPos, stream->size(), DisposeAfterUse::YES); _videoDecoder->setDefaultHighColorFormat(Graphics::PixelFormat(4, 8, 8, 8, 0, 8, 16, 24, 0)); return _videoDecoder->loadStream(bink); }