int convertdefine() { int i; int j; i=0;
while (i < GTop) {
j=adrofname(i);
if (eqstr(symbol,j)) { if (GType[i]=='#') { prs("\n;define: "); printName(i);
prs("= "); lexval=GData[i]; prnum(lexval); return T_CONST; } }
i++; }
return 0; }
/*
* 父进程等待子进程终止
* i为子进程pid，-1表示等待所有子进程
* t为语法树节点
*/
void pwait(int i, int *t)
{
int p, e;
int s;
if(i != 0)
for(;;) {
times(&timeb);
time(timeb.proct);
p = wait(&s);
if(p == -1) /* 等待失败 */
break;
e = s&0177; /* 保留状态环境 */
if(mesg[e] != 0) { /* 子进程异常终止 */
if(p != i) {
prn(p);
prs(": ");
}
prs(mesg[e]); /* 打印对应的消息 */
if(s&0200) /* 内核奔溃 */
prs(" -- Core dumped");
}
if(e != 0)
err(""); /* 等待正常终止 */
if(i == p) {
acct(t);
break;
} else
acct(0);
}
}
int expr() { int mode; int id1; int ixarr; int ids;
if (istoken(T_CONST)) {doconst(); return 1; }
mode=typeName(); /*0=V,1=*,2=&*/
if (token=='(') {docall1(); goto e1; }
if (isreg()) goto e1;
id1=searchname(); gettypes(id1); ids=signi;
ixarr=0;
if (istoken('[')) { ixarr=searchname(); expect(T_NAME); expect(']');
gettypes(ixarr);
if (widthi==0) error1("Arrayindex muss int sein"); }
if (istoken(T_PLUSPLUS )) {if(mode)error1("Nur var erlaubt");doinc();goto e1;}
if (istoken(T_MINUSMINUS)) {if(mode)error1("Nur var erlaubt");dodec();goto e1;}
if (istoken(T_PLUSASS )) {compoundass("add", mode); goto e1;}
if (istoken(T_MINUSASS )) {compoundass("sub", mode); goto e1;}
if (istoken(T_ANDASS )) {compoundass("and", mode); goto e1;}
if (istoken(T_ORASS )) {compoundass("or" , mode); goto e1;}
if (istoken(T_MULASS )) {error1("nicht implementiert");}
if (istoken(T_DIVASS )) {error1("nicht implementiert");}
if (istoken('=')) { isconst=expr();
if (isconst) { if(mode==0) {prs("\n;++++ mov "); printName(id1);
prs(", "); prnum(lexval); } }
doassign(mode, id1, ixarr); goto e1;}
dovar1(mode, "mov", ixarr, id1);
e1: if (istoken('+')) rterm("add");
else if (istoken('-')) rterm("sub" );
else if (istoken('&')) rterm("and" );
else if (istoken('|')) rterm("or" );
else if (istoken(T_LESSLESS)) rterm("shl");
else if (istoken(T_GREATGREAT)) rterm("shr");
else if (istoken('*')) domul (ids);
else if (istoken('/')) doidiv(ids);
else if (istoken('%')) domod (ids);
if (isrelational()) { rterm("cmp"); cmpneg(ids);}
return 0;
}
int constantexpr() { int mode; int id1;int ids;
token=getlex(); mode=typeName();
id1=searchname(); gettypes(id1); ids=signi;
if (isrelational() ==0) error1("Vergleich erwartet");
expect(T_CONST);
prs("; constant expression");
prs("\ncmp "); printName(id1); prs(", "); prnum(lexval); cmpneg(ids);
expect(')');
}
/* 打印错误，非交互模式则清空stdin缓存并退出shell进程*/
void err(char *s)
{
prs(s);
prs("\n");
if(promp == 0) {
seek(0, 0, 2);
exit(-1);
}
}
int getarg() { int arglen1; int i; char *c; arglen1=*arglen;
if (arglen1) {i=arglen1+0x81; c=i; *c=0; strcpy1(namein, argv);
strcpy1(namelst, namein); i=strlen1(namelst); i--; c=&namelst+i; *c='S'; }
else {strcpy1(namein, "F.C"); strcpy1(namelst, "F.S"); }
fdin=open2 (namein);
if(DOS_ERR !=0){print1("Datei fehlt: "); print1(namein); exit1(1); }
fdout=creat1(namelst);
if(DOS_ERR !=0){print1("Datei nicht erzeugbar: ");print1(namelst);exit1(2);}
prs("\n;Arglen: "); prnum(arglen1); if(arglen1){prs(", Argv: "); prs(argv);}
}
int rterm(char *op) {int mode; int opint; int ixarr; int id1;
if (istoken(T_CONST)) { prnl(); prs(op);
if (wi) prs(" ax, "); else prs(" al, "); prnum(lexval); return;}
mode=typeName(); id1=searchname(); ixarr=0;
if (istoken('[')) { ixarr=searchname(); expect(T_NAME); expect(']');
gettypes(ixarr);
if (widthi==0) error1("Arrayindex muss int sein"); }
if (eqstr(symbol,"_AX")) return;
opint=op; dovar1(mode, opint, ixarr, id1);
}
static int
pr_head(const struct chunk *cnk) {
int pos = 0;
pos += prs(cnk->ch_text->tx_fname);
pos += prs(": line ");
pos += pru(cnk->ch_first.ps_nl_cnt);
pos += prs("-");
pos += pru(cnk->ch_last.ps_nl_cnt - 1);
return pos;
}
int doinclude() { int fdtemp;
if (token==T_STRING) { fdtemp=fdin;
prs("\n;Verarbeite Include-Datei: "); prscomment(symbol);
fdin=open2(symbol);
if (DOS_ERR !=0) {prs("Include-Datei fehlt: "); prscomment(symbol);
error1("Stop"); }
linenoinclude=lineno; lineno=1;
parse(); lineno=linenoinclude;
fdin=fdtemp; prs("\n;Zurueck in Hauptdatei: "); prs(namein);
getfirstchar(); token=getlex(); }
}
void
chkmail(void)
{
unsigned char *s = mailp;
unsigned char *save;
long *ptr = mod_time;
unsigned char *start;
BOOL flg;
struct stat statb;
while (*s) {
start = s;
save = 0;
flg = 0;
while (*s) {
if (*s != COLON) {
if (*s == '%' && save == 0)
save = s;
s++;
} else {
flg = 1;
*s = 0;
}
}
if (save)
*save = 0;
if (*start && stat((const char *)start, &statb) >= 0) {
if (statb.st_size && *ptr &&
statb.st_mtime != *ptr) {
if (save) {
prs(save+1);
newline();
}
else
prs(_gettext(mailmsg));
}
*ptr = statb.st_mtime;
} else if (*ptr == 0)
*ptr = 1;
if (save)
*save = '%';
if (flg)
*s++ = COLON;
ptr++;
}
}
int cmpneg(int ids) {
if(iscmp==T_EQ) prs("\n jne @@"); /*ZF=0 */
else if(iscmp==T_NE) prs("\n je @@"); /*ZF=1 */
else if(iscmp==T_LE) if (ids) prs("\n jg @@");/*ZF=0 SF =OF*/
else prs("\n ja @@");/*ZF=0 CF=0 */
else if(iscmp==T_GE) if (ids){prs(" ;unsigned : "); prnum(ids);
prs("\n jl @@");/* SF!=OF*/}
else{prs(" ;unsigned : "); prnum(ids);
prs("\n jb @@");/*jb=jc=CF=1 */}
else if(iscmp=='<' ) prs("\n jge @@"); /* SF =OF*/
else if(iscmp=='>' ) prs("\n jle @@"); /*ZF=1 oder SF!=OF*/
else error1("Vergleich unbekannt in CMPNEG()"); }
int dodefine() { int symlen; int j;
expect(T_NAME);
if (token==T_CONST) {
if (GTop >= GMAX) error1("Globale Tabelle (define) voll");
symlen = strlen1(symbol);
if (symlen > 15 ) error1("Define-Name ist länger als 15 Zeichen");
GSign [GTop]='U'; GWidth[GTop]='B'; GType [GTop]='#';
j=GTop*16; pt=&GNameField + j; strcpy1(pt, symbol);
prs("; Define Nr "); prnum(GTop); prs(": ");
printName(GTop); prc(' ');
GData[GTop]=lexval; prc('=');prnum(lexval); expect(T_CONST); GTop++; }
}
void failed(const char *s1, const char *s2)
{
prp();
prs(s1);
if (s2) {
prs(colon);
prs(s2);
;
}
newline();
exitsh(ERROR);
}
/* Shell入口*/
void main(int c, char **av)
{
int f;
char *acname, **v;
for(f=2; f<15; f++) /* close_on_exec，因为shell可能来自外部进程或自身fork */
close(f);
if((f=dup(1)) != 2) /* 将stdout重定向到stderr，dup()将返回尚未打开的最小文件句柄*/
close(f);
dolc = getpid(); /* 记录当前进程pid */
for(f=4; f>=0; f--) {
pidp[f] = dolc%10+'0'; /* itoa */
dolc = dolc/10;
}
v = av;
acname = "/usr/adm/sha"; /* SHA加密序列，目前Unix版本已废弃*/
promp = "% "; /* 普通用户交互提示符*/
if(((uid = getuid())&0377) == 0)
promp = "# "; /* root用户交互提示符*/
acctf = open(acname, 1);
if(c > 1) {
promp = 0; /* 进入非交互模式*/
if (*v[1]=='-') { /* 存在选项*/
**v = '-'; /* 用第一个序列字符临时标记*/
if (v[1][1]=='c' && c>2) /* '-c'选项，从arginp中扫描*/
arginp = v[2];
else if (v[1][1]=='t') /* '-t'选项，从stdin中扫描*/
onelflg = 2;
} else { /* 直接从命令文件中扫描*/
close(0);
f = open(v[1], 0); /* 重定向stdin到文件*/
if(f < 0) {
prs(v[1]);
err(": cannot open");
}
}
}
if(**v == '-') {
setintr++; /* 非交互模式下带选项，则初始化忽略所有信号*/
signal(QUIT, 1);
signal(INTR, 1);
}
dolv = v+1;
dolc = c-1;
loop: /* 每次loop执行一次shell语句解释，直到遇上换行符，无限循环除非整个shell进程终止 */
if(promp != 0)
prs(promp); /* 打印交互提示符*/
peekc = getc(); /* 对于I/O流，预读一个字符，以便将来再次读取*/
main1(); /* 进入解释器 */
goto loop;
}
int main()
{
/*
// std::string s = std::string("una string para split l,");
std::string s = std::string("unaStringSinEspacios");
std::vector< std::string > vecStr = split(s);
for(std::vector< std::string >::iterator it = vecStr.begin();
it != vecStr.end();
++it)
std::cout << "vecStr: " << *it << std::endl;
*/
std::vector<int> voi;
std::vector<std::string> vos;
prs(sizeof(int), "int");
prs(sizeof(char), "char");
prs(sizeof(std::string), "std::string");
prs(sizeof(voi), "voi = vector<int>;");
prs(sizeof(vos), "vector<string>");
std::vector<int> voi2;
std::vector<std::string> vos2;
prs( sizeof(voi2), "voi = vector<int>;");
prs( sizeof(vos2), "vector<string>(9999)");
std::cout << "\nCapacity of vos2: " << vos2.capacity() << std::endl;;
int desde = 0;
int hasta = 999999;
std::cout << "\nEmpieza for... desde " << desde
<< " hasta " << hasta << "\n\n";
size_t size = 0;
for(; desde < hasta; desde++) {
voi2.insert(voi2.begin() + desde, desde);
if( size < voi2.capacity()) {
std::cout << "size es " << size
<< "\t\tvoi2.capacity() es"
<< voi2.capacity() << "\t\tdesde es "
<< "\t\tvoi2.size() es"
<< voi2.size() << "\t\tdesde es "
<< desde << std::endl;
size = voi2.capacity();
}
//else std::cout << "no";
}
std::cout << " Termino for.\n";
prs(sizeof(voi2), "voi2 = vector<int>, despues del for");
// int size = voi.size();
std::cout << "Size of voi: " << voi.size() << std::endl;
std::cout << "Size of voi2: " << voi2.size() << std::endl;
//std::vector<int> myints = { 1, 2, 3, 4 };
//std::cout << "0. size: " << myints.size() << '\n';
return 0;
}
/*
* fake diagnostics to continue to look like original
* test(1) diagnostics
*/
static void
bfailed(const unsigned char *s1, const unsigned char *s2,
const unsigned char *s3)
{
prp();
prs(s1);
if (s2)
{
prs(colon);
prs(s2);
prs(s3);
}
newline();
exitsh(ERROR);
}
/* parse and evaluate an expression of a specified precedence or higher
* the lowest precedence is 0
*/
static unsigned long prs(unsigned p)
{
unsigned long n = 0; /* return value */
/* parse expression that begins with a token (precedence 11) */
switch (token) {
/* constant */
case NUM:
n = num_value;
lex();
break;
/* parenthesis */
case '(':
lex();
n = prs(0);
match(')');
break;
/* unary operators */
case '+': lex(); n = prs(11); break;
case '-': lex(); n = (unsigned long)(-(long)prs(11)); break;
case '~': lex(); n = ~prs(11); break;
case '!': lex(); n = !prs(11); break;
/* anything else is an error */
default:
if (success) {
fprintf(stderr, "syntax error at %s\n", name(token));
success = 0;
}
break;
}
/* parse other operators */
while (success) {
unsigned long n1, n2; /* intermediate calculations */
#define U(x) (unsigned)x
/* regular binary operators */
if (p <= 10 && token == '*') { lex(); n = n * prs(11); }
if (p <= 10 && token == '/') { lex(); n = n / z(prs(11));} else
if (p <= 10 && token == '%') { lex(); n = n % z(prs(11));} else
if (p <= 9 && token == '+') { lex(); n = n + prs(10); } else
if (p <= 9 && token == '-') { lex(); n = n - prs(10); } else
if (p <= 8 && token == SHL) { lex(); n = n >> U(prs(9));} else
if (p <= 8 && token == SHR) { lex(); n = n << U(prs(9));} else
/*
* printing and io conversion
*/
prp()
{
if ((flags & prompt) == 0 && cmdadr)
{
prs_cntl(cmdadr);
prs(colon);
}
}
static void prsym(int sym)
{
if (sym & SYMFLG) {
register SYSPTR sp = reserved;
while (sp->sysval && sp->sysval != sym)
sp++;
prs(sp->sysnam);
} else if (sym == EOFSYM) {
prs(endoffile);
} else {
if (sym & SYMREP)
prc(sym);
if (sym == NL)
prs("newline");
else
prc(sym);
}
}
static void synbad(void)
{
prp();
prs(synmsg);
if ((flags & ttyflg) == 0) {
prs(atline);
prn(standin->flin);
}
prs(colon);
prc(LQ);
if (wdval)
prsym(wdval);
else
prs(wdarg->argval);
prc(RQ);
prs(unexpected);
newline();
exitsh(SYNBAD);
}
char* CPRApplication::ReadToEOLN(ag::list<CPRTokenInfo>::member* p, char* FText)//!!!!!!!!!!!!!!!!!
{
CPRParser prs(FText,(*p)->data.iStartPos);
char* m = prs.ReadToEOLN();
/* char* m2 = ((strcmp(m,"*")==0)||(strcmp(m,"&")==0))?prs.ReadIdent():NULL;
if (m2!=NULL) strcat(m,m2);*/
while((*p)->data.iStartPos<prs.iPosition-1)(*p)=(*p)->next;
(*p)=(*p)->prev;
return m;
}
/*
* 执行命令
* f为可执行文件路径
* at为语法树节点
*/
void texec(char *f, int *at)
{
extern int errno;
int *t;
t = at;
execv(f, t+DCOM); /* 重新加载并执行命令，不需要设置环境*/
if (errno==ENOEXEC) {
if (*linep)
t[DCOM] = (int)linep;
t[DSPR] = (int)"/bin/sh";
execv(t[DSPR], t+DSPR); /* 找不到命令可执行文件*/
prs("No shell!\n");
exit(-1);
}
if (errno==ENOMEM) {
prs((char *)t[DCOM]);
err(": too large"); /* 内存不足*/
exit(-1);
}
}
/**
Let pc2s be a buffer of proof converters that are wrappers for proofs.
That is, they are functors of the form: unit -> Proof
Then, this function applies pc1 to the proofs produced by pc2s's and store
the resultant proof in result.
pc1 and pc2s must be different from 0.
*/
proof_ref apply(ast_manager & m, proof_converter_ref & pc1, proof_converter_ref_buffer & pc2s) {
SASSERT(pc1);
proof_ref_buffer prs(m);
unsigned sz = pc2s.size();
for (unsigned i = 0; i < sz; i++) {
proof_ref pr(m);
SASSERT(pc2s[i]); // proof production is enabled
pr = pc2s[i]->operator()(m, 0, nullptr);
prs.push_back(pr);
}
return (*pc1)(m, sz, prs.c_ptr());
}
/*
* A generic call back routine to output error messages from the
* policy backing functions called by pfsh.
*
* msg must contain '\n' if a new line is to be printed.
*/
void
secpolicy_print(int level, const char *msg)
{
switch (level) {
case SECPOLICY_WARN:
default:
prs(_gettext(msg));
return;
case SECPOLICY_ERROR:
error(msg);
break;
}
}
/* 分配一个语法树节点，大小根据n指定，为n*4字节 */
int* tree(int n)
{
int *t;
t = treep;
treep += n;
if (treep>treeend) {
prs("Command line overflow\n"); /* 空间不足 */
error++;
reset();
}
return(t);
}
int doreg(char *dr) { expect('=');
prs("\n mov "); prs(dr); prs(", ");
if (istoken(T_CONST)) prunsign(lexval);
else if (istoken(T_NAME )) {
if (eqstr(symbol,"_DX")) prs("dx");
else if (eqstr(symbol,"_CX")) prs("cx");
else prs(symbol); }
else error1("Nur Zahl oder Var erlaubt"); }
Browse::Browse( char * cmdLine )
: WMdiWindow( "" )
, _helpInfo( NULL )
, _status( new WStatWindow( this, WRect(0,0,0,0), "Ready" ) )
, _editorDLL( NULL )
//---------------------------------------------------------------
{
WString errMessage;
CommandParser prs( cmdLine, true );
_searchPath = prs.searchPath();
WFlashPage * flash_page = showFlashPage( 0 );
browseTop = this;
topWindow = browseTop;
_helpInfo = new WSystemHelp( this, BrowseTitle, _BrowseHelpFile,
_BrowseHtmlHelpFile );
setIcon( WBRWIcon );
setupMenus();
viewManager()->registerForEvents( this );
// important that options comes before the database
// since the option file can set the query and cause a re-load
// of the inheritance graph
if( prs.options() ) {
optManager()->loadFrom( prs.options() );
} else {
optManager()->loadDefault();
}
// this must come after the option loads
if( optManager()->isEditorDLL() ) {
setEditorDLL( optManager()->getEditorName() );
}
if( prs.database() ) {
dbManager()->setModule( prs.database(), prs.files() );
} else {
/* if there is no database, disable interesting menus */
viewManager()->enableMenus( false );
}
postTitle();
delete flash_page;
show();
hookF1Key( true );
}
void rule_manager::mk_rule_core(expr* fml, proof* p, rule_set& rules, symbol const& name) {
expr_ref_vector fmls(m);
proof_ref_vector prs(m);
m_hnf.reset();
m_hnf.set_name(name);
m_hnf(fml, p, fmls, prs);
for (unsigned i = 0; i < m_hnf.get_fresh_predicates().size(); ++i) {
m_ctx.register_predicate(m_hnf.get_fresh_predicates()[i], false);
}
for (unsigned i = 0; i < fmls.size(); ++i) {
mk_horn_rule(fmls[i].get(), prs[i].get(), rules, name);
}
}
void
freeio(struct ionod *iop)
{
struct ionod *sav;
while (iop)
{
if (iop->iofile & IODOC)
{
#ifdef DEBUG
prs("unlinking ");
prs(iop->ioname);
newline();
#endif
unlink(iop->ioname);
if (fiotemp == iop)
fiotemp = iop->iolst;
else
{
struct ionod *fiop = fiotemp;
while (fiop->iolst != iop)
fiop = fiop->iolst;
fiop->iolst = iop->iolst;
}
}
free(iop->ioname);
free(iop->iolink);
sav = iop->ionxt;
free(iop);
iop = sav;
}
}
virtual void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) {
// Let m_clause be of the form (l_0 or ... or l_{num_source - 1})
// Each source[i] proof is a proof for "false" using l_i as a hypothesis
// So, I use lemma for producing a proof for (not l_i) that does not contain the hypothesis,
// and unit_resolution for building a proof for the goal.
SASSERT(num_source == m_clause->get_num_args());
proof_ref_buffer prs(m);
prs.push_back(m_clause_pr);
for (unsigned i = 0; i < num_source; i++) {
proof * pr_i = source[i];
expr * not_li = m.mk_not(m_clause->get_arg(i));
prs.push_back(m.mk_lemma(pr_i, not_li));
}
result = m.mk_unit_resolution(prs.size(), prs.c_ptr());
}
