home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / dev / alst-3.04.lha / ALSt-3.04 / src / parser.c < prev    next >
C/C++ Source or Header  |  1994-05-14  |  21KB  |  818 lines
  1. /*
  2.     Little Smalltalk, version 2
  3.     Written by Tim Budd, Oregon State University, July 1987
  4.  
  5.     Method parser - parses the textual description of a method,
  6.     generating bytecodes and literals.
  7.  
  8.     This parser is based around a simple minded recursive descent
  9.     parser.
  10.     It is used both by the module that builds the initial virtual image,
  11.     and by a primitive when invoked from a running Smalltalk system.
  12.  
  13.     The latter case could, if the bytecode interpreter were fast enough,
  14.     be replaced by a parser written in Smalltalk.  This would be preferable,
  15.     but not if it slowed down the system too terribly.
  16.  
  17.     To use the parser the routine setInstanceVariables must first be
  18.     called with a class object.  This places the appropriate instance
  19.     variables into the memory buffers, so that references to them
  20.     can be correctly encoded.
  21.  
  22.     As this is recursive descent, you should read it SDRAWKCAB !
  23.         (from bottom to top)
  24. */
  25. # include <stdio.h>
  26. # include <ctype.h>
  27. # include "env.h"
  28. # include "memory.h"
  29. # include "names.h"
  30. # include "interp.h"
  31. # include "lex.h"
  32. # ifdef STRING
  33. # include <string.h>
  34. # endif
  35. # ifdef STRINGS
  36. # include <strings.h>
  37. # endif
  38.  
  39.         /* all of the following limits could be increased (up to
  40.             256) without any trouble.  They are kept low 
  41.             to keep memory utilization down */
  42.  
  43. # define codeLimit 256        /* maximum number of bytecodes permitted */
  44. # define literalLimit 128    /* maximum number of literals permitted */
  45. # define temporaryLimit 32    /* maximum number of temporaries permitted */
  46. # define argumentLimit 32    /* maximum number of arguments permitted */
  47. # define instanceLimit 32    /* maximum number of instance vars permitted */
  48. # define methodLimit 64        /* maximum number of methods permitted */
  49.  
  50. boolean parseok;            /* parse still ok? */
  51. extern char peek();
  52. static int codeTop;            /* top position filled in code array */
  53. static byte codeArray[codeLimit];    /* bytecode array */
  54. static int literalTop;            /*  ... etc. */
  55. static object literalArray[literalLimit];
  56. static int temporaryTop;
  57. static char *temporaryName[temporaryLimit];
  58. static int argumentTop;
  59. static char *argumentName[argumentLimit];
  60. static int instanceTop;
  61. static char *instanceName[instanceLimit];
  62.  
  63. static int maxTemporary;        /* highest temporary see so far */
  64. static char selector[80];        /* message selector */
  65.  
  66. enum blockstatus {NotInBlock, InBlock, OptimizedBlock} blockstat;
  67.  
  68. setInstanceVariables(aClass)
  69. object aClass;
  70. {    int i, limit;
  71.     object vars;
  72.  
  73.     if (aClass == nilobj)
  74.         instanceTop = 0;
  75.     else {
  76.         setInstanceVariables(basicAt(aClass, superClassInClass));
  77.         vars = basicAt(aClass, variablesInClass);
  78.         if (vars != nilobj) {
  79.             limit = sizeField(vars);
  80.             for (i = 1; i <= limit; i++)
  81.                 instanceName[++instanceTop] = charPtr(basicAt(vars, i));
  82.             }
  83.         }
  84. }
  85.  
  86. static genCode(value)
  87. int value;
  88. {
  89.     if (codeTop >= codeLimit)
  90.         compilError(selector,"too many bytecode instructions in method","");
  91.     else
  92.         codeArray[codeTop++] = value;
  93. }
  94.  
  95. static genInstruction(high, low)
  96. int high, low;
  97. {
  98.     if (low >= 16) {
  99.         genInstruction(Extended, high);
  100.         genCode(low);
  101.         }
  102.     else
  103.         genCode(high * 16 + low);
  104. }
  105.  
  106. static int genLiteral(aLiteral)
  107. object aLiteral;
  108. {
  109.     if (literalTop >= literalLimit)
  110.         compilError(selector,"too many literals in method","");
  111.     else {
  112.         literalArray[++literalTop] = aLiteral;
  113.         incr(aLiteral);
  114.         }
  115.     return(literalTop - 1);
  116. }
  117.  
  118. static genInteger(val)    /* generate an integer push */
  119. int val;
  120. {
  121.     if (val == -1)
  122.         genInstruction(PushConstant, minusOne);
  123.     else if ((val >= 0) && (val <= 2))
  124.         genInstruction(PushConstant, val);
  125.     else
  126.         genInstruction(PushLiteral,
  127.             genLiteral(newInteger(val)));
  128. }
  129.  
  130. static char *glbsyms[] = {"currentInterpreter", "nil", "true", "false",
  131. 0 };
  132.  
  133. static boolean nameTerm(name)
  134. char *name;
  135. {    int i;
  136.     boolean done = false;
  137.     boolean isSuper = false;
  138.  
  139.     /* it might be self or super */
  140.     if (streq(name, "self") || streq(name, "super")) {
  141.         genInstruction(PushArgument, 0);
  142.         done = true;
  143.         if (streq(name,"super")) isSuper = true;
  144.         }
  145.  
  146.     /* or it might be a temporary (reverse this to get most recent first)*/
  147.     if (! done)
  148.         for (i = temporaryTop; (! done) && ( i >= 1 ) ; i--)
  149.             if (streq(name, temporaryName[i])) {
  150.                 genInstruction(PushTemporary, i-1);
  151.                 done = true;
  152.                 }
  153.  
  154.     /* or it might be an argument */
  155.     if (! done)
  156.         for (i = 1; (! done) && (i <= argumentTop ) ; i++)
  157.             if (streq(name, argumentName[i])) {
  158.                 genInstruction(PushArgument, i);
  159.                 done = true;
  160.                 }
  161.  
  162.     /* or it might be an instance variable */
  163.     if (! done)
  164.         for (i = 1; (! done) && (i <= instanceTop); i++) {
  165.             if (streq(name, instanceName[i])) {
  166.                 genInstruction(PushInstance, i-1);
  167.                 done = true;
  168.                 }
  169.             }
  170.  
  171.     /* or it might be a global constant */
  172.     if (! done)
  173.         for (i = 0; (! done) && glbsyms[i]; i++)
  174.             if (streq(name, glbsyms[i])) {
  175.                 genInstruction(PushConstant, i+4);
  176.                 done = true;
  177.                 }
  178.  
  179.     /* not anything else, it must be a global */
  180.     /* must look it up at run time */
  181.     if (! done) {
  182.         genInstruction(PushLiteral, genLiteral(newSymbol(name)));
  183.         genMessage(false, 0, newSymbol("value"));
  184.         }
  185.  
  186.     return(isSuper);
  187. }
  188.  
  189. static int parseArray()
  190. {    int i, size, base;
  191.     object newLit, obj;
  192.  
  193.     base = literalTop;
  194.     ignore nextToken();
  195.     while (parseok && (token != closing)) {
  196.         switch(token) {
  197.             case arraybegin:
  198.                 ignore parseArray();
  199.                 break;
  200.  
  201.             case intconst:
  202.                 ignore genLiteral(newInteger(tokenInteger));
  203.                 ignore nextToken();
  204.                 break;
  205.  
  206.             case floatconst:
  207.                 ignore genLiteral(newFloat(tokenFloat));
  208.                 ignore nextToken();
  209.                 break;
  210.  
  211.             case nameconst: case namecolon: case symconst:
  212.                 ignore genLiteral(newSymbol(tokenString));
  213.                 ignore nextToken();
  214.                 break;
  215.  
  216.             case binary:
  217.                 if (streq(tokenString, "(")) {
  218.                     ignore parseArray();
  219.                     break;
  220.                     }
  221.                 if (streq(tokenString, "-") && isdigit(peek())) {
  222.                     ignore nextToken();
  223.                     if (token == intconst)
  224.                         ignore genLiteral(newInteger(- tokenInteger));
  225.                     else if (token == floatconst) {
  226.                         ignore genLiteral(newFloat(-tokenFloat));
  227.                         }
  228.                     else
  229.                         compilError(selector,"negation not followed",
  230.                             "by number");
  231.                     ignore nextToken();
  232.                     break;
  233.                     }
  234.                 ignore genLiteral(newSymbol(tokenString));
  235.                 ignore nextToken();
  236.                 break;
  237.  
  238.             case charconst:
  239.                 ignore genLiteral(newChar( tokenInteger));
  240.                 ignore nextToken();
  241.                 break;
  242.  
  243.             case strconst:
  244.                 ignore genLiteral(newStString(tokenString));
  245.                 ignore nextToken();
  246.                 break;
  247.  
  248.             default:
  249.                 compilError(selector,"illegal text in literal array",
  250.                     tokenString);
  251.                 ignore nextToken();
  252.                 break;
  253.         }
  254.     }
  255.  
  256.     if (parseok)
  257.         if (! streq(tokenString, ")"))
  258.             compilError(selector,"array not terminated by right parenthesis",
  259.                 tokenString);
  260.         else
  261.             ignore nextToken();
  262.     size = literalTop - base;
  263.     newLit = newArray(size);
  264.     for (i = size; i >= 1; i--) {
  265.         obj = literalArray[literalTop];
  266.         basicAtPut(newLit, i, obj);
  267.         decr(obj);
  268.         literalArray[literalTop] = nilobj;
  269.         literalTop = literalTop - 1;
  270.         }
  271.     return(genLiteral(newLit));
  272. }
  273.  
  274. static boolean term()
  275. {    boolean superTerm = false;    /* true if term is pseudo var super */
  276.  
  277.     if (token == nameconst) {
  278.         superTerm = nameTerm(tokenString);
  279.         ignore nextToken();
  280.         }
  281.     else if (token == intconst) {
  282.         genInteger(tokenInteger);
  283.         ignore nextToken();
  284.         }
  285.     else if (token == floatconst) {
  286.         genInstruction(PushLiteral, genLiteral(newFloat(tokenFloat)));
  287.         ignore nextToken();
  288.         }
  289.     else if ((token == binary) && streq(tokenString, "-")) {
  290.         ignore nextToken();
  291.         if (token == intconst)
  292.             genInteger(- tokenInteger);
  293.         else if (token == floatconst) {
  294.             genInstruction(PushLiteral,
  295.                 genLiteral(newFloat(-tokenFloat)));
  296.             }
  297.         else
  298.             compilError(selector,"negation not followed",
  299.                 "by number");
  300.         ignore nextToken();
  301.         }
  302.     else if (token == charconst) {
  303.         genInstruction(PushLiteral,
  304.             genLiteral(newChar(tokenInteger)));
  305.         ignore nextToken();
  306.         }
  307.     else if (token == symconst) {
  308.         genInstruction(PushLiteral,
  309.             genLiteral(newSymbol(tokenString)));
  310.         ignore nextToken();
  311.         }
  312.     else if (token == strconst) {
  313.         genInstruction(PushLiteral,
  314.             genLiteral(newStString(tokenString)));
  315.         ignore nextToken();
  316.         }
  317.     else if (token == arraybegin) {
  318.         genInstruction(PushLiteral, parseArray());
  319.         }
  320.     else if ((token == binary) && streq(tokenString, "(")) {
  321.         ignore nextToken();
  322.         express