home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 018.lha / parser / parse1.c < prev    next >
C/C++ Source or Header  |  1986-10-19  |  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.         The University of Arizona
  22.         Tucson, Arizona
  23.         85721
  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 = NULL;
  47.     contextvars = NULL;
  48.     maxcontext = 0;
  49.     addtemp("_self", NULL);
  50.     return(new);
  51. }
  52.  
  53. struct varstruct *mkvar(text, vtype) char *text; /*enum vartypes*/int vtype;
  54. {  struct varstruct *p;
  55.  
  56.    p = structalloc(varstruct);
  57.    p->vtype = vtype;
  58.    p->text = text;
  59.    p->nextvar = NULL;
  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*/  int 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(NULL);
  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 = NULL;
  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 */ int 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 = NULL;
  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 */ int 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 */ int 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 */ int 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.