Hi Bakul. Long time since our Bay Area plan 9 hacking sessions. I've avoided the valley all together for a year and a half now. Not quite long enough yet. I thought the same thing, using ~0 for nil, but realized two things. First, that's a valid address on the PDP11 where the convention developed. It's the unibus space. Second, ~0 + member offest is still in page zero. By the way, are there any structs more than 4K in Linux? Are there any in plan 9? Sent from my iPad > On Nov 26, 2015, at 2:27 AM, Bakul Shah wrote: > > Using 0xfff...f instead of 0 for a null ptr might've been less "disgusting"! > >> On Nov 25, 2015, at 6:04 PM, Prof Brucee wrote: >> >> gcc is indeed a very sad tome. The mmap of 0 is disgusting. I like kenc. It just works. My behaviour this afternoon will be undefined but not as stupid as that of some programmers. >> >>> On 26/11/2015 5:43 AM, "Brantley Coile" wrote: >>> Align it to column 7 and it looks like all the code I saw when I started. >>> >>> iPhone email >>> >>>> On Nov 25, 2015, at 12:13 PM, Ryan Gonzalez wrote: >>>> >>>> Neither! It's what happens when you run sed 's/^\s*//' on your whole code base, yielding results like (from cmd/yacc.c): >>>> >>>> >>>> void >>>> setup(int argc, char *argv[]) >>>> { >>>> long c, t; >>>> int i, j, fd, lev, ty, ytab, *p; >>>> int vflag, dflag, stem; >>>> char actnm[8], *stemc, *s, dirbuf[128]; >>>> Biobuf *fout; >>>> >>>> ytab = 0; >>>> vflag = 0; >>>> dflag = 0; >>>> stem = 0; >>>> stemc = "y"; >>>> foutput = 0; >>>> fdefine = 0; >>>> fdebug = 0; >>>> ARGBEGIN{ >>>> case 'v': >>>> case 'V': >>>> vflag++; >>>> break; >>>> case 'D': >>>> yydebug = ARGF(); >>>> break; >>>> case 'a': >>>> yyarg = 1; >>>> break; >>>> case 'd': >>>> dflag++; >>>> break; >>>> case 'l': >>>> yyline = 0; >>>> break; >>>> case 'o': >>>> ytab++; >>>> ytabc = ARGF(); >>>> break; >>>> case 's': >>>> stem++; >>>> stemc = ARGF(); >>>> break; >>>> case 'S': >>>> parser = PARSERS; >>>> break; >>>> default: >>>> error("illegal option: %c", ARGC()); >>>> }ARGEND >>>> openup(stemc, dflag, vflag, ytab, ytabc); >>>> fout = dflag?fdefine:ftable; >>>> if(yyarg){ >>>> Bprint(ftable, "#define\tYYARG\t1\n\n"); >>>> } >>>> if((fd = mkstemp(ttempname)) >= 0){ >>>> tempname = ttempname; >>>> ftemp = Bfdopen(fd, OWRITE); >>>> } >>>> if((fd = mkstemp(tactname)) >= 0){ >>>> actname = tactname; >>>> faction = Bfdopen(fd, OWRITE); >>>> } >>>> if(ftemp == 0 || faction == 0) >>>> error("cannot open temp file"); >>>> if(argc < 1) >>>> error("no input file"); >>>> infile = argv[0]; >>>> if(infile[0] != '/' && getwd(dirbuf, sizeof dirbuf)!=nil){ >>>> i = strlen(infile)+1+strlen(dirbuf)+1+10; >>>> s = malloc(i); >>>> if(s != nil){ >>>> snprint(s, i, "%s/%s", dirbuf, infile); >>>> cleanname(s); >>>> infile = s; >>>> } >>>> } >>>> finput = Bopen(infile, OREAD); >>>> if(finput == 0) >>>> error("cannot open '%s'", argv[0]); >>>> cnamp = cnames; >>>> >>>> defin(0, "$end"); >>>> extval = PRIVATE; /* tokens start in unicode 'private use' */ >>>> defin(0, "error"); >>>> defin(1, "$accept"); >>>> defin(0, "$unk"); >>>> mem = mem0; >>>> i = 0; >>>> >>>> for(t = gettok(); t != MARK && t != ENDFILE;) >>>> switch(t) { >>>> case ';': >>>> t = gettok(); >>>> break; >>>> >>>> case START: >>>> if(gettok() != IDENTIFIER) >>>> error("bad %%start construction"); >>>> start = chfind(1, tokname); >>>> t = gettok(); >>>> continue; >>>> >>>> case TYPEDEF: >>>> if(gettok() != TYPENAME) >>>> error("bad syntax in %%type"); >>>> ty = numbval; >>>> for(;;) { >>>> t = gettok(); >>>> switch(t) { >>>> case IDENTIFIER: >>>> if((t=chfind(1, tokname)) < NTBASE) { >>>> j = TYPE(toklev[t]); >>>> if(j != 0 && j != ty) >>>> error("type redeclaration of token %s", >>>> tokset[t].name); >>>> else >>>> SETTYPE(toklev[t], ty); >>>> } else { >>>> j = nontrst[t-NTBASE].value; >>>> if(j != 0 && j != ty) >>>> error("type redeclaration of nonterminal %s", >>>> nontrst[t-NTBASE].name ); >>>> else >>>> nontrst[t-NTBASE].value = ty; >>>> } >>>> case ',': >>>> continue; >>>> case ';': >>>> t = gettok(); >>>> default: >>>> break; >>>> } >>>> break; >>>> } >>>> continue; >>>> >>>> case UNION: >>>> /* copy the union declaration to the output */ >>>> cpyunion(); >>>> t = gettok(); >>>> continue; >>>> >>>> case LEFT: >>>> case BINARY: >>>> case RIGHT: >>>> i++; >>>> >>>> case TERM: >>>> /* nonzero means new prec. and assoc. */ >>>> lev = t-TERM; >>>> ty = 0; >>>> >>>> /* get identifiers so defined */ >>>> t = gettok(); >>>> >>>> /* there is a type defined */ >>>> if(t == TYPENAME) { >>>> ty = numbval; >>>> t = gettok(); >>>> } >>>> for(;;) { >>>> switch(t) { >>>> case ',': >>>> t = gettok(); >>>> continue; >>>> >>>> case ';': >>>> break; >>>> >>>> case IDENTIFIER: >>>> j = chfind(0, tokname); >>>> if(j >= NTBASE) >>>> error("%s defined earlier as nonterminal", tokname); >>>> if(lev) { >>>> if(ASSOC(toklev[j])) >>>> error("redeclaration of precedence of %s", tokname); >>>> SETASC(toklev[j], lev); >>>> SETPLEV(toklev[j], i); >>>> } >>>> if(ty) { >>>> if(TYPE(toklev[j])) >>>> error("redeclaration of type of %s", tokname); >>>> SETTYPE(toklev[j],ty); >>>> } >>>> t = gettok(); >>>> if(t == NUMBER) { >>>> tokset[j].value = numbval; >>>> if(j < ndefout && j > 3) >>>> error("please define type number of %s earlier", >>>> tokset[j].name); >>>> t = gettok(); >>>> } >>>> continue; >>>> } >>>> break; >>>> } >>>> continue; >>>> >>>> case LCURLY: >>>> defout(0); >>>> cpycode(); >>>> t = gettok(); >>>> continue; >>>> >>>> default: >>>> error("syntax error"); >>>> } >>>> if(t == ENDFILE) >>>> error("unexpected EOF before %%"); >>>> >>>> /* t is MARK */ >>>> if(!yyarg) >>>> Bprint(ftable, "extern int yyerrflag;\n"); >>>> Bprint(ftable, "#ifndef YYMAXDEPTH\n"); >>>> Bprint(ftable, "#define YYMAXDEPTH 150\n"); >>>> Bprint(ftable, "#endif\n" ); >>>> if(!ntypes) { >>>> Bprint(ftable, "#ifndef YYSTYPE\n"); >>>> Bprint(ftable, "#define YYSTYPE int\n"); >>>> Bprint(ftable, "#endif\n"); >>>> } >>>> if(!yyarg){ >>>> Bprint(ftable, "YYSTYPE yylval;\n"); >>>> Bprint(ftable, "YYSTYPE yyval;\n"); >>>> }else{ >>>> if(dflag) >>>> Bprint(ftable, "#include \"%s.%s\"\n\n", stemc, FILED); >>>> Bprint(fout, "struct Yyarg {\n"); >>>> Bprint(fout, "\tint\tyynerrs;\n"); >>>> Bprint(fout, "\tint\tyyerrflag;\n"); >>>> Bprint(fout, "\tvoid*\targ;\n"); >>>> Bprint(fout, "\tYYSTYPE\tyyval;\n"); >>>> Bprint(fout, "\tYYSTYPE\tyylval;\n"); >>>> Bprint(fout, "};\n\n"); >>>> } >>>> prdptr[0] = mem; >>>> >>>> /* added production */ >>>> *mem++ = NTBASE; >>>> >>>> /* if start is 0, we will overwrite with the lhs of the first rule */ >>>> *mem++ = start; >>>> *mem++ = 1; >>>> *mem++ = 0; >>>> prdptr[1] = mem; >>>> while((t=gettok()) == LCURLY) >>>> cpycode(); >>>> if(t != IDENTCOLON) >>>> error("bad syntax on first rule"); >>>> >>>> if(!start) >>>> prdptr[0][1] = chfind(1, tokname); >>>> >>>> /* read rules */ >>>> while(t != MARK && t != ENDFILE) { >>>> /* process a rule */ >>>> rlines[nprod] = lineno; >>>> if(t == '|') >>>> *mem++ = *prdptr[nprod-1]; >>>> else >>>> if(t == IDENTCOLON) { >>>> *mem = chfind(1, tokname); >>>> if(*mem < NTBASE) >>>> error("token illegal on LHS of grammar rule"); >>>> mem++; >>>> } else >>>> error("illegal rule: missing semicolon or | ?"); >>>> /* read rule body */ >>>> t = gettok(); >>>> >>>> more_rule: >>>> while(t == IDENTIFIER) { >>>> *mem = chfind(1, tokname); >>>> if(*mem < NTBASE) >>>> levprd[nprod] = toklev[*mem]; >>>> mem++; >>>> t = gettok(); >>>> } >>>> if(t == PREC) { >>>> if(gettok() != IDENTIFIER) >>>> error("illegal %%prec syntax"); >>>> j = chfind(2, tokname); >>>> if(j >= NTBASE) >>>> error("nonterminal %s illegal after %%prec", >>>> nontrst[j-NTBASE].name); >>>> levprd[nprod] = toklev[j]; >>>> t = gettok(); >>>> } >>>> if(t == '=') { >>>> levprd[nprod] |= ACTFLAG; >>>> Bprint(faction, "\ncase %d:", nprod); >>>> cpyact(mem-prdptr[nprod]-1); >>>> Bprint(faction, " break;"); >>>> if((t=gettok()) == IDENTIFIER) { >>>> >>>> /* action within rule... */ >>>> sprint(actnm, "$$%d", nprod); >>>> >>>> /* make it a nonterminal */ >>>> j = chfind(1, actnm); >>>> >>>> /* >>>> * the current rule will become rule number nprod+1 >>>> * move the contents down, and make room for the null >>>> */ >>>> for(p = mem; p >= prdptr[nprod]; --p) >>>> p[2] = *p; >>>> mem += 2; >>>> >>>> /* enter null production for action */ >>>> p = prdptr[nprod]; >>>> *p++ = j; >>>> *p++ = -nprod; >>>> >>>> /* update the production information */ >>>> levprd[nprod+1] = levprd[nprod] & ~ACTFLAG; >>>> levprd[nprod] = ACTFLAG; >>>> if(++nprod >= NPROD) >>>> error("more than %d rules", NPROD); >>>> prdptr[nprod] = p; >>>> >>>> /* make the action appear in the original rule */ >>>> *mem++ = j; >>>> >>>> /* get some more of the rule */ >>>> goto more_rule; >>>> } >>>> } >>>> >>>> while(t == ';') >>>> t = gettok(); >>>> *mem++ = -nprod; >>>> >>>> /* check that default action is reasonable */ >>>> if(ntypes && !(levprd[nprod]&ACTFLAG) && nontrst[*prdptr[nprod]-NTBASE].value) { >>>> >>>> /* no explicit action, LHS has value */ >>>> int tempty; >>>> >>>> tempty = prdptr[nprod][1]; >>>> if(tempty < 0) >>>> error("must return a value, since LHS has a type"); >>>> else >>>> if(tempty >= NTBASE) >>>> tempty = nontrst[tempty-NTBASE].value; >>>> else >>>> tempty = TYPE(toklev[tempty]); >>>> if(tempty != nontrst[*prdptr[nprod]-NTBASE].value) >>>> error("default action causes potential type clash"); >>>> } >>>> nprod++; >>>> if(nprod >= NPROD) >>>> error("more than %d rules", NPROD); >>>> prdptr[nprod] = mem; >>>> levprd[nprod] = 0; >>>> } >>>> >>>> /* end of all rules */ >>>> defout(1); >>>> >>>> finact(); >>>> if(t == MARK) { >>>> Bprint(ftable, "\n"); >>>> if(yyline) >>>> Bprint(ftable, "#line\t%d\t\"%s\"\n", lineno, infile); >>>> while((c=Bgetrune(finput)) != Beof) >>>> Bputrune(ftable, c); >>>> } >>>> Bterm(finput); >>>> } >>>> >>>> >>>>> On Wed, Nov 25, 2015 at 10:03 AM, wrote: >>>>> On Wed, Nov 25, 2015 at 09:25:55AM -0500, Brantley Coile wrote: >>>>> > unindented consequences >>>>> >>>>> Is that a class of Python bugs or an awesome name for a Nerdcore band? >>>> >>>> >>>> >>>> -- >>>> Ryan >>>> [ERROR]: Your autotools build scripts are 200 lines longer than your program. Something’s wrong. >>>> http://kirbyfan64.github.io/