void analyse_function(Function *f, sym_table *prog, char *scope_id, int line_no) { //Find the scope of the function scope *called = find_scope(f->id, prog); //Find the scope if (!called) { //Ooops this is an error. Report it. print_undefined_proc_call_error(f, line_no); isValid = FALSE; return; } Params *fcallee = (Params *) called->params; Exprs *fcaller = f->args; //Check number of variables int call_no = count_list((void *)fcaller); int expect_no = count_list((void *)fcallee); if (call_no != expect_no) { print_func_pmismatch_error(f, fcallee, line_no, expect_no, call_no); isValid = FALSE; } else { //Go through each variable and try match. We know these are the same //lenght now. int par_num = 1; while (fcallee != NULL) { Expr *e = fcaller->first; Param *p = fcallee->first; Type caller = get_expr_type(e, NULL, prog, scope_id, line_no); if (caller != p->type && p->ind == VAL_IND) { if ((caller == INT_TYPE) && (p->type == FLOAT_TYPE)) { // This is valid, we can cast an int val into a float val } else { //Then the parameter calls are incorrect print_func_ptype_error(par_num, caller, p->type, f, line_no); isValid = FALSE; } } else if (caller != p->type && p->ind == REF_IND) { if ((caller == FLOAT_TYPE) && (p->type == INT_TYPE)) { // This is valid, we can cast an int into a float to store // in the ref. } else { //Then the parameter calls are incorrect print_func_ptype_error(par_num, caller, p->type, f, line_no); isValid = FALSE; } } else if (caller != p->type && caller != INVALID_TYPE) { //Then the parameter calls are incorrect print_func_ptype_error(par_num, caller, p->type, f, line_no); isValid = FALSE; } fcallee = fcallee->rest; fcaller = fcaller->rest; par_num ++; } } }
write_hooks (FILE *inf, FILE *outf) { char *p, buf[1024]; struct id *newid; struct id *constructors = 0; struct id *destructors = 0; while (! feof (inf)) { /* Read a line of nm output and strip the trailing newline. */ fgets (buf, sizeof buf, inf); p = buf + strlen (buf) - 1; if (*p == '\n') *p = '\0'; /* If it contains a constructor or destructor name, add the name to the appropriate list. */ for (p = buf; *p; p++) { while (*p && *p != '_') p++; if (! strncmp (p, "_GLOBAL_$I$", 11)) { newid = alloca (sizeof *newid); newid->name = alloca (strlen (p) + 1); strcpy (newid->name, p); newid->next = constructors; constructors = newid; break; } else if (! strncmp (p, "_GLOBAL_$D$", 11)) { newid = alloca (sizeof *newid); newid->name = alloca (strlen (p) + 1); strcpy (newid->name, p); newid->next = destructors; destructors = newid; break; } } } /* Write the tables. */ fprintf (outf, "%s\n", TEXT_SECTION_ASM_OP); ASM_GLOBALIZE_LABEL (outf, "__CTOR_LIST__"); ASM_OUTPUT_LABEL (outf, "__CTOR_LIST__"); ASM_OUTPUT_INT (outf, count_list (constructors)); write_list (outf, constructors); fprintf (outf, "%s\n", DATA_SECTION_ASM_OP); ASM_GLOBALIZE_LABEL (outf, "__DTOR_LIST__"); ASM_OUTPUT_LABEL (outf, "__DTOR_LIST__"); ASM_OUTPUT_INT (outf, count_list (destructors)); write_list (outf, destructors); ASM_OUTPUT_INT (outf, 0); }
static long procinfo_ioctl(struct file *f, unsigned int cmd, unsigned long arg) #endif { procinfo_t info; procinfo_arg_t *info_arg; struct task_struct *task; pid_t pid; switch (cmd) { case GET_PROCINFO: info_arg = (procinfo_arg_t *) arg; pid = info_arg->pid; if (pid > 0) { task = pid_task(find_vpid(pid), PIDTYPE_PID); } else if (pid == 0) { task = current; } else if (pid < 0) { task = current->parent; } if (task == NULL) { return -EINVAL; } info.pid = task->pid; info.ppid = task->parent->pid; info.start_time = task->start_time; info.num_sib = count_list(&task->sibling); if (copy_to_user(info_arg->info, &info, sizeof(procinfo_t))) { return -EACCES; } break; default: return -EINVAL; } return 0; }
static void jffs2_rotate_lists(struct jffs2_sb_info *c) { uint32_t x; x = count_list(&c->clean_list); if (x) rotate_list((&c->clean_list), pseudo_random % x); x = count_list(&c->dirty_list); if (x) rotate_list((&c->dirty_list), pseudo_random % x); if (c->nr_erasing_blocks) rotate_list((&c->erase_pending_list), pseudo_random % c->nr_erasing_blocks); if (c->nr_free_blocks) /* Not that it should ever be zero */ rotate_list((&c->free_list), pseudo_random % c->nr_free_blocks); }
BOOL validate_array_dims(Expr *e, char *scope_id, sym_table *table) { symbol *asym = retrieve_symbol(e->id, scope_id, table); if (asym == NULL) { //Array has not been defined return FALSE; } else { Decl *d = (Decl *) asym->sym_value; return count_array(d->array) == count_list(e->indices); } }
void jffs2_rotate_lists(struct jffs2_sb_info *c) { uint32_t x; uint32_t rotateby; x = count_list(&c->clean_list); if (x) { rotateby = pseudo_random % x; rotate_list((&c->clean_list), rotateby); } x = count_list(&c->very_dirty_list); if (x) { rotateby = pseudo_random % x; rotate_list((&c->very_dirty_list), rotateby); } x = count_list(&c->dirty_list); if (x) { rotateby = pseudo_random % x; rotate_list((&c->dirty_list), rotateby); } x = count_list(&c->erasable_list); if (x) { rotateby = pseudo_random % x; rotate_list((&c->erasable_list), rotateby); } if (c->nr_erasing_blocks) { rotateby = pseudo_random % c->nr_erasing_blocks; rotate_list((&c->erase_pending_list), rotateby); } if (c->nr_free_blocks) { rotateby = pseudo_random % c->nr_free_blocks; rotate_list((&c->free_list), rotateby); } }
void jffs2_rotate_lists(struct jffs2_sb_info *c) { uint32_t x; uint32_t rotateby; x = count_list(&c->clean_list); if (x) { rotateby = pseudo_random % x; D1(printk(KERN_DEBUG "Rotating clean_list by %d\n", rotateby)); rotate_list((&c->clean_list), rotateby); D1(printk(KERN_DEBUG "Erase block at front of clean_list is at %08x\n", list_entry(c->clean_list.next, struct jffs2_eraseblock, list)->offset)); } else {
void rd_particle_specs(FILE *ifp, char *input) { PBC_t *PBC; char err_msg[MAX_CHAR_ERR_MSG], s_tmp[SLEN], s_tmp_save[SLEN_2], *s_ptr1, *s_ptr2; int i, j, iread; iread = look_for_optional(ifp, "Particle Specifications", input, '='); if(iread != 1) { Particle_Dynamics = 0; Particle_Number_Sample_Types = 0; Particle_Number_Samples_Existing = NULL; Particle_Number_Samples = NULL; Particle_Number_Output_Variables = NULL; Particle_Output_Variables = NULL; Particle_Filename_Template = NULL; Particle_Number_PBCs = 0; PBCs = NULL; return; } printf("\n--- Particle specifications ---\n"); Particle_Dynamics = 1; /* turn on particle dynamics */ /* What kind of particle model do you want? This determines all * kinds of things, such as FEM<->particle coupling, particle * trajectory calculation, etc. */ look_for(ifp, "Particle model", input, '='); if(!fgets(s_tmp, SLEN-1, ifp)) EH(-1, "Error reading Particle model card."); strip(s_tmp); /* s_tmp still has '\n' at end */ if(s_tmp[strlen(s_tmp)-1] == '\n') s_tmp[strlen(s_tmp)-1] = 0; strcpy(s_tmp_save, s_tmp); s_ptr1 = strpbrk(s_tmp_save, " \t\n"); if(s_ptr1 != NULL) s_ptr1[0] = 0; if(!strncmp("INERTIAL_TRACER_EXPLICIT", s_tmp, 24)) Particle_Model = INERTIAL_TRACER_EXPLICIT; else if(!strncmp("INERTIAL_TRACER_IMPLICIT", s_tmp, 24)) Particle_Model = INERTIAL_TRACER_IMPLICIT; else if(!strncmp("TRACER_EXPLICIT", s_tmp, 15)) Particle_Model = TRACER_EXPLICIT; else if(!strncmp("TRACER_IMPLICIT", s_tmp, 15)) Particle_Model = TRACER_IMPLICIT; else if(!strncmp("SWIMMER_EXPLICIT", s_tmp, 16)) Particle_Model = SWIMMER_EXPLICIT; else if(!strncmp("SWIMMER_IMPLICIT", s_tmp, 16)) Particle_Model = SWIMMER_IMPLICIT; else if(!strncmp("CHARGED_TRACER_EXPLICIT", s_tmp, 23)) Particle_Model = CHARGED_TRACER_EXPLICIT; else if(!strncmp("CHARGED_TRACER_IMPLICIT", s_tmp, 23)) Particle_Model = CHARGED_TRACER_IMPLICIT; else if(!strncmp("DIELECTROPHORETIC_TRACER_IMPLICIT", s_tmp, 33)) Particle_Model = DIELECTROPHORETIC_TRACER_IMPLICIT; else { sprintf(s_tmp_save, "Unknown Particle model: %s\n", s_tmp); EH(-1, s_tmp_save); } printf("Setting Particle_Model = %s\n", s_tmp_save); switch(Particle_Model) { case INERTIAL_TRACER_IMPLICIT: case INERTIAL_TRACER_EXPLICIT: s_ptr1 = s_tmp + 24; if(!(s_ptr2 = strtok(s_ptr1, " \t\n"))) { sprintf(err_msg, "Error reading random walk coefficient for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[0] = atof(s_ptr2); printf("Setting random walk coefficient = %g\n", Particle_Model_Data[0]); if(!(s_ptr2 = strtok(NULL, " \t\n"))) { sprintf(err_msg, "Error reading gravity coefficient for %s particle_model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[1] = atof(s_ptr2); printf("Setting gravity coefficient = %g\n", Particle_Model_Data[1]); break; case TRACER_EXPLICIT: case TRACER_IMPLICIT: s_ptr1 = s_tmp + 15; if(!(s_ptr2 = strtok(s_ptr1, " \t\n"))) { sprintf(err_msg, "Error reading random walk coefficient for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[0] = atof(s_ptr2); printf("Setting random walk coefficient = %g\n", Particle_Model_Data[0]); break; case SWIMMER_EXPLICIT: case SWIMMER_IMPLICIT: s_ptr1 = s_tmp + 16; if(!(s_ptr2 = strtok(s_ptr1, " \t\n"))) { sprintf(err_msg, "Error reading random swimming speed coefficient for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[0] = atof(s_ptr2); printf("Setting random swimming speed coefficient = %g\n", Particle_Model_Data[0]); if(!(s_ptr2 = strtok(NULL, " \t\n"))) { sprintf(err_msg, "Error reading random cell orientation coefficient for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[1] = atof(s_ptr2); printf("Setting random cell orientation coefficient = %g\n", Particle_Model_Data[1]); if(!(s_ptr2 = strtok(NULL, " \t\n"))) { sprintf(err_msg, "Error reading upswimming speed for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[2] = atof(s_ptr2); printf("Setting particle upswimming speed = %g\n", Particle_Model_Data[2]); break; case CHARGED_TRACER_EXPLICIT: case CHARGED_TRACER_IMPLICIT: s_ptr1 = s_tmp + 23; if(!(s_ptr2 = strtok(s_ptr1, " \t\n"))) { sprintf(err_msg, "Error reading random walk coefficient for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[0] = atof(s_ptr2); printf("Setting random walk coefficient = %g\n", Particle_Model_Data[0]); if(!(s_ptr2 = strtok(NULL, " \t\n"))) { sprintf(err_msg, "Error reading charge coefficient for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[1] = atof(s_ptr2); printf("Setting charge coefficient = %g\n", Particle_Model_Data[1]); break; case DIELECTROPHORETIC_TRACER_IMPLICIT: s_ptr1 = s_tmp + 33; if(!(s_ptr2 = strtok(s_ptr1, " \t\n"))) { sprintf(err_msg, "Error reading random walk coefficient for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[0] = atof(s_ptr2); printf("Setting random walk coefficient = %g\n", Particle_Model_Data[0]); if(!(s_ptr2 = strtok(NULL, " \t\n"))) { sprintf(err_msg, "Error reading particle permittivity for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[1] = atof(s_ptr2); printf("Setting particle permittivity = %g\n", Particle_Model_Data[1]); if(!(s_ptr2 = strtok(NULL, " \t\n"))) { sprintf(err_msg, "Error reading medium (fluid) permittivity for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[2] = atof(s_ptr2); printf("Setting medium (fluid) permittivity = %g\n", Particle_Model_Data[2]); if(!(s_ptr2 = strtok(NULL, " \t\n"))) { sprintf(err_msg, "Error reading particle conductivity for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[3] = atof(s_ptr2); printf("Setting particle conductivity = %g\n", Particle_Model_Data[3]); if(!(s_ptr2 = strtok(NULL, " \t\n"))) { sprintf(err_msg, "Error reading medium (fluid) conductivity for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[4] = atof(s_ptr2); printf("Setting medium (fluid) conductivity = %g\n", Particle_Model_Data[4]); if(!(s_ptr2 = strtok(NULL, " \t\n"))) { sprintf(err_msg, "Error reading AC angular frequency for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[5] = atof(s_ptr2); printf("Setting AC angular frequency = %g\n", Particle_Model_Data[5]); if(!(s_ptr2 = strtok(NULL, " \t\n"))) { sprintf(err_msg, "Error reading Volt conversion factor for %s particle model.", s_tmp); EH(-1, err_msg); } Particle_Model_Data[6] = atof(s_ptr2); printf("Setting Volt conversion factor = %g\n", Particle_Model_Data[6]); break; default: EH(-1, "How'd you get here?"); } /* Get maximum number of particle time steps if we're running after * a steady-state solution... */ if(TimeIntegration == STEADY) { if(look_for_optional(ifp, "Time steps", input, '=') == 1) { if(fscanf(ifp, "%d", &Particle_Max_Time_Steps) != 1) EH(-1, "Error reading Time steps card for post-steady problem."); printf("Setting Particle_Max_Time_Steps = %d\n", Particle_Max_Time_Steps); } else Particle_Max_Time_Steps = 0; } else if(look_for_optional(ifp, "Time steps", input, '=') == 1) printf("CAUTION: ignoring Time steps card for transient problem."); /* How many particles would you like? For now, they are always * introduced unformly throughout the domain. */ look_for(ifp, "Number of particles", input, '='); if(fscanf(ifp, "%d", &Particle_Number) != 1) EH(-1, "Error reading Number of particles card."); printf("Setting Particle_Number = %d\n", Particle_Number); if(look_for_optional(ifp, "Restart file", input, '=') == 1) { char file_name_temp[MAX_PARTICLE_FILENAME_LENGTH]; if(!fgets(file_name_temp, MAX_PARTICLE_FILENAME_LENGTH, ifp)) EH(-1, "Error reading Restart file card."); strip(file_name_temp); strncpy(Particle_Restart_Filename, file_name_temp, MAX_PARTICLE_FILENAME_LENGTH); printf("Restart file = %s\n", Particle_Restart_Filename); } else sprintf(Particle_Restart_Filename, "<not active>"); /* When to output particle information. There are two ways to * specify this, and they are incompatible (i.e., only one can be * specified). Either you can output particles every so many Goma * time steps, or you can have particles output every so often * time-wise (e.g., every 0.1 seconds), whether within a Goma time * step or containing many Goma time steps.*/ if(look_for_optional(ifp, "Output stride", input, '=') == 1) { if(fscanf(ifp, "%d", &Particle_Output_Stride) != 1) EH(-1, "Error reading Output stride card."); printf("Setting Particle_Output_Stride = %d\n", Particle_Output_Stride); } else Particle_Output_Stride = -1; if(look_for_optional(ifp, "Output time step", input, '=') == 1) { if(fscanf(ifp, "%lf", &Particle_Output_Time_Step) != 1) EH(-1, "Error reading Output time step card."); printf("Setting Particle_Output_Time_Step = %g\n", Particle_Output_Time_Step); if(Particle_Output_Stride != -1) EH(-1, "You cannot specify both Output stride and Output time step."); } else Particle_Output_Time_Step = 0.0; if(Particle_Output_Stride == -1 && Particle_Output_Time_Step == 0.0) EH(-1, "One of the Output stride or Output time step cards must be present."); if(look_for_optional(ifp, "Output format", input, '=') == 1) { if(!fgets(s_tmp, SLEN-1, ifp)) EH(-1, "Error reading Output format card."); strip(s_tmp); /* s_tmp still has '\n' at end -- don't care. */ if(!strncmp("TECPLOT", s_tmp, 7)) Particle_Output_Format = TECPLOT; else if(!strncmp("FLAT_TEXT", s_tmp, 9)) Particle_Output_Format = FLAT_TEXT; else { sprintf(s_tmp_save, "Unknown Output format: %s\n", s_tmp); EH(-1, s_tmp_save); } } else Particle_Output_Format = FLAT_TEXT; if(look_for_optional(ifp, "Particle density", input, '=') == 1) { if(fscanf(ifp, "%lf", &Particle_Density) != 1) EH(-1, "Error reading Particle density card."); } else Particle_Density = 1.0; printf("Setting Particle_Density = %g\n", Particle_Density); if(look_for_optional(ifp, "Particle radius", input, '=') == 1) { if(fscanf(ifp, "%lf", &Particle_Radius) != 1) EH(-1, "Error reading Particle radius card."); } else Particle_Radius = 1.0; printf("Setting Particle_Radius = %g\n", Particle_Radius); if(Particle_Radius <= 0.0) EH(-1, "Particle radius must be > 0.0. Non-inertial tracer particles will ignore this setting."); if(look_for_optional(ifp, "Particle ratio", input, '=') == 1) { if(fscanf(ifp, "%lf", &Particle_Ratio) != 1) EH(-1, "Error reading Particle ratio card."); } else Particle_Ratio = 1.0; printf("Setting Particle_Ratio = %g\n", Particle_Ratio); Particle_Show_Debug_Info = 0; if(look_for_optional(ifp, "Show particle debug info", input, '=') == 1) { if(fscanf(ifp, "%s", s_tmp) != 1) EH(-1, "Need yes or no for Show particle debug info card."); if(!strncmp(s_tmp, "YES", 3)) { Particle_Show_Debug_Info = 1; printf("Showing particle debug info\n"); } } if(!Particle_Show_Debug_Info) printf("Not showing particle debug info\n"); /* Initialization for particle creation and move domains. */ for(i = 0; i < MAX_DOMAIN_REAL_VALUES; i++) { Particle_Creation_Domain_Reals[i] = 1.0e+10; Particle_Move_Domain_Reals[i] = 1.0e+10; } Particle_Creation_Domain = UNRESTRICTED; Particle_Move_Domain = UNRESTRICTED; sprintf(Particle_Creation_Domain_Filename, "<not active>"); sprintf(Particle_Creation_Domain_Name, "<not active>"); sprintf(Particle_Move_Domain_Filename, "<not active>"); sprintf(Particle_Move_Domain_Name, "<not active>"); /* Set optional creation domain. */ if(look_for_optional(ifp, "Particle creation domain", input, '=') == 1) { if(fscanf(ifp, "%s", s_tmp) != 1) EH(-1, "Error reading Particle creation domain card."); if(!strncmp(s_tmp, "BRICK", 5)) { Particle_Creation_Domain = BRICK; if(fscanf(ifp, "%lf %lf %lf %lf %lf %lf\n", &Particle_Creation_Domain_Reals[0], &Particle_Creation_Domain_Reals[1], &Particle_Creation_Domain_Reals[2], &Particle_Creation_Domain_Reals[3], &Particle_Creation_Domain_Reals[4], &Particle_Creation_Domain_Reals[5]) != 6) EH(-1, "Error reading min/max values on Particle creation domain card."); printf("Using BRICK creation domain with x in [%g,%g], y in [%g,%g], z in [%g,%g]\n", Particle_Creation_Domain_Reals[0], Particle_Creation_Domain_Reals[1], Particle_Creation_Domain_Reals[2], Particle_Creation_Domain_Reals[3], Particle_Creation_Domain_Reals[4], Particle_Creation_Domain_Reals[5]); } else if(!strncmp(s_tmp, "ACIS", 4)) { EH(-1, "CGM not supported, ACIS"); } else { sprintf(err_msg, "Error reading Particle creation domain card, unknown domain type: %s.", s_tmp); EH(-1, err_msg); } } else printf("Using unrestricted Particle_Creation_Domain\n"); /* Set optional move domain. */ if(look_for_optional(ifp, "Particle move domain", input, '=') == 1) { if(fscanf(ifp, "%s", s_tmp) != 1) EH(-1, "Error reading Particle move domain card."); if(!strncmp(s_tmp, "BRICK", 5)) { Particle_Move_Domain = BRICK; if(fscanf(ifp, "%lf %lf %lf %lf %lf %lf\n", &Particle_Move_Domain_Reals[0], &Particle_Move_Domain_Reals[1], &Particle_Move_Domain_Reals[2], &Particle_Move_Domain_Reals[3], &Particle_Move_Domain_Reals[4], &Particle_Move_Domain_Reals[5]) != 6) EH(-1, "Error reading min/max values on Particle move domain card."); printf("Using BRICK move domain with x in [%g,%g], y in [%g,%g], z in [%g,%g]\n", Particle_Move_Domain_Reals[0], Particle_Move_Domain_Reals[1], Particle_Move_Domain_Reals[2], Particle_Move_Domain_Reals[3], Particle_Move_Domain_Reals[4], Particle_Move_Domain_Reals[5]); } else if(!strncmp(s_tmp, "ACIS", 4)) { EH(-1, "Need the CGM library to use ACIS for Particle creation domain card."); } else { sprintf(err_msg, "Error reading Particle move domain card, unknown domain type: %s.", s_tmp); EH(-1, err_msg); } } else printf("Using unrestricted Particle_Move_Domain\n"); /* This is used for restarts, too, and ignores output file type. If * we're a steady-state Goma calculation, then this applies to the * particle timesteps taken afterwards. If this is a transient Goma * calculation, then this is a multiple of Goma steps. In * particular, if particles are output on a time strided basis, that * will be ignored here. */ if(look_for_optional(ifp, "Full output stride", input, '=') == 1) { char file_name_temp[MAX_PARTICLE_FILENAME_LENGTH]; if(fscanf(ifp, "%d", &Particle_Full_Output_Stride) != 1) EH(-1, "Problem reading Full output stride card."); if(!fgets(file_name_temp, MAX_PARTICLE_FILENAME_LENGTH, ifp)) EH(-1, "Problem reading Full output stride card."); strip(file_name_temp); strncpy(Particle_Full_Output_Filename, file_name_temp, MAX_PARTICLE_FILENAME_LENGTH); printf("Setting full output every %d steps to file %s\n", Particle_Full_Output_Stride, Particle_Full_Output_Filename); } else { Particle_Full_Output_Stride = 0; sprintf(Particle_Full_Output_Filename, "<not active>"); } /* General description for number of particles to track, and how * many of them. Can specify multiple selections, and the particles * will be separate samples. Subject to total number of particles, * of course... */ look_for(ifp, "Number of sample types", input, '='); if(fscanf(ifp, "%d", &Particle_Number_Sample_Types) != 1) EH(-1, "Problem reading Number of sample types card."); printf("Setting Particle_Number_Sample_Types = %d\n", Particle_Number_Sample_Types); if(Particle_Number_Sample_Types) { Particle_Number_Samples_Existing = (int *)array_alloc(1, Particle_Number_Sample_Types, sizeof(int)); Particle_Number_Samples = (int *)array_alloc(1, Particle_Number_Sample_Types, sizeof(int)); Particle_Number_Output_Variables = (int *)array_alloc(1, Particle_Number_Sample_Types, sizeof(int)); Particle_Output_Variables = (particle_variable_s **) array_alloc(1, Particle_Number_Sample_Types, sizeof(particle_variable_s *)); Particle_Filename_Template = (particle_filename_s *)array_alloc(1, Particle_Number_Sample_Types, sizeof(particle_filename_s)); } else { Particle_Number_Samples_Existing = NULL; Particle_Number_Samples = NULL; Particle_Number_Output_Variables = NULL; Particle_Output_Variables = NULL; Particle_Filename_Template = NULL; } for(i = 0; i < Particle_Number_Sample_Types; i++) { look_for(ifp, "Sample", input, '='); if(fscanf(ifp, "%d", &Particle_Number_Samples[i]) != 1) EH(-1, "Error reading number of particle samples."); if(Particle_Number_Samples[i] > 0) printf("Sample %d contains %d particles", i, Particle_Number_Samples[i]); else EH(-1, "Number of particle samples must be > 0."); if(!fgets(s_tmp, SLEN-1, ifp)) EH(-1, "Error reading sample variables and filename."); strncpy(s_tmp_save, s_tmp, SLEN); Particle_Number_Output_Variables[i] = 0; s_ptr1 = strtok(s_tmp, " \t\n"); while((s_ptr1 = strtok(NULL, " \t\n"))) Particle_Number_Output_Variables[i]++; s_ptr1 = strtok(s_tmp_save, " \t\n"); if(Particle_Number_Output_Variables[i] > 0) { printf(" tracking variable(s)"); Particle_Output_Variables[i] = (particle_variable_s *)calloc(Particle_Number_Output_Variables[i], sizeof(particle_variable_s)); /* Particle_Output_Variables[i] = (char **)array_alloc(1, Particle_Number_Output_Variables[i], sizeof(char *)); */ for(j = 0; j < Particle_Number_Output_Variables[i]; j++) { if(strlen(s_ptr1) + 1 > MAX_PARTICLE_OUTPUT_VARIABLE_LENGTH) EH(-1, "Increase MAX_PARTICLE_OUTPUT_VARIABLE_LENGTH"); strncpy(Particle_Output_Variables[i][j], s_ptr1, strlen(s_ptr1) + 1); printf(" %s", Particle_Output_Variables[i][j]); s_ptr1 = strtok(NULL, " \t\n"); } } if(strlen(s_ptr1) + 1 > MAX_PARTICLE_FILENAME_LENGTH) EH(-1, "Increase MAX_PARTICLE_FILENAME_LENGTH"); strncpy(Particle_Filename_Template[i], s_ptr1, strlen(s_ptr1) + 1); Particle_Filename_Template[i][strlen(s_ptr1)] = 0; printf(" to file %s.\n", Particle_Filename_Template[i]); } iread = look_for_optional(ifp, "START OF PBC", input, '='); if(iread == 1) { Particle_Number_PBCs = count_list(ifp, "PBC", input, '=', "END OF PBC"); printf("Found %d PBC's\n", Particle_Number_PBCs); PBCs = (PBC_t *)calloc(Particle_Number_PBCs, sizeof(PBC_t)); for(i = 0; i < Particle_Number_PBCs; i++) { PBC = &PBCs[i]; look_for(ifp, "PBC", input, '='); if(fscanf(ifp, "%80s", input) != 1) EH(-1, "Error reading PBC."); stringup(input); /* I know it is stupid to do this for an unnecssary token, * but it makes the input look better... */ if(fscanf(ifp, "%s", s_tmp) != 1) EH(-1, "Missing SS token on PBC card."); if(strncmp(s_tmp, "SS", 2)) EH(-1, "Missing SS token on PBC card."); if(fscanf(ifp, "%d", &(PBC->SS_id)) != 1) EH(-1, "Error reading SS_id on PBC card."); if(!strncmp(input, "OUTFLOW", 7)) { PBC->type = PBC_OUTFLOW; puts("Found an OUTFLOW PBC."); } else if(!strncmp(input, "SOURCE", 6)) { PBC->type = PBC_SOURCE; if(fscanf(ifp, "%lf", &(PBC->real_data[0])) != 1) EH(-1, "Error reading SS specification and float on PBC = SOURCE card."); printf("Found a SOURCE PBC with source = %g.\n", PBC->real_data[0]); } else if(!strncmp(input, "TARGET", 6)) { PBC->type = PBC_TARGET; if(fscanf(ifp, "%s", s_tmp) != 1) EH(-1, "Missing filename on PBC TARGET card."); if(strlen(s_tmp) + 1 > MAX_PBC_STRING_DATA_LENGTH) EH(-1, "Increase MAX_PBC_STRING_DATA_LENGTH"); strncpy(PBC->string_data, s_tmp, strlen(s_tmp) + 1); printf("Found a TARGET PBC with filename = '%s'.\n", PBC->string_data); } else if(!strncmp(input, "FREESTREAM_SOURCE", 17)) { PBC->type = PBC_FREESTREAM_SOURCE; if(fscanf(ifp, "%lf", &(PBC->real_data[0])) != 1) EH(-1, "Error reading SS specification and float on PBC = FREESTREAM_SOURCE card."); printf("Found a FREESTREAM_SOURCE PBC with source = %g.\n", PBC->real_data[0]); } else if(!strncmp(input, "IMPERMEABLE", 11)) { PBC->type = PBC_IMPERMEABLE; if(fscanf(ifp, "%lf", &(PBC->real_data[0])) != 1) EH(-1, "Error reading distance factor on PBC = IMPERMEABLE card."); if(!fgets(s_tmp, SLEN-1, ifp)) EH(-1, "Error reading geometry entity name on PBC = IMPERMEABLE card."); strip(s_tmp); if(s_tmp[strlen(s_tmp)-1] == '\n') s_tmp[strlen(s_tmp)-1] = 0; if(strlen(s_tmp) + 1 > MAX_PBC_STRING_DATA_LENGTH) EH(-1, "Increase MAX_PBC_STRING_DATA_LENGTH"); strncpy(PBC->string_data, s_tmp, strlen(s_tmp) + 1); printf("Found an IMPERMEABLE PBC with distance factor = %g to entity '%s'.\n", PBC->real_data[0], PBC->string_data); } else EH(-1, "Error reading PBC type."); } } else { Particle_Number_PBCs = 0; PBCs = NULL; } }
static int http_github(http_connection_t *hc, const char *remain, void *opaque) { const char *pid = http_arg_get(&hc->hc_req_args, "project"); const char *key = http_arg_get(&hc->hc_req_args, "key"); if(pid == NULL) { trace(LOG_WARNING, "github: Missing 'project' in request"); return 400; } if(key == NULL) { trace(LOG_WARNING, "github: Missing 'key' in request"); return 400; } project_cfg(pc, pid); if(pc == NULL) { trace(LOG_DEBUG, "github: Project '%s' not configured", pid); return 404; } const char *mykey = cfg_get_str(pc, CFG("github", "key"), ""); if(strcmp(mykey, key)) { trace(LOG_WARNING, "github: Invalid key received (%s) for project %s", key, pid); return 403; } project_t *p = project_get(pid); const char *json = http_arg_get(&hc->hc_req_args, "payload"); if(json == NULL) { plog(p, "github", "github: Missing payload in request"); return 400; } char errbuf[256]; htsmsg_t *msg = htsmsg_json_deserialize(json, errbuf, sizeof(errbuf)); if(msg == NULL) { plog(p, "github", "github: Malformed JSON in github request -- %s", errbuf); return 400; } const char *ref = htsmsg_get_str(msg, "ref"); if(ref != NULL && !strncmp(ref, "refs/heads/", strlen("refs/heads/"))) ref += strlen("refs/heads/"); htsmsg_t *list = htsmsg_get_list(msg, "commits"); if(ref != NULL && list != NULL) { htsmsg_field_t *f; HTSMSG_FOREACH(f, list) { htsmsg_t *c = htsmsg_get_map_by_field(f); if(c == NULL) continue; const char *url = htsmsg_get_str(c, "url"); const char *msg = htsmsg_get_str(c, "message"); htsmsg_t *a = htsmsg_get_map(c, "author"); const char *author = a ? htsmsg_get_str(a, "name") : NULL; int added = count_list(c, "added"); int removed = count_list(c, "removed"); int modified = count_list(c, "modified"); int len; char buf[512]; char ctx[128]; url = url ? urlshorten(url) : NULL; snprintf(ctx, sizeof(ctx), "changes/%s", ref); len = snprintf(buf, sizeof(buf), "Commit in '"COLOR_BLUE"%s"COLOR_OFF"' by "COLOR_PURPLE"%s"COLOR_OFF" [", ref, author ?: "???"); if(added) len += snprintf(buf + len, sizeof(buf) - len, COLOR_GREEN "%d file%s added", added, added == 1 ? "" : "s"); if(modified) len += snprintf(buf + len, sizeof(buf) - len, COLOR_YELLOW "%s%d file%s modified", added ? ", " : "", modified, modified == 1 ? "" : "s"); if(removed) len += snprintf(buf + len, sizeof(buf) - len, COLOR_RED "%s%d file%s removed", added || modified ? ", " : "", removed, removed == 1 ? "" : "s"); snprintf(buf + len, sizeof(buf) - len, COLOR_OFF"]%s%s", url ? " " : "", url ?: ""); plog(p, ctx, "%s", buf); plog(p, ctx, "%s", msg); }
Type get_expr_type(Expr *e, Expr *parent, sym_table *table, char *scope_id, int line_no) { //Find the type of an expression ExprKind kind = e->kind; // Switch on kind to print switch (kind) { case EXPR_ID: //Find the symbol and get it's type if (retrieve_symbol(e->id, scope_id, table)) { //Lets check the type Type t = get_type(retrieve_symbol(e->id, scope_id, table)); e->inferred_type = t; return t; } else { //Not good. Let the user know. print_undefined_variable_error(e, parent, line_no); isValid = FALSE; e->inferred_type = INVALID_TYPE; return INVALID_TYPE; } break; case EXPR_CONST: if (e != NULL) { //f**k c. Type t = get_const_type(e); e->inferred_type = t; return t; } break; case EXPR_BINOP: //We need the types of each expression //Then we determine the type if allowed using the binop return get_binop_type(get_expr_type(e->e1, e, table, scope_id, line_no), get_expr_type(e->e2, e, table, scope_id, line_no), e->binop, line_no, e); break; case EXPR_UNOP: //Get the type of the expression //Then we determine the type if allowed using the binop return get_unop_type(get_expr_type(e->e1, e, table, scope_id, line_no), e->unop, line_no, e); break; case EXPR_ARRAY: //We need to check array dimensions, then check all expressions are //int equiv. if (validate_array_dims(e, scope_id, table)) { symbol *a = retrieve_symbol(e->id, scope_id, table); validate_array_indices(e->indices, e->id, line_no, table, scope_id, a); e->inferred_type = get_type(a); return e->inferred_type; } else { symbol *a = retrieve_symbol(e->id, scope_id, table); if (a != NULL) { // Now check if a is an array if (a->bounds == NULL) { print_not_array_error(e, a->sym_value, line_no); } else { Decl *d = (Decl *) a->sym_value; print_array_dims_error(e, count_array(d->array), count_list(e->indices), line_no); } isValid = FALSE; } else { print_undefined_variable_error(e, NULL, line_no); isValid = FALSE; } e->inferred_type = INVALID_TYPE; return INVALID_TYPE; } return INVALID_TYPE; break; } return INVALID_TYPE; }
static struct EvalError *check_stdmacro( enum StandardMacro stdmacro, struct Expression *args, size_t n) { size_t length; struct Expression expr; struct Set *set; switch (stdmacro) { case F_DEFINE: case F_SET: if (args[0].type != E_SYMBOL) { return new_eval_error_expr(ERR_TYPE_VAR, args[0]); } break; case F_LAMBDA: expr = args[0]; if (expr.type != E_NULL && expr.type != E_PAIR && expr.type != E_SYMBOL) { return new_syntax_error(expr); } set = new_set(); while (expr.type != E_NULL) { InternId symbol_id; if (expr.type == E_PAIR) { if (expr.box->car.type != E_SYMBOL) { free_set(set); return new_eval_error_expr(ERR_TYPE_VAR, expr.box->car); } symbol_id = expr.box->car.symbol_id; } else if (expr.type == E_SYMBOL) { symbol_id = expr.symbol_id; } else { free_set(set); return new_eval_error_expr(ERR_TYPE_VAR, expr); } if (!add_to_set(set, symbol_id)) { free_set(set); return attach_code( new_eval_error_symbol(ERR_DUP_PARAM, symbol_id), args[0]); } if (expr.type == E_SYMBOL) { break; } expr = expr.box->cdr; } free_set(set); break; case F_UNQUOTE: case F_UNQUOTE_SPLICING: return new_eval_error(ERR_UNQUOTE); case F_COND: for (size_t i = 0; i < n; i++) { if (!count_list(&length, args[i]) || length < 2) { return new_syntax_error(args[i]); } } break; case F_LET: case F_LET_STAR: expr = args[0]; set = new_set(); while (expr.type != E_NULL) { if (expr.type == E_PAIR) { if (!count_list(&length, expr.box->car) || length != 2) { free_set(set); return new_syntax_error(expr.box->car); } if (expr.box->car.box->car.type != E_SYMBOL) { free_set(set); return new_eval_error_expr( ERR_TYPE_VAR, expr.box->car.box->car); } } else { free_set(set); return new_syntax_error(args[0]); } InternId symbol_id = expr.box->car.box->car.symbol_id; if (!add_to_set(set, symbol_id)) { free_set(set); return attach_code( new_eval_error_symbol(ERR_DUP_PARAM, symbol_id), args[0]); } expr = expr.box->cdr; } free_set(set); break; default: break; } return NULL; }
static struct EvalError *check_stdproc( enum StandardProcedure stdproc, struct Expression *args, size_t n) { switch (stdproc) { case S_APPLY:; Arity arity; if (!expression_arity(&arity, args[0])) { return new_eval_error_expr(ERR_TYPE_OPERATOR, args[0]); } size_t length; if (!count_list(&length, args[n-1])) { return new_syntax_error(args[n-1]); } size_t n_args = length + n - 2; if (!arity_allows(arity, n_args)) { return new_arity_error(arity, n_args); } break; case S_MACRO: if (args[0].type != E_STDPROCEDURE && args[0].type != E_PROCEDURE) { return new_type_error(E_PROCEDURE, args, 0); } break; case S_NUM_EQ: case S_NUM_LT: case S_NUM_GT: case S_NUM_LE: case S_NUM_GE: case S_ADD: case S_SUB: case S_MUL: case S_EXPT: case S_INTEGER_TO_CHAR: case S_NUMBER_TO_STRING: for (size_t i = 0; i < n; i++) { CHECK_TYPE(E_NUMBER, i); } break; case S_DIV: case S_REMAINDER: case S_MODULO: for (size_t i = 0; i < n; i++) { CHECK_TYPE(E_NUMBER, i); if (i > 0 && args[i].number == 0) { // This is not technically a type error, but this is the // earliest and most convenient place to catch it. return new_eval_error(ERR_DIV_ZERO); } } break; case S_CAR: case S_CDR: case S_SET_CAR: case S_SET_CDR: CHECK_TYPE(E_PAIR, 0); break; case S_STRING_LENGTH: case S_STRING_EQ: case S_STRING_LT: case S_STRING_GT: case S_STRING_LE: case S_STRING_GE: case S_STRING_COPY: case S_STRING_APPEND: case S_STRING_TO_SYMBOL: case S_STRING_TO_NUMBER: case S_LOAD: for (size_t i = 0; i < n; i++) { CHECK_TYPE(E_STRING, i); } break; case S_MAKE_STRING: CHECK_TYPE(E_NUMBER, 0); CHECK_TYPE(E_CHARACTER, 1); if (args[0].number < 0) { return new_eval_error_expr(ERR_NEGATIVE_SIZE, args[0]); } break; case S_STRING_REF: CHECK_TYPE(E_STRING, 0); CHECK_TYPE(E_NUMBER, 1); CHECK_RANGE(0, 1); break; case S_STRING_SET: CHECK_TYPE(E_STRING, 0); CHECK_TYPE(E_NUMBER, 1); CHECK_TYPE(E_CHARACTER, 2); CHECK_RANGE(0, 1); break; case S_SUBSTRING: CHECK_TYPE(E_STRING, 0); CHECK_TYPE(E_NUMBER, 1); CHECK_TYPE(E_NUMBER, 2); CHECK_RANGE(0, 1); CHECK_RANGE(0, 2); break; case S_STRING_FILL: CHECK_TYPE(E_STRING, 0); CHECK_TYPE(E_CHARACTER, 1); break; case S_CHAR_EQ: case S_CHAR_LT: case S_CHAR_GT: case S_CHAR_LE: case S_CHAR_GE: case S_CHAR_TO_INTEGER: for (size_t i = 0; i < n; i++) { CHECK_TYPE(E_CHARACTER, i); } break; case S_SYMBOL_TO_STRING: CHECK_TYPE(E_SYMBOL, 0); break; default: break; } return NULL; }
static int pop3_slowuidl( int sock, struct query *ctl, int *countp, int *newp) { /* XXX FIXME: this code is severely broken. A Cc:d mailing list * message will arrive twice with the same Message-ID, so this * slowuidl code will break. Same goes for messages without * Message-ID headers at all. This code would best be removed. */ /* This approach tries to get the message headers from the * remote hosts and compares the message-id to the already known * ones: * + if the first message containes a new id, all messages on * the server will be new * + if the first is known, try to estimate the last known message * on the server and check. If this works you know the total number * of messages to get. * + Otherwise run a binary search to determine the last known message */ int ok, nolinear = 0; int first_nr, list_len, try_id, try_nr, add_id; int num; char id [IDLEN+1]; if ((ok = pop3_gettopid(sock, 1, id, sizeof(id))) != 0) return ok; if( ( first_nr = str_nr_in_list(&ctl->oldsaved, id) ) == -1 ) { /* the first message is unknown -> all messages are new */ *newp = *countp; return 0; } /* check where we expect the latest known message */ list_len = count_list( &ctl->oldsaved ); try_id = list_len - first_nr; /* -1 + 1 */ if( try_id > 1 ) { if( try_id <= *countp ) { if ((ok = pop3_gettopid(sock, try_id, id, sizeof(id))) != 0) return ok; try_nr = str_nr_last_in_list(&ctl->oldsaved, id); } else { try_id = *countp+1; try_nr = -1; } if( try_nr != list_len -1 ) { /* some messages inbetween have been deleted... */ if( try_nr == -1 ) { nolinear = 1; for( add_id = 1<<30; add_id > try_id-1; add_id >>= 1 ) ; for( ; add_id; add_id >>= 1 ) { if( try_nr == -1 ) { if( try_id - add_id <= 1 ) { continue; } try_id -= add_id; } else try_id += add_id; if ((ok = pop3_gettopid(sock, try_id, id, sizeof(id))) != 0) return ok; try_nr = str_nr_in_list(&ctl->oldsaved, id); } if( try_nr == -1 ) { try_id--; } } else { report(stderr, GT_("Messages inserted into list on server. Cannot handle this.\n")); return -1; } }