Good points! Though 0 was a valid address on pdp11, right? May be if they had used ~0 as nil and not put any peripheral device at that address,  *nil would've had more immediate failures! Many ~0+offset errors would be caught on machines that trap 2 or 4 byte fetch/store to odd addresses.

I guess the real problem is that compilers don't generate tests to catch *nil (unless they can prove a ptr can't be nil). That + not generating bounds checks.

No comment on the Bay Area :-) Especially since we are trying to hire people!

> On Nov 26, 2015, at 3:22 AM, Brantley Coile <brantleycoile@me.com> wrote:
> 
> 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 <bakul@bitblocks.com> 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 <prof.brucee@gmail.com> 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" <brantleycoile@me.com> 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 <rymg19@gmail.com> 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, <plannine@sigint.cs.purdue.edu> 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/