home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d1xx / d183 / pcq.lha / PCQ / Source / Initialize.p < prev    next >
Text File  |  1989-02-26  |  6KB  |  250 lines
  1. external;
  2.  
  3. {
  4.     Initialize.p (of PCQ Pascal)
  5.     Copyright (c) 1989 Patrick Quaid.
  6.  
  7.     This routine initializes all the global variables and
  8. enters the standard identifiers.
  9. }
  10.  
  11. const
  12. {$I "pasconst.i"}
  13.  
  14. type
  15. {$I "pastype.i"}
  16.  
  17. var
  18. {$I "pasvar.i"}
  19.  
  20.     function addtype(a, b, c, d, e, f : integer): integer;
  21.         forward;
  22.     procedure enterspell(s : string);
  23.         forward;
  24.     function enterstandard(a, b, c, d, e, f, g : integer): integer;
  25.         forward;
  26.     function AllocString(l : integer): string;
  27.         forward;
  28.     
  29. procedure initstandard;
  30.  
  31. {
  32.     This is a huge routine, but since it's so straightforward I
  33. don't think I'll split it up.  It just enters all the standard
  34. identifiers into the identifier table.  Note that 'nil' is
  35. considered a standard identifier.
  36. }
  37.  
  38. var
  39.     dummy : integer;
  40.     niltype : integer;
  41.     spellint : integer;
  42. begin
  43.  
  44.     spellint := integer(adr(spelling)) - 1;
  45.  
  46.     badtype := addtype(vordinal, 0, 0, 0, 4, 0);
  47.     idents[badtype].name := string(spellint + spellptr);
  48.     enterspell(" ");
  49.  
  50.     inttype := addtype(vordinal, 0, 0, 0, 4, 0);
  51.     idents[inttype].name := string(spellint + spellptr);
  52.     enterspell("Integer");
  53.  
  54.     shorttype := addtype(vordinal, 0, 0, 0, 2, 0);
  55.     idents[shorttype].name := string(spellint + spellptr);
  56.     enterspell("Short");
  57.  
  58.     booltype := addtype(vordinal, 0, 0, 0, 1, 0);
  59.     idents[booltype].name := string(spellint + spellptr);
  60.     enterspell("Boolean");
  61.  
  62.     chartype := addtype(vordinal, 0, 0, 0, 1, 0);
  63.     idents[chartype].name := string(spellint + spellptr);
  64.     enterspell("Char");
  65.  
  66.     texttype := addtype(vfile, chartype, 0, 0, 18, 0);
  67.     idents[texttype].name := string(spellint + spellptr);
  68.     enterspell("Text");
  69.  
  70.     stringtype := addtype(vpointer, chartype, 0, 0, 4, 0);
  71.     idents[stringtype].name := string(spellint + spellptr);
  72.     enterspell("String");
  73.  
  74.     realtype := addtype(vreal, 0, 0, 0, 4, 0);
  75.     idents[realtype].name := string(spellint + spellptr);
  76.     enterspell("Real");
  77.  
  78.     bytetype := addtype(vordinal, 0, 0, 0, 1, 0);
  79.     idents[bytetype].name := string(spellint + spellptr);
  80.     enterspell("Byte");
  81.  
  82.     literaltype := addtype(varray, chartype, 1, 1, 1, inttype);
  83.  
  84.     dummy := enterstandard(stanproc, 1, 0, 0, 0, 0, 0);
  85.     enterspell("Write");
  86.  
  87.     dummy := enterstandard(stanproc, 2, 0, 0, 0, 0, 0);
  88.     enterspell("Writeln");
  89.  
  90.     dummy := enterstandard(stanproc, 3, 0, 0, 0, 0, 0);
  91.     enterspell("Read");
  92.  
  93.     dummy := enterstandard(stanproc, 4, 0, 0, 0, 0, 0);
  94.     enterspell("Readln");
  95.  
  96.     dummy := enterstandard(stanproc, 5, 0, 0, 0, 0, 0);
  97.     enterspell("New");
  98.  
  99.     dummy := enterstandard(stanproc, 6, 0, 0, 0, 0, 0);
  100.     enterspell("Dispose");
  101.  
  102.     dummy := enterstandard(stanproc, 7, 0, 0, 0, 0, 0);
  103.     enterspell("Close");
  104.  
  105.     dummy := enterstandard(stanproc, 8, 0, 0, 0, 0, 0);
  106.     enterspell("Get");
  107.  
  108.     dummy := enterstandard(stanproc, 9, 0, 0, 0, 0, 0);
  109.     enterspell("Exit");
  110.  
  111.     dummy := enterstandard(stanproc, 10, 0, 0, 0, 0, 0);
  112.     enterspell("Trap");
  113.  
  114.     dummy := enterstandard(stanfunc, 1, inttype, 0, 0, 0, 0);
  115.     enterspell("Ord");
  116.  
  117.     dummy := enterstandard(stanfunc, 2, chartype, 0, 0, 0, 0);
  118.     enterspell("Chr");
  119.  
  120.     dummy := enterstandard(stanfunc, 3, booltype, 0, 0, 0, 0);
  121.     enterspell("Odd");
  122.  
  123.     dummy := enterstandard(stanfunc, 4, inttype, 0, 0, 0, 0);
  124.     enterspell("Abs");
  125.  
  126.     dummy := enterstandard(stanfunc, 5, inttype, 0, 0, 0, 0);
  127.     enterspell("Succ");
  128.  
  129.     dummy := enterstandard(stanfunc, 6, inttype, 0, 0, 0, 0);
  130.     enterspell("Pred");
  131.  
  132.     dummy := enterstandard(stanfunc, 7, booltype, 0, 0, 0, 0);
  133.     enterspell("Reopen");
  134.  
  135.     dummy := enterstandard(stanfunc, 8, booltype, 0, 0, 0, 0);
  136.     enterspell("Open");
  137.  
  138.     dummy := enterstandard(stanfunc, 9, booltype, 0, 0, 0, 0);
  139.     enterspell("Eof");
  140.  
  141.  
  142.     dummy := enterstandard(constant, -1, booltype, 0, 0, 0, 0);
  143.     enterspell("True");
  144.  
  145.     dummy := enterstandard(constant, 0, booltype, 0, 0, 0, 0);
  146.     enterspell("False");
  147.  
  148.     dummy := enterstandard(constant, $7FFFFFFF, inttype, 0, 0, 0, 0);
  149.     enterspell("MaxInt");
  150.  
  151.     dummy := enterstandard(constant, $7FFF, shorttype, 0, 0, 0, 0);
  152.     enterspell("MaxShort");
  153.  
  154.     niltype := addtype(vpointer, badtype, 0, 0, 4, 0);
  155.     idents[niltype].name := string(spellint + spellptr);
  156.     enterspell("Address");
  157.  
  158.     dummy := enterstandard(constant, 0, niltype, 0, 0, 0, 0);
  159.     enterspell("Nil");
  160.  
  161.     dummy := enterstandard(stanfunc, 10, niltype, 0, 0, 0, 0);
  162.     enterspell("Adr");
  163.  
  164.     dummy := addtype(varray, chartype, 128, 1, 128, inttype);
  165.     dummy := enterstandard(global, 0, dummy, 0, 0, 0, 0);
  166.     enterspell("CommandLine");
  167. end;
  168.  
  169.  
  170. procedure initreserved();
  171.  
  172. {
  173.     This initializes the array of reserved words.  If you mess
  174. around with this, be advised that the symbol numbers defined in
  175. pasconst.i correspond with the indices of these words.  Look at
  176. searchreserved in utilities.p to explain the previous sentence.
  177. }
  178.  
  179. begin
  180.     reserved[1]  := "AND";
  181.     reserved[2]  := "ARRAY";
  182.     reserved[3]  := "BEGIN";
  183.     reserved[4]  := "BY";
  184.     reserved[5]  := "CASE";
  185.     reserved[6]  := "CONST";
  186.     reserved[7]  := "DIV";
  187.     reserved[8]  := "DO";
  188.     reserved[9]  := "DOWNTO";
  189.     reserved[10] := "ELSE";
  190.     reserved[11] := "END";
  191.     reserved[12] := "EXTERNAL";
  192.     reserved[13] := "FILE";
  193.     reserved[14] := "FOR";
  194.     reserved[15] := "FORWARD";
  195.     reserved[16] := "FUNCTION";
  196.     reserved[17] := "GOTO";
  197.     reserved[18] := "IF";
  198.     reserved[19] := "IN";
  199.     reserved[20] := "LABEL";
  200.     reserved[21] := "MOD";
  201.     reserved[22] := "NOT";
  202.     reserved[23] := "OF";
  203.     reserved[24] := "OR";
  204.     reserved[25] := "PACKED";
  205.     reserved[26] := "PRIVATE";
  206.     reserved[27] := "PROCEDURE";
  207.     reserved[28] := "PROGRAM";
  208.     reserved[29] := "RECORD";
  209.     reserved[30] := "REPEAT";
  210.     reserved[31] := "RETURN";
  211.     reserved[32] := "SET";
  212.     reserved[33] := "THEN";
  213.     reserved[34] := "TO";
  214.     reserved[35] := "TYPE";
  215.     reserved[36] := "UNTIL";
  216.     reserved[37] := "VAR";
  217.     reserved[38] := "WHILE";
  218.     reserved[39] := "WITH";
  219. end;
  220.  
  221. Procedure initglobals;
  222.  
  223. {
  224.     This just puts the startup values into the variables.
  225. }
  226.  
  227. begin
  228.     litlab := 1;
  229.  
  230.     symtext := allocstring(80);
  231.     includename := allocstring(80);
  232.  
  233.     eqstart := 0;
  234.     eqend := 0;
  235.     errorptr := 0;
  236.  
  237.     including := false;
  238.     identptr := 1;
  239.     spelling[0] := chr(0);
  240.     spellptr := 1;
  241.     litptr := 1;
  242.     errorcount := 0;
  243.     lineno := 1;
  244.     currsym := 0;
  245.     symloc := 0;
  246.     currfn := 0;
  247.     nxtlab := 1;
  248.     rangecheck := false;
  249. end;
  250.