home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_200 / 232_01 / parse1.c < prev    next >
Text File  |  1987-06-17  |  7KB  |  339 lines
  1. /*
  2.     Little Smalltalk
  3.         pass 1 of the parser
  4.  
  5.         timothy a. budd, 10/84
  6.  
  7. */
  8. /*
  9.     The source code for the Little Smalltalk System may be freely
  10.     copied provided that the source of all files is acknowledged
  11.     and that this condition is copied with each file.
  12.  
  13.     The Little Smalltalk System is distributed without responsibility
  14.     for the performance of the program and without any guarantee of
  15.     maintenance.
  16.  
  17.     All questions concerning Little Smalltalk should be addressed to:
  18.  
  19.         Professor Tim Budd
  20.         Department of Computer Science
  21.         Oregon State University
  22.         Corvallis, Oregon
  23.         97331
  24.         USA
  25. */
  26. # include <stdio.h>
  27. # include "env.h"
  28. # include "drive.h"
  29. # include "parser.h"
  30. # include "y.tab.h"
  31.  
  32. extern char *alloc();
  33.  
  34. int maxcontext = 0;
  35.  
  36. struct classstruct *mkclass(classname, supername)
  37. char *classname, *supername;
  38. {    struct classstruct *new;
  39.     struct varstruct *mkvar(), *addvlist();
  40.  
  41.     new = structalloc(classstruct);
  42.     new->name = classname;
  43.     if (supername)
  44.         new->super = supername;
  45.     else new->super = walloc("Object");
  46.     instvars = (struct varstruct *) 0;
  47.     contextvars = (struct varstruct *) 0;
  48.     maxcontext = 0;
  49.     addtemp("_self", (enum vartypes) 0);
  50.     return(new);
  51. }
  52.  
  53. struct varstruct *mkvar(text, vtype) char *text; enum vartypes vtype;
  54. {  struct varstruct *p;
  55.  
  56.    p = structalloc(varstruct);
  57.    p->vtype = vtype;
  58.    p->text = text;
  59.    p->nextvar = (struct varstruct *) 0;
  60.    p->position = 17;
  61.    return(p);
  62. }
  63.  
  64. struct varstruct *addvlist(varnode, vlist)
  65. struct varstruct *varnode, *vlist;
  66. {
  67.    varnode->nextvar = vlist;
  68.    if (vlist) varnode->position = 1 + vlist->position;
  69.    else varnode->position = 0;
  70.    return(varnode);
  71. }
  72.  
  73. addtemp(name, vtype)
  74. char *name;
  75. enum vartypes vtype;
  76. {
  77.     contextvars = addvlist(mkvar(name, vtype), contextvars);
  78.     if (contextvars->position > maxcontext)
  79.         maxcontext = contextvars->position;
  80. }
  81.  
  82. struct varstruct *invlist(varnode, name)
  83. struct varstruct *varnode;
  84. char *name;
  85. {
  86.     for ( ; varnode; varnode = varnode->nextvar)
  87.         if (strcmp(varnode->text, name) == 0)
  88.             return(varnode);
  89.     return((struct varstruct *) 0);
  90. }
  91.  
  92. struct methodstruct *mkmethod(pat, temps, state)
  93. struct exprstruct *pat;
  94. int temps;
  95. struct statestruct *state;
  96. {    struct methodstruct *new;
  97.     int i;
  98.  
  99.     new = structalloc(methodstruct);
  100.     new->pattern = pat;
  101.     new->numtempvars = temps;
  102.     new->states = state;
  103.     new->nextmethod = (struct methodstruct *) 0;
  104.     switch(pat->cmdtype) {
  105.         case uncmd: i = 0; break;
  106.         case bincmd: i = 1; break;
  107.         case keycmd: i = keycount(pat->cc.keys); break;
  108.         }
  109.     deltemps(i);
  110.     return(new);
  111. }
  112.  
  113. keycount(kl)
  114. struct keylist *kl;
  115. {
  116.     if (kl->nextkey)
  117.         return(1 + keycount(kl->nextkey));
  118.     else return(1);
  119. }
  120.  
  121. struct statestruct *mkstate(type, name, sexpr)
  122. enum statetypes type;
  123. char *name;
  124. struct statestruct *sexpr;
  125. {    struct statestruct *new;
  126.     struct varstruct *v;
  127.  
  128.     new = structalloc(statestruct);
  129.     new->statetype = type;
  130.     new->nextstate = (struct statestruct *) 0;
  131.     switch(type) {
  132.         case upar: case blkupar:
  133.             new->nn.stateexpr = sexpr;
  134.             break;
  135.         case expr:
  136.             new->nn.cmd = (struct exprstruct *) sexpr;
  137.             break;
  138.         case asgn:
  139.             new->nn.stateexpr = sexpr;
  140.             v = invlist(instvars, name);
  141.             if (v) {
  142.                 new->statetype = iasgn;
  143.                 new->mm.varpos = v->position;
  144.                 break;
  145.                 }
  146.             v = invlist(contextvars, name);
  147.             if (v) {
  148.                 new->statetype = casgn;
  149.                 new->mm.varpos = v->position;
  150.                 break;
  151.                 }
  152.         default:
  153.             yyerror("unknown variable or case in mkstate");
  154.         }
  155.     return(new);
  156. }
  157.  
  158. struct exprstruct *mkexpr(receiver, type, name, args)
  159. struct exprstruct *receiver, *args;
  160. enum cmdtypes type;
  161. char *name;
  162. {    struct exprstruct *new;
  163.  
  164.     new = structalloc(exprstruct);
  165.     new->cmdtype = type;
  166.     new->cmdname = name;
  167.     new->receiver = receiver;
  168.     switch(type) {
  169.         case reccmd:
  170.             new->cc.recobj = (struct objstruct *) args;
  171.             break;
  172.         case uncmd:
  173.             break;
  174.         case bincmd:
  175.             new->cc.argument = args;
  176.             break;
  177.         case keycmd:
  178.             new->cc.keys = (struct keylist *) args;
  179.             break;
  180.         }
  181.     return(new);
  182. }
  183.  
  184. struct keylist *mkklist(kl, kw, ka)
  185. struct keylist *kl;
  186. char *kw;
  187. struct exprstruct *ka;
  188. {    struct keylist *new;
  189.  
  190.     new = structalloc(keylist);
  191.     new->keyword = kw;
  192.     new->arg = ka;
  193.     new->nextkey = kl;
  194.     return(new);
  195. }
  196.     
  197. mkkname(kl, kb)
  198. struct keylist *kl;
  199. char *kb;
  200. {
  201.     if (kl->nextkey)
  202.         mkkname(kl->nextkey, kb);
  203.     strcat(kb, kl->keyword);
  204. }
  205.  
  206. struct exprstruct *mkkey(receiver, keywordlist)
  207. struct exprstruct *receiver;
  208. struct keylist *keywordlist;
  209. {    char kbuffer[500];
  210.  
  211.     kbuffer[0] = '\0';
  212.     mkkname(keywordlist, kbuffer);
  213.     return(mkexpr(receiver, keycmd, walloc(kbuffer),
  214.         (struct exprstruct *) keywordlist));
  215. }
  216.  
  217. struct objstruct *mkobj(type, info)
  218. enum objtypes type;
  219. YYSTYPE *info;
  220. {    struct objstruct *new;
  221.     struct varstruct *v;
  222.     struct litstruct *mklit();
  223.  
  224.     new = structalloc(objstruct);
  225.     new->objtype = type;
  226.     switch(type) {
  227.         case classobj:
  228.             new->ee.litinfo = mklit(symlit, info);
  229.             break;
  230.         case varobj:
  231.             v = invlist(instvars, info->c);
  232.             if (v) {
  233.                 new->objtype = instvarobj;
  234.                 new->ee.varoffset = v->position;
  235.                 return(new);
  236.                 }
  237.             v = invlist(contextvars, info->c);
  238.             if (v) {
  239.                 new->objtype = contvarobj;
  240.                 new->ee.varoffset = v->position;
  241.                 return(new);
  242.                 }
  243.             yerr("unknown variable %s", info->c);
  244.             break;
  245.         case litobj:
  246.             new->ee.litinfo = info->t;
  247.             break;
  248.         case pseuobj:
  249.             new->ee.pseuinfo = info->p;
  250.             break;
  251.         case primobj:
  252.             new->ee.priminfo = info->u;
  253.             break;
  254.         case exprobj:
  255.             new->ee.stateinfo = info->s;
  256.             break;
  257.         case blockobj:
  258.             new->ee.blockinfo = info->b;
  259.             break;
  260.     }
  261.     return(new);
  262. }
  263.  
  264. struct blockstruct *mkblock(numargs, bstates)
  265. int numargs;
  266. struct statestruct *bstates;
  267. {    struct blockstruct *new;
  268.     int i;
  269.  
  270.     new = structalloc(blockstruct);
  271.     new->numargs = numargs;
  272.     if (contextvars)
  273.         i = (contextvars->position - numargs) +1;
  274.     else i = 1;
  275.     new->arglocation = i;
  276.     new->bstates = bstates;
  277.     return(new);
  278. }
  279.  
  280.  
  281. struct primstruct *mkprim(pnum, plist)
  282. struct primlist *plist;
  283. int pnum;
  284. {    struct primstruct *new;
  285.  
  286.     new = structalloc(primstruct);
  287.     new->primnumber = pnum;
  288.     new->plist = plist;
  289.     return(new);
  290. }
  291.  
  292. struct primlist *addprim(plist, prim)
  293. struct primlist *plist;
  294. struct objstruct *prim;
  295. {    struct primlist *new;
  296.  
  297.     new = structalloc(primlist);
  298.     new->nextprim = plist;
  299.     new->pobject = prim;
  300.     return(new);
  301. }
  302.  
  303. struct litlist *addlit(list, lit)
  304. struct litlist *list;
  305. struct litstruct *lit;
  306. {    struct litlist *new;
  307.  
  308.     new = structalloc(litlist);
  309.     new->litele = lit;
  310.     new->nextlit = list;
  311.     return(new);
  312. }
  313.  
  314. struct litstruct *mklit(littype, e)
  315. enum littypes littype;
  316. YYSTYPE *e;
  317. {  struct litstruct *p;
  318.  
  319.     p = structalloc(litstruct);
  320.     p->littype = littype;
  321.     switch(littype) {
  322.         case numlit:  p->ll.litint = e->i; break;
  323.         case fnumlit: p->ll.litstr = e->c; break;
  324.         case charlit: p->ll.litchar = (char) e->i; break;
  325.         case strlit:  p->ll.litstr = e->c; break;
  326.         case symlit:  p->ll.litsym = e->c; break;
  327.         case arlit:   p->ll.litarry = e->a; break;
  328.           }
  329.     return(p);
  330. }
  331.  
  332. deltemps(n)
  333. int n;
  334. {
  335.     while (n--) {
  336.         contextvars = contextvars->nextvar;
  337.         }
  338. }
  339.