void assertion_set::update(unsigned i, expr * f, proof * pr) {
SASSERT(m().proofs_enabled() == (pr != 0 && !m().is_undef_proof(pr)));
if (m_inconsistent)
return;
if (m().proofs_enabled()) {
expr_ref out_f(m());
proof_ref out_pr(m());
slow_process(true, f, pr, out_f, out_pr);
if (!m_inconsistent) {
if (m().is_false(out_f)) {
push_back(out_f, out_pr);
}
else {
m().set(m_forms, i, out_f);
m().set(m_proofs, i, out_pr);
}
}
}
else {
quick_process(true, f);
if (!m_inconsistent) {
if (m().is_false(f))
push_back(f, 0);
else
m().set(m_forms, i, f);
}
}
}
void goal::update(unsigned i, expr * f, proof * pr, expr_dependency * d) {
SASSERT(proofs_enabled() == (pr != 0 && !m().is_undef_proof(pr)));
if (m_inconsistent)
return;
if (proofs_enabled()) {
expr_ref out_f(m());
proof_ref out_pr(m());
slow_process(true, f, pr, d, out_f, out_pr);
if (!m_inconsistent) {
if (m().is_false(out_f)) {
push_back(out_f, out_pr, d);
}
else {
m().set(m_forms, i, out_f);
m().set(m_proofs, i, out_pr);
if (unsat_core_enabled())
m().set(m_dependencies, i, d);
}
}
}
else {
quick_process(true, f, d);
if (!m_inconsistent) {
if (m().is_false(f)) {
push_back(f, 0, d);
}
else {
m().set(m_forms, i, f);
if (unsat_core_enabled())
m().set(m_dependencies, i, d);
}
}
}
}
/**********************main()***********************/
void main()
{
fp_err=fopen("纯捷联err.txt","w");
//fp_V=fopen("V.txt","w");
//fp_tV=fopen("tV.txt","w");
//初始化导航参数
initial(); //初始化理论值和实际值
ctCn2b(); //姿态角计算姿态矩阵（理论）
ini_Cn2b();//姿态角计算姿态矩阵（实际）
ini_q(); //四元数初始化（实际值）
/*Mk0=gyro_ran;
Nk0=acce_ran;*/
for(number=0;number<Num;number++)
{
noise=white();
/*Mk=-number*sampletime/1800*Mk0;
Nk=-number*sampletime/1800*Nk0;
printf("%le\t %le\t\n",Mk,Nk);*/
D_gyro[0]=(gyro_ran*noise+gyro_con0)*dh_hs;//+Mk
D_gyro[1]=(gyro_ran*noise+gyro_con1)*dh_hs;//+Mk
D_gyro[2]=(gyro_ran*noise+gyro_con2)*dh_hs;//+Mk
D_acce[0]=(acce_ran*noise+acce_con0)*g/1000.0;//+Nk
D_acce[1]=(acce_ran*noise+acce_con1)*g/1000.0;//+Nk+Nk
D_acce[2]=(acce_ran*noise+acce_con2)*g/1000.0;//
t_renew();//导航参数理论值更新函数
ctCn2b(); //由理论值姿态角解算姿态矩阵的函数
out_Wib_b();//导入陀螺数据
cWnb_b();//真实值计算
q_renew();//真实值计算
cCn2b();//真实值，从四元数中计算出来
out_f(); //导入加速度计数据
renew();//理论值
if((number%Tfnum==0)&&(number!=0)) // 1s
{
fprintf(fp_err,"%e\t %e\t %e\t %e\t %e\t %e\t %e\t\n",(P-tP)*H_d*60,(R-tR)*H_d*60,(H-tH)*H_d*60,
V[0]-tV[0],V[1]-tV[1],(latit-tlatit)*Rn,(longi-tlongi)*Re*cos(tlatit));
}
}
fclose(fp_err);
// fclose(fp_V);
// fclose(fp_tV);
}
void assertion_stack::update(unsigned i, expr * f, proof * pr, expr_dependency * d) {
SASSERT(i >= m_form_qhead);
SASSERT(proofs_enabled() == (pr != 0 && !m().is_undef_proof(pr)));
if (m_inconsistent)
return;
if (proofs_enabled()) {
expr_ref out_f(m());
proof_ref out_pr(m());
slow_process(true, f, pr, d, out_f, out_pr);
if (!m_inconsistent) {
if (m().is_false(out_f)) {
push_back(out_f, out_pr, d);
}
else {
m().inc_ref(out_f);
m().dec_ref(m_forms[i]);
m_forms[i] = out_f;
m().inc_ref(out_pr);
m().dec_ref(m_proofs[i]);
m_proofs[i] = out_pr;
if (unsat_core_enabled()) {
m().inc_ref(d);
m().dec_ref(m_deps[i]);
m_deps[i] = d;
}
}
}
}
else {
quick_process(true, f, d);
if (!m_inconsistent) {
if (m().is_false(f)) {
push_back(f, 0, d);
}
else {
m().inc_ref(f);
m().dec_ref(m_forms[i]);
m_forms[i] = f;
if (unsat_core_enabled()) {
m().inc_ref(d);
m().dec_ref(m_deps[i]);
m_deps[i] = d;
}
}
}
}
}
//<stat> -> <in> | <out> | <block> | <if> | <loop> | <assign>
node_t* stat_f() {
node_t *p = getNode("<stat>");
if (tk.tokenId == SCAN_tk) { // <in>
p->child1 = getNode("SCAN");
tk = scanner(fp, lineNum);
p->child2 = in_f();
return p;
} else if (tk.tokenId == PRINT_tk) { // <out>
p->child1 = getNode("PRINT");
tk = scanner(fp, lineNum);
p->child2 = out_f();
return p;
} else if (tk.name == "{") { // <block>
//don't need to put delimiters in the tree
p->child1 = block_f();
return p;
} else if (tk.tokenId == IF_tk) { // <if>
p->child1 = getNode("IF");
tk = scanner(fp, lineNum);
p->child2 = if_f();
return p;
} else if (tk.tokenId == LOOP_tk) { // <loop>
p->child1 = getNode("LOOP");
tk = scanner(fp, lineNum);
p->child2 = loop_f();
return p;
} else if (tk.tokenId == IDENT_tk) { // <assign>
p->child1 = assign_f();
return p;
} else {
error("Got token " + tk.name + ", expected SCAN, PRINT, {, IF, LOOP, or IDENTIFIER token\n");
}
return p;
}
void VOMSUtilTest::VOMSTrustListTest() {
std::vector<Arc::VOMSACInfo> output;
std::string emptystring = "";
Arc::VOMSTrustList emptylist;
// CPPUNIT_ASSERT_EQUAL(!parseVOMSAC(c, emptystring, emptystring, emptylist, output, false),false);
// Create the AC on the VOMS side
std::string CAcert("ca_cert.pem");
std::string user_key_file("user_key.pem");
std::string user_cert_file("user_cert.pem");
Arc::Credential issuer_cred(user_cert_file, user_key_file, "", CAcert, "userpassword");
std::string vomsserver_key_file("host_key.pem");
std::string vomsserver_cert_file("host_cert.pem");
Arc::Credential ac_issuer_cred(vomsserver_cert_file, vomsserver_key_file, "", CAcert, "");
std::string holder_proxy_file("user_proxy.pem");
Arc::Credential holder_cred(holder_proxy_file, "", "", CAcert);
std::vector<std::string> fqan;
fqan.push_back("/nordugrid.org");
std::vector<std::string> targets;
targets.push_back("www.nordugrid.org");
std::vector<std::string> attrs;
attrs.push_back("::role=admin");
attrs.push_back("::role=guest");
std::string voname = "nordugrid";
std::string uri = "voms.nordugrid.org:50000";
std::string ac_str;
Arc::createVOMSAC(ac_str, ac_issuer_cred, holder_cred, fqan, targets, attrs, voname, uri, 3600*12);
//
// Create the full AC which is an ordered list of AC
//
// encode the AC string into base64
int size;
char* enc = NULL;
std::string ac_str_b64;
enc = Arc::VOMSEncode((char*)(ac_str.c_str()), ac_str.length(), &size);
if (enc != NULL) {
ac_str_b64.append(enc, size);
free(enc);
enc = NULL;
}
std::string aclist_str;
aclist_str.append(VOMS_AC_HEADER).append("\n");
aclist_str.append(ac_str_b64).append("\n");
aclist_str.append(VOMS_AC_TRAILER).append("\n");
std::string voms_proxy_file("voms_proxy.pem");
// Request
int keybits = 1024;
int proxydepth = 10;
Arc::Time t;
Arc::Credential proxy_req(t, Arc::Period(12*3600), keybits, "gsi2", "limited", "", proxydepth);
std::string proxy_req_file("voms_req.pem");
proxy_req.GenerateRequest(proxy_req_file.c_str());
//Add AC extension to proxy certificat before signing it
proxy_req.AddExtension("acseq", (char**) (aclist_str.c_str()));
//Sign the voms proxy
issuer_cred.SignRequest(&proxy_req, voms_proxy_file.c_str());
std::string private_key, signing_cert, signing_cert_chain;
proxy_req.OutputPrivatekey(private_key);
issuer_cred.OutputCertificate(signing_cert);
issuer_cred.OutputCertificateChain(signing_cert_chain);
std::ofstream out_f(voms_proxy_file.c_str(), std::ofstream::app);
out_f.write(private_key.c_str(), private_key.size());
out_f.write(signing_cert.c_str(), signing_cert.size());
out_f.write(signing_cert_chain.c_str(), signing_cert_chain.size());
out_f.close();
std::vector<std::string> vomscert_trust_dn;
vomscert_trust_dn.push_back("/O=Grid/OU=ARC/CN=localhost");
vomscert_trust_dn.push_back("/O=Grid/OU=ARC/CN=CA");
vomscert_trust_dn.push_back("NEXT CHAIN");
vomscert_trust_dn.push_back("^/O=Grid/OU=ARC");
// Read and pars VOMS proxy
Arc::Credential voms_proxy(voms_proxy_file, "", ".", CAcert);
std::vector<Arc::VOMSACInfo> attributes;
Arc::VOMSTrustList trust_dn(vomscert_trust_dn);
Arc::parseVOMSAC(voms_proxy, ".", CAcert, "", trust_dn, attributes, true);
for(size_t n=0; n<attributes.size(); n++) {
for(size_t i=0; i<attributes[n].attributes.size(); i++) {
Arc::CredentialLogger.msg(Arc::DEBUG, "Line %d.%d of the attributes returned: %s",n,i,attributes[n].attributes[i]);
}
}
CPPUNIT_ASSERT_EQUAL(1,(int)attributes.size());
CPPUNIT_ASSERT_EQUAL(4,(int)attributes[0].attributes.size());
}
void goal::slow_process(expr * f, proof * pr, expr_dependency * d) {
expr_ref out_f(m());
proof_ref out_pr(m());
slow_process(false, f, pr, d, out_f, out_pr);
}
void assertion_stack::slow_process(expr * f, proof * pr, expr_dependency * d) {
expr_ref out_f(m());
proof_ref out_pr(m());
slow_process(false, f, pr, d, out_f, out_pr);
}
void assertion_set::slow_process(expr * f, proof * pr) {
expr_ref out_f(m());
proof_ref out_pr(m());
slow_process(false, f, pr, out_f, out_pr);
}
