自学教程：C++ t_error函数代码示例

void update_roughness_veg(double hc, double snowD, double zmu, double zmt, double *z0_ris, double *d0_ris, double *hc_ris){			*hc_ris=hc-snowD;//[mm]	*d0_ris=0.667*(*hc_ris);//[mm]	//*hc_ris=hc;//[mm]	//*d0_ris=0.0;//[mm]	*z0_ris=0.1*(*hc_ris);//[mm]		*d0_ris=(*d0_ris)*1.E-3;//[m]	*z0_ris=(*z0_ris)*1.E-3;//[m]	*hc_ris=(*hc_ris)*1.E-3;//[m]		if(zmu<(*hc_ris)){		printf("Wind speed measurement height:%f m/n",zmu);		printf("Effective vegetation height:%f m/n",*hc_ris);		t_error("Temperatute must be measured above vegetation");	}	if(zmt<(*hc_ris)){		printf("Temperature measurement height:%f m/n",zmu);		printf("Effective vegetation height:%f m/n",*hc_ris);		t_error("Temperatute must be measured above vegetation");	}		if(*hc_ris-(*d0_ris)<(*z0_ris)){		printf("Effective vegetation height:%f m/n",*hc_ris);		printf("Effective 0 displacement height:%f m/n",*d0_ris);		printf("Effective roughness length:%f m/n",*z0_ris);		t_error("It must be always Hcanopy-d0 >= z0");	}}

void Businger(short a, double zmu, double zmt, double d0, double z0, double v, double T, double DT, double DQ, double z0_z0t, 			  double *rm, double *rh, double *rv, double *Lobukhov, long maxiter){	double L, cm, u_star=0., ch, T_star=0., cv, Q_star=0.;	double z0v, z0t, z0q;	long cont;	double tol;		FILE *f;		//first guess of Obukhov length	if(DT<0){		L=1.E5;	}else{		L=-1.E5;	}	cont=0;	tol=1.0E99;	do{			if(cont>0) tol=10*T_star+100*u_star+1000*Q_star;					//Conductances		Star(a, zmu, z0, d0, L, 0.0, v, 1.0, 0.0, 1.0, &u_star, &cm, &z0v, (*Psim), (*roughT));	//momentum		if(z0_z0t==0.0){	//rigid surface			Star(a, zmt, z0, d0, L, u_star, DT, u_star*z0/1.4E-5, 1.0, 0.0, &T_star, &ch, &z0t, (*Psih), (*roughT)); //heat flux			Star(a, zmt, z0, d0, L, u_star, DQ, u_star*z0/1.4E-5, 1.0, 0.0, &Q_star, &cv, &z0q, (*Psih), (*roughQ)); //water vapour flux		}else{	//bending surface			Star(a, zmt, z0, d0, L, u_star, DT, 1.0, 0.0, 1.0/z0_z0t, &T_star, &ch, &z0t, (*Psih), (*roughT)); //heat flux			Star(a, zmt, z0, d0, L, u_star, DQ, 1.0, 0.0, 1.0/z0_z0t, &Q_star, &cv, &z0q, (*Psih), (*roughQ)); //water vapour flux		}		//Obukhov length		L=-u_star*u_star*(T+tk)/(ka*g*(T_star-0.61*Q_star*(T+tk)));						cont++;	}while(fabs(100*T_star+100*u_star+1000*Q_star-tol)>0.01 && cont<=maxiter);		if(d0>zmu || d0>zmt){		f = fopen(FailedRunFile, "w");		fprintf(f,"Error:: Displacement height greater than measurement elevations/n");		fclose(f);		t_error("Fatal Error! Geotop is closed. See failing report.");		}	if(zmu<=z0 || zmt<=z0t || zmt<=z0q){		f = fopen(FailedRunFile, "w");		fprintf(f,"Error:: Elevation of sensors lower than roughness length: zmu=%f zmt=%f z0=%f z0t=%f/n",zmu,zmt,z0,z0t);		fclose(f);		t_error("Fatal Error! Geotop is closed. See failing report.");		}	*rm=cm*cm/(ka*ka*v);	*rh=ch*cm/(ka*ka*v);	*rv=cv*cm/(ka*ka*v);		*Lobukhov=L;	}

int main(void){	enum {n = 8*1024*1024};	char *s = malloc(n);	int i;	float f;	char c;	if (!s)		return t_error("out of memory");	t_setrlim(RLIMIT_STACK, 100*1024);	for (i = 0; i < n; i++) s[i] = '1';	s[n-3] = ' ';	s[n-1] = 0;	/*	 * stack overflow if scanf copies s on the stack (glibc)	 * same issue with %d except then storing the conversion	 * result is undefined behaviour	 */	i = sscanf(s, "%f %c", &f, &c);	if (i != 2)		t_error("sscanf returned %d, want 2/n", i);	if (f != INFINITY)		t_error("sscanf(longnum, /"%%f/") read %f, want inf/n", f);	if (c != '1')		t_error("sscanf(/"1/", %%c) read '%c', want '1'/n", c);	free(s);	return t_status;}

static void test_align(int dalign, int salign, int len){	char *src = aligned(buf);	char *dst = aligned(buf + 128);	char *want = aligned(buf + 256);	char *p;	int i;	if (salign + len > N || dalign + len > N)		abort();	for (i = 0; i < N; i++) {		src[i] = '#';		dst[i] = want[i] = ' ';	}	for (i = 0; i < len; i++)		src[salign+i] = want[dalign+i] = '0'+i;	p = pmemcpy(dst+dalign, src+salign, len);	if (p != dst+dalign)		t_error("memcpy(%p,...) returned %p/n", dst+dalign, p);	for (i = 0; i < N; i++)		if (dst[i] != want[i]) {			t_error("memcpy(align %d, align %d, %d) failed/n", dalign, salign, len);			t_printf("got : %.*s/n", dalign+len+1, dst);			t_printf("want: %.*s/n", dalign+len+1, want);			break;		}}

/*----------------------------------------------------------------------------------*/double doublevector_correlation(DOUBLEVECTOR *v,DOUBLEVECTOR *u,double m1,double m2,long r,double novalue){	long i,n=0;	float correlation=0;if(v==NULL || v->co==NULL || u==NULL || u->co==NULL ){	t_error("this vector was never allocated");} else if(v->nh <1 ||  v->isdynamic !=1 || u->nh <1 ||  u->isdynamic !=1) {	t_error("this vector was not properly allocated");}	for(i=1;i<v->nh-r;i++){		    			if(v->co[i]!=novalue && v->co[i]!=novalue){			 	correlation+=v->co[i]*u->co[i+r];				n++;			}	}	return correlation/n -m1*m2;}

int main(void){	static const long lim = 42;	static const int r = RLIMIT_NOFILE;	struct rlimit rl;	int fd, maxfd = 0;	rl.rlim_max = lim;	rl.rlim_cur = lim;	if (setrlimit(r, &rl))		t_error("setrlimit(%d, %ld) failed: %s/n", r, lim, strerror(errno));	if (getrlimit(r, &rl))		t_error("getrlimit(%d) failed: %s/n", r, strerror(errno));	if (rl.rlim_max != lim || rl.rlim_cur != lim)		t_error("getrlimit %d says cur=%ld,max=%ld after setting the limit to %ld/n", r, rl.rlim_cur, rl.rlim_max, lim);	while((fd=dup(1)) != -1)		if (fd > maxfd) maxfd = fd;	if (errno != EMFILE)		t_error("dup(1) failed with %s, wanted EMFILE/n", strerror(errno));	if (maxfd+1 != lim)		t_error("more fds are open than rlimit allows: fd=%d, limit=%d/n", maxfd, lim);	return t_status;}

    void visitSelfCall(SelfCall *p) {      p->visit_children(this);      Symbol * symp;      MethodIDImpl * MethIdP = dynamic_cast<MethodIDImpl*>(p->m_methodid);      Basetype bargs;      char * key = strdup(MethIdP->m_symname->spelling());      symp = InScope(key);       // cout<<"After scope "<<key<<endl;      std::vector<CompoundType> args;      if(symp == NULL){        t_error(no_class_method,p->m_attribute);      }      // cout<< "the key is: "<<key<<endl;      int i = 0;      if((p->m_expression_list->size()) != symp->methodType.argsType.size()) {          t_error(call_narg_mismatch, p->m_attribute);}      typename std::list<Expression_ptr>::iterator it = p->m_expression_list->begin();       for( ; it != p->m_expression_list->end(); ++it) {        Expression * Expoin = dynamic_cast<Expression *> (*it);         bargs = symp->methodType.argsType[i].baseType;         if(bargs != Expoin->m_attribute.m_type.baseType)            t_error(call_args_mismatch, p->m_attribute);        i++;        }      p->m_attribute.m_type.baseType = symp->baseType;      //WRITE ME    }

/*... Double precision variables' vector n-moment estimation  */float floatmatrix_n_moment(FLOATMATRIX *m, float mean,float NN, float novalue){	long i,j;	float  moment=0, n;if(m==NULL || m->co==NULL ){	t_error("this matrix was never allocated");} else if(m->nrh <1 || m->nch <1 || m->isdynamic !=1) {	t_error("this matrix was not properly allocated");}n=0;if(NN==1){	for(i=1;i<m->nrh;i++){		for(j=1;j<m->nch;j++){		    			if(m->co[i][j]!=novalue){ 				moment+=m->co[i][j];				n++;			}			}	}moment/=n;}else if(NN==2) { 	for(i=1;i<m->nrh;i++){		for(j=1;j<m->nch;j++){		    			if(m->co[i][j]!=novalue) {				moment+=(m->co[i][j])*(m->co[i][j]);				n++;			}			}	} moment=(moment/n-mean*mean);}else {		for(i=1;i<m->nrh;i++){		for(j=1;j<m->nch;j++){		    			if(m->co[i][j]!=novalue){				moment+=pow((m->co[i][j]-mean),NN);	        	n++;	        }		}	}	moment/=n;}	return moment;}

/*----------------------------------------------------------------------------------------------------------*/double decod(char *ch, long n, double ndef){	short sgn=0;	long i,ibeg,idec,j;	double a=0;	if(ch[0]==42 || ch[0]==44 || ch[0]==-1 || ch[0]==10 || ch[0]==13){		a=ndef;	}else{		i=-1;		do{			i+=1;		}while((ch[i]<46 || ch[i]==47 || ch[i]>57) && (i<n-1));		if((i==n-1) && (ch[i]<46 || ch[i]==47 || ch[i]>57)){			a=ndef;		}else{			ibeg=i;			if(ibeg>0){				if(ch[ibeg-1]==45) sgn=1;			}			i-=1;			do{				i+=1;			}while(ch[i]!=46 && (i<n-1));			if(ch[i]==46){				idec=i;			}else{				idec=n;			}			/*if(i!=n-1){				do{					i+=1;					if(ch[i]<48 || ch[i]>57) t_error("ERROR: NUMBER WRITTEN IN A NON-STANDARD FORM");				}while(i<n-1);			}*/			j=0;			for(i=idec-1;i>=ibeg;i--){				if(ch[i]>=48 && ch[i]<=57){					a+=(ch[i]-48)*pow(10.0,(double)(idec-i-1-j));				}else{					j+=1;					if(ch[i]==69) t_error("ERROR:IT IS NOT POSSIBLE TO WRITE NUMBERS IN THE EXPONENTIAL FORMAT");				}			}			j=0;			for(i=idec+1;i<n;i++){				if(ch[i]>=48 && ch[i]<=57){					a+=(ch[i]-48)*pow(10.0,(double)(idec-i+j));				}else{					j+=1;					if(ch[i]==69) t_error("ERROR:IT IS NOT POSSIBLE TO WRITE NUMBERS IN THE EXPONENTIAL FORMAT");				}			}			if(sgn==1) a*=(-1);		}	}	return(a);}

 void visitAnd(And *p) {   p->m_attribute.m_type.baseType = bt_boolean;   p->visit_children(this);   if(p->m_expression_1->m_attribute.m_type.baseType != 2)     t_error(expr_type_err, p->m_expression_1->m_attribute);    if(p->m_expression_2->m_attribute.m_type.baseType != 2)     t_error(expr_type_err, p->m_expression_2->m_attribute);            //WRITE ME      //WRITE ME }

 void visitLessThanEqualTo(LessThanEqualTo *p) {   p->m_attribute.m_type.baseType = bt_boolean;   p->visit_children(this);   if(p->m_expression_1->m_attribute.m_type.baseType != 1)       t_error(expr_type_err, p->m_expression_1->m_attribute);   if(p->m_expression_2->m_attribute.m_type.baseType != 1)       t_error(expr_type_err, p->m_expression_2->m_attribute);            //WRITE ME }

 void visitDivide(Divide *p) {   p->m_attribute.m_type.baseType = bt_integer;   p->visit_children(this);   if(p->m_expression_1->m_attribute.m_type.baseType != 1)     t_error(expr_type_err, p->m_expression_1->m_attribute);   if(p->m_expression_2->m_attribute.m_type.baseType != 1)     t_error(expr_type_err, p->m_expression_2->m_attribute);            //WRITE ME }

int main(void){	int i, j, k;	char b[2000];	TEST(i, snprintf(0, 0, "%d", 123456), 6, "length returned %d != %d");	TEST(i, snprintf(0, 0, "%.4s", "hello"), 4, "length returned %d != %d");	TEST(i, snprintf(b, 0, "%.0s", "goodbye"), 0, "length returned %d != %d");	strcpy(b, "xxxxxxxx");	TEST(i, snprintf(b, 4, "%d", 123456), 6, "length returned %d != %d");	TEST_S(b, "123", "incorrect output");	TEST(i, b[5], 'x', "buffer overrun");	/* Perform ascii arithmetic to test printing tiny doubles */	TEST(i, snprintf(b, sizeof b, "%.1022f", 0x1p-1021), 1024, "%d != %d");	b[1] = '0';	for (i=0; i<1021; i++) {		for (k=0, j=1023; j>0; j--) {			if (b[j]<'5') b[j]+=b[j]-'0'+k, k=0;			else b[j]+=b[j]-'0'-10+k, k=1;		}	}	TEST(i, b[1], '1', "'%c' != '%c'");	for (j=2; b[j]=='0'; j++);	TEST(i, j, 1024, "%d != %d");#ifndef DISABLE_SLOW_TESTS	errno = 0;	TEST(i, snprintf(NULL, 0, "%.*u", 2147483647, 0), 2147483647, "cannot print max length %d");	TEST(i, snprintf(NULL, 0, "%.*u ", 2147483647, 0), -1, "integer overflow %d");	TEST(i, errno, EOVERFLOW, "after overflow: %d != %d");#endif	for (j=0; int_tests[j].fmt; j++) {		i = snprintf(b, sizeof b, int_tests[j].fmt, int_tests[j].i);		if (i != strlen(int_tests[j].expect)) {			t_error("snprintf(b, sizeof b, /"%s/", %d) returned %d wanted %d/n",				int_tests[j].fmt, int_tests[j].i, i, strlen(int_tests[j].expect));		}		if (strcmp(b, int_tests[j].expect) != 0)			t_error("bad integer conversion: got /"%s/", want /"%s/"/n", b, int_tests[j].expect);	}	for (j=0; fp_tests[j].fmt; j++) {		i = snprintf(b, sizeof b, fp_tests[j].fmt, fp_tests[j].f);		if (i != strlen(fp_tests[j].expect)) {			t_error("snprintf(b, sizeof b, /"%s/", %f) returned %d wanted %d/n",				fp_tests[j].fmt, fp_tests[j].f, i, strlen(fp_tests[j].expect));		}		if (strcmp(b, fp_tests[j].expect) != 0)			t_error("bad floating-point conversion: got /"%s/", want /"%s/"/n", b, fp_tests[j].expect);	}	TEST(i, snprintf(0, 0, "%.4a", 1.0), 11, "%d != %d");	return t_status;}

static void *f(void *arg){	if (tls_fix != 23)		t_error("fixed init failed: want 23 got %d/n", tls_fix);	if (tls_zero != 0)		t_error("zero init failed: want 0 got %d/n", tls_zero);	tls_fix++;	tls_zero++;	return 0;}

    void visitClassImpl(ClassImpl *p) {      int stop;      m_symboltable->open_scope();      Symbol * symPtr = new Symbol;      // = new ClassNode;      Symbol * symp;// = new Symbol;      ClassIDImpl * ClassIdP = dynamic_cast<ClassIDImpl*>(p->m_classid_1);      ClassIDImpl * ClassIdP2 = dynamic_cast<ClassIDImpl*>(p->m_classid_2);      char * key1 = strdup(ClassIdP->m_classname->spelling());      symPtr->classType.classID = ClassIdP->m_classname->spelling();      char * progFinder = strdup("Program");      ClassName * nm = new ClassName(key1);      if(progger == true){        t_error(no_program, p->m_attribute);      }      if(std::string(key1) == std::string(progFinder)){        progger = true;      }      //char * key2 = strdup(ClassIdP2->m_classname->spelling());      if(m_classtable->exist(key1)){        t_error(dup_ident_name, p->m_attribute);      }      else{         if(ClassIdP2->m_classname != NULL){            char * key2 = strdup(ClassIdP2->m_classname->spelling());            ClassName * nm2 = new ClassName(key2);           // cout<<"inserted class: " <<key1 <<" from :"<<key2 <<endl;            m_classtable->insert(nm, nm2, p,  m_symboltable->get_scope());            ClassNode * clasp = m_classtable->getParentOf(key2);            // cout<<"Class: " <<key1 <<", Super class:  "<<clasp->name->spelling()<<endl;         }        else{           // cout<< "instered this in class table: "<< key1 <<endl;        m_classtable->insert(nm, NULL, p,  m_symboltable->get_scope());        }      }     m_symboltable->insert((char *)"xxx", symPtr);      p->visit_children(this);      m_symboltable->close_scope();      //WRITE ME    }

/*----------------------------------------------------------------------------------*/float floatvector_n_moment(FLOATVECTOR *v, float mean,float NN, float novalue){	unsigned i,n=0;	float  moment=0;if(v==NULL || v->co==NULL ){	t_error("this vector was never allocated");} else if(v->nh <1 ||  v->isdynamic !=1) {	t_error("this vector was not properly allocated");}if(NN==1){	for(i=1;i<v->nh;i++){		    			if(v->co[i]!=novalue){ 				moment+=v->co[i];				n++;			}	}moment/=n;}else if(NN==2) { 	for(i=1;i<v->nh;i++){		    			if(v->co[i]!=novalue){ 				moment+=(v->co[i])*(v->co[i]);				n++;			}	} moment=(moment/n-mean*mean);}else {		for(i=1;i<v->nh;i++){		    			if(v->co[i]!=novalue){ 				moment+=pow((v->co[i]-mean),NN);				n++;			}	}	moment/=n;}	return moment;}

int main(void){	int i, j;	wchar_t b[500];	(void)(	setlocale(LC_CTYPE, "en_US.UTF-8") ||	setlocale(LC_CTYPE, "en_GB.UTF-8") ||	setlocale(LC_CTYPE, "en.UTF-8") ||	setlocale(LC_CTYPE, "POSIX.UTF-8") ||	setlocale(LC_CTYPE, "C.UTF-8") ||	setlocale(LC_CTYPE, "UTF-8") ||	setlocale(LC_CTYPE, "") );	TEST(i, strcmp(nl_langinfo(CODESET), "UTF-8"), 0, "no UTF-8 locale; tests might fail");	TEST(i, swprintf(0, 0, L"%d", 123456)<0, 1, "%d != %d");	TEST(i, swprintf(b, 2, L"%lc", 0xc0), 1, "%d != %d");	TEST(i, b[0], 0xc0, "wrong character %x != %x");	TEST(i, swprintf(b, 2, L"%lc", 0x20ac), 1, "%d != %d");	TEST(i, b[0], 0x20ac, "wrong character %x != %x");	TEST(i, swprintf(b, 3, L"%s", "/xc3/x80!"), 2, "%d != %d");	TEST(i, b[0], 0xc0, "wrong character %x != %x");	TEST(i, swprintf(b, 2, L"%.1s", "/xc3/x80!"), 1, "%d != %d");	TEST(i, b[0], 0xc0, "wrong character %x != %x");	wcscpy(b, L"xxxxxxxx");	TEST(i, swprintf(b, 4, L"%d", 123456)<0, 1, "%d != %d");	TEST_S(b, L"123", "incorrect output");	TEST(i, b[5], 'x', "buffer overrun");	for (j=0; int_tests[j].fmt; j++) {		i = swprintf(b, sizeof b, int_tests[j].fmt, int_tests[j].i);		if (i != wcslen(int_tests[j].expect)) {			t_error("swprintf(b, sizeof b, /"%ls/", %d) returned %d wanted %d/n",				int_tests[j].fmt, int_tests[j].i, i, wcslen(int_tests[j].expect));		}		if (wcscmp(b, int_tests[j].expect) != 0)			t_error("bad integer conversion: got /"%ls/", want /"%ls/"/n", b, int_tests[j].expect);	}	for (j=0; fp_tests[j].fmt; j++) {		i = swprintf(b, sizeof b, fp_tests[j].fmt, fp_tests[j].f);		if (i != wcslen(fp_tests[j].expect)) {			t_error("swprintf(b, sizeof b, /"%ls/", %f) returned %d wanted %d/n",				fp_tests[j].fmt, fp_tests[j].f, i, wcslen(fp_tests[j].expect));		}		if (wcscmp(b, fp_tests[j].expect) != 0)			t_error("bad floating-point conversion: got /"%ls/", want /"%ls/"/n", b, fp_tests[j].expect);	}	return t_status;}

    void visitMethodImpl(MethodImpl *p) {     m_symboltable->open_scope();      if (p->m_type != NULL) {        p->m_type->accept( this );      } else {        this->visitNullPointer();      }   //  cout<<"my type: "<<p->m_type->m_attribute.m_type.baseType<<endl;    Symbol *symp = new Symbol;      Symbol *Msymp = new Symbol;      Symbol *test;      MethodIDImpl * MethIdP = dynamic_cast<MethodIDImpl*>(p->m_methodid);      p->m_attribute.m_type.baseType = p->m_type->m_attribute.m_type.baseType;//this is dealing with duplicate method names      char * key = strdup(MethIdP->m_symname->spelling());//~!~!~!~!~!~!~!~ place here         test = InScope(key);          if(test != NULL){//change this make Msymp = my function            t_error(dup_ident_name, p->m_attribute);          }          else{                  CompoundType arg;            p->visit_children(this);//Adding parameters to sym table and each argument to method vector       typename std::list<Parameter_ptr>::iterator it = p->m_parameter_list->begin();       for( ; it != p->m_parameter_list->end(); ++it) {          ParameterImpl * Pimp = dynamic_cast<ParameterImpl *> (*it);          VariableIDImpl * VarIdP = dynamic_cast<VariableIDImpl*>(Pimp->m_variableid);          //char * key = strdup(VarIdP->m_symname->spelling());            arg.baseType = Pimp->m_type->m_attribute.m_type.baseType;            Msymp->methodType.argsType.push_back(arg);          }            Msymp->methodType.returnType.baseType = p->m_type->m_attribute.m_type.baseType;            Msymp->baseType = p->m_type->m_attribute.m_type.baseType;            m_symboltable->insert_in_parent_scope(key, Msymp);          }      if(p->m_type->m_attribute.m_type.baseType != p->m_methodbody->m_attribute.m_type.baseType){           t_error(ret_type_mismatch, p->m_attribute);        }            m_symboltable->close_scope();      //WRITE ME    }

static intget_opt(int fd, int level, int name){	struct t_optmgmt req, res;	struct {		struct opthdr opt;		int value;	} reqbuf;	reqbuf.opt.level = level;	reqbuf.opt.name = name;	reqbuf.opt.len = sizeof (int);	reqbuf.value = 0;	req.flags = T_CURRENT;	req.opt.len = sizeof (reqbuf);	req.opt.buf = (char *)&reqbuf;	res.flags = 0;	res.opt.buf = (char *)&reqbuf;	res.opt.maxlen = sizeof (reqbuf);	if (t_optmgmt(fd, &req, &res) < 0 || res.flags != T_SUCCESS) {		t_error("t_optmgmt");		return (-1);	}	return (reqbuf.value);}

    void visitParameterImpl(ParameterImpl *p) {      p->visit_children(this);      Symbol *symp = new Symbol;      Symbol * test;      VariableIDImpl * VarIdP = dynamic_cast<VariableIDImpl*>(p->m_variableid);      char * key = strdup(VarIdP->m_symname->spelling());      test = InScope(key);        if(test!=NULL){            t_error(dup_ident_name, p->m_attribute);          }        else{            symp->baseType = p->m_type->m_attribute.m_type.baseType;        //    cout<< "param; key: "<< key <<" type : "<< symp->baseType<<endl;            if(symp->baseType == 8){              symp->classType.classID = p->m_type->m_attribute.m_type.classType.classID;        //      cout<< "this is what i'm SEETTTING key: " << symp->classType.classID<<endl;            }            // cout<<"insertingthis var from param: "<<key <<endl;            m_symboltable->insert(key, symp);          }            //WRITE ME    }

static intsetopt(int fd, int level, int name, int value){	struct t_optmgmt req, resp;	struct {		struct opthdr opt;		int value;	} reqbuf;	reqbuf.opt.level = level;	reqbuf.opt.name = name;	reqbuf.opt.len = sizeof (int);	reqbuf.value = value;	req.flags = T_NEGOTIATE;	req.opt.len = sizeof (reqbuf);	req.opt.buf = (char *)&reqbuf;	resp.flags = 0;	resp.opt.buf = (char *)&reqbuf;	resp.opt.maxlen = sizeof (reqbuf);	if (t_optmgmt(fd, &req, &resp) < 0 || resp.flags != T_SUCCESS) {		t_error("t_optmgmt");		return (-1);	}	return (0);}

int *ivector(long nl, long nh) /* allocate an integer vector  with subscript range v[nl ....nh] */{	int *v;		v=(int *)malloc((size_t)((nh-nl+1+NR_END)*sizeof(int)));		if (!v) t_error("allocation failure in fvector()");		return v-nl+NR_END;	}

LONGMATRIX_VECTOR *read_fine_indices(char *filename,short print) {	/*!	 * /author Emanuele Cordano	 * date May 2009	 *	 * /param (char*) - name of filename	 */param (short) -	 */	LONGMATRIX_VECTOR *lm;	FILE *fd;	long j,n_po;	fd=t_fopen(filename,"r");	n_po=(long)read_index(fd,no_PRINT);	lm=new_longmatrix_vector(n_po);	for (j=lm->nl;j<=lm->nh;j++) {		if (print==1) printf("Function read_fine_indices element %ld of %ld is being defined /n",j,lm->nh);		lm->element[j]=read_longmatrix(fd,"a",no_PRINT);		if (print==1) printf("Function read_fine_indices element %ld of %ld is read [%ld,%ld] f.e. %ld /n",j,lm->nh,lm->element[j]->nrh,lm->element[j]->nrh,lm->element[j]->element[1][1]);		if (!lm->element[j]) t_error("lm->element[j] in read_fine_indices was not defined");	//		if (polygons->element[j]->index!=j) printf ("Error in read_polygonvector (polygon %ld) inconstancy: %ld %ld /n",j,j,polygons->element[j]->index);	}	t_fclose(fd);	if (print==1) printf("Function read_fine_indices was successfully executed! /n");	return lm;}

int main(void){	regex_t re;	int r;	r = regcomp(&re, "abc", REG_NOSUB);	if (r)		t_error("regcomp failed: %d/n", r);	r = regexec(&re, "zyx abc", 1, 0, 0);	if (r == REG_NOMATCH)		t_error("regexec failed to match/n");	else if (r)		t_error("regexec returned invalid code: %d/n", r);	regfree(&re);	return t_status;}

static void test_mutexattr(){	pthread_mutex_t m;	pthread_mutexattr_t a;	int r;	int i;	T(pthread_mutexattr_init(&a));	T(pthread_mutexattr_gettype(&a, &i));	if (i != PTHREAD_MUTEX_DEFAULT)		t_error("default mutex type is %d, wanted PTHREAD_MUTEX_DEFAULT (%d)/n", i, PTHREAD_MUTEX_DEFAULT);	T(pthread_mutexattr_settype(&a, PTHREAD_MUTEX_ERRORCHECK));	T(pthread_mutexattr_gettype(&a, &i));	if (i != PTHREAD_MUTEX_ERRORCHECK)		t_error("setting error check mutex type failed failed: got %d, wanted %d/n", i, PTHREAD_MUTEX_ERRORCHECK);}

static void *tryrdlock(void *arg){	int r = pthread_rwlock_tryrdlock(arg);	if (r != EBUSY)		t_error("tryrdlock for wrlocked lock returned %s, want EBUSY/n", strerror(r));	return 0;}

void product_using_only_strict_lower_diagonal_part(DOUBLEVECTOR *product, DOUBLEVECTOR *x, LONGVECTOR *Li, LONGVECTOR *Lp, DOUBLEVECTOR *Lx){		long c, r, i;		for(i=1;i<=x->nh;i++){		product->co[i] = 0.0;	}		c = 1;	for(i=1;i<=Li->nh;i++){		r = Li->co[i];				if(r > c){			product->co[c] += Lx->co[i] * (x->co[r] - x->co[c]);			product->co[r] += Lx->co[i] * (x->co[c] - x->co[r]);		}else if(r < c){			printf("r:%ld c:%ld i:%ld Ap[c]:%ld tot:%ld %ld %ld/n",r,c,i,Lp->co[c],Li->nh,Lp->co[x->nh],x->nh);			t_error("matrix is not L");		}				if(i<Li->nh){			while(i >= Lp->co[c]) c++;		}	}}

void aero_resistance(double zmu, double zmt, double z0, double d0, double z0_z0t, double v, double Ta, double T, double Qa, 					 double Q, double P, double gmT, double *Lobukhov, double *rm, double *rh, double *rv, short state_turb, 					 short MO, long maxiter){	FILE *f;		//calculates resistences		//double p=pow((1000.0/P),(0.286*(1-0.23*Qa)));	double p=1.0;	//double Tpa=(Ta+tk)*p,Tp=(T+tk)*p;	//potential temperatures	if(state_turb==0){		//Lewis(zmu, zmt, d0, z0, z0_z0t, Tpa, Tp, v, rm, rh, rv, rep);		f = fopen(FailedRunFile, "w");		fprintf(f,"Error:: state_turb == 0 not possible, check option file/n");		fclose(f);		t_error("Fatal Error! Geotop is closed. See failing report.");				}else if(state_turb==1){		Businger(MO, zmu, zmt, d0, z0, v, 0.5*T+0.5*Ta, T-Ta, Q-Qa, z0_z0t, rm, rh, rv, Lobukhov, maxiter);				}else if(state_turb==2){	//catabatic flows - OERLEMANS & GRISOGONO (2002)		*rm=1.0/(v*ka*ka/(log((zmu-d0)/z0 )*log((zmu-d0)/z0 )));		if(p*(-gmT+0.0098)>0.0015){			*rh=1/( 0.0004*(Ta-T)*pow(g/(tk*p*(gmT+0.0098)*5),0.5) );		}else{			*rh=1/( 0.0004*(Ta-T)*pow(g/(tk*(0.0015)*5),0.5) );		}		*rv=*rh;	}	}

/*-------------------------------------------------------------------------------*/short file_copy(FILE *destination,FILE *origin){char ch;long pos=0;if(destination==NULL || origin==NULL) t_error("This file was not opened yet");		ch=getc(origin);		while(ch!=EOF){		       if(ch=='/n'){		    		fprintf(destination,"/n");		    		skip_whitespaces(origin); 		    	}else{		    			    		fprintf(destination,"%c",ch);		    	}			ch=getc(origin);		}pos=ftell(origin);if(pos==0){	printf("/nWarning::Empty file encountered");	return 0;} else {	return 1;}	return 0;}

void product_using_only_strict_lower_diagonal_part_plus_identity_by_vector(DOUBLEVECTOR *product, DOUBLEVECTOR *x, DOUBLEVECTOR *y,																	LONGVECTOR *Li, LONGVECTOR *Lp, DOUBLEVECTOR *Lx){		long i, r, c;		//calculate (A+Iy)*x, A described by its strict lower diagonal part			for(i=1;i<=x->nh;i++){		product->co[i] = y->co[i] * x->co[i];	}		c = 1;	for(i=1;i<=Li->nh;i++){		r = Li->co[i];				if(r > c){			product->co[c] += Lx->co[i] * (x->co[r] - x->co[c]);			product->co[r] += Lx->co[i] * (x->co[c] - x->co[r]);		}else if(r < c){			printf("r:%ld c:%ld i:%ld Lp[c]:%ld tot:%ld %ld %ld/n",r,c,i,Lp->co[c],Li->nh,Lp->co[x->nh],x->nh);			t_error("matrix is not L");		}				if(i<Li->nh){			while(i >= Lp->co[c]) c++;		}	}	}