_ Git - BearSSL/blob - T0/Word.cs

   1 /*
   2  * Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24
  25 using System;
  26 using System.Collections.Generic;
  27
  28 /*
  29  * A "word" is a function with a name. Words can be either native or
  30  * interpreted; native words are implemented as some in-compiler special
  31  * code.
  32  *
  33  * Some native words (not all of them) have a C implementation and can
  34  * thus be part of the generated C code. Native words with no C
  35  * implementation can be used only during compilation; this is typically
  36  * the case for words that support the syntax (e.g. 'if').
  37  */
  38
  39 abstract class Word {
  40
  41         /*
  42          * The compiler context for this word.
  43          */
  44         internal T0Comp TC {
  45                 get; private set;
  46         }
  47
  48         /*
  49          * Immediate words are executed immediately when encountered in the
  50          * source code, even while compiling another word.
  51          */
  52         internal bool Immediate {
  53                 get; set;
  54         }
  55
  56         /*
  57          * Each word has a unique name. Names are case-sensitive.
  58          */
  59         internal string Name {
  60                 get; private set;
  61         }
  62
  63         /*
  64          * Words are allocated slot numbers when output code is generated.
  65          */
  66         internal int Slot {
  67                 get; set;
  68         }
  69
  70         /*
  71          * Each word may have a known stack effect.
  72          */
  73         internal SType StackEffect {
  74                 get; set;
  75         }
  76
  77         internal Word(T0Comp owner, string name)
  78         {
  79                 TC = owner;
  80                 Name = name;
  81                 StackEffect = SType.UNKNOWN;
  82         }
  83
  84         /*
  85          * Resolving a word means looking up all references to external
  86          * words.
  87          */
  88         internal virtual void Resolve()
  89         {
  90         }
  91
  92         /*
  93          * Execute this word. If the word is native, then its code is
  94          * run right away; if the word is interpreted, then the entry
  95          * sequence is executed.
  96          */
  97         internal virtual void Run(CPU cpu)
  98         {
  99                 throw new Exception(String.Format(
 100                         "cannot run '{0}' at compile-time", Name));
 101         }
 102
 103         /*
 104          * All words may have an explicit C implementations. To be part
 105          * of the generated C code, a word must either be interpreted,
 106          * or have an explicit C implementation, or both.
 107          */
 108         internal string CCode {
 109                 get; set;
 110         }
 111
 112         /*
 113          * Get all words referenced from this one. This implies
 114          * resolving the word.
 115          */
 116         internal virtual List<Word> GetReferences()
 117         {
 118                 return new List<Word>();
 119         }
 120
 121         /*
 122          * Get all data blocks directly referenced from this one. This
 123          * implies resolving the word.
 124          */
 125         internal virtual List<ConstData> GetDataBlocks()
 126         {
 127                 return new List<ConstData>();
 128         }
 129
 130         /*
 131          * Produce the code elements for this word.
 132          */
 133         internal virtual void GenerateCodeElements(List<CodeElement> dst)
 134         {
 135                 throw new Exception("Word does not yield code elements");
 136         }
 137
 138         /*
 139          * Compute/verify stack effect for this word.
 140          */
 141         internal virtual void AnalyseFlow()
 142         {
 143         }
 144
 145         /*
 146          * Get maximum data stack usage for this word. This is the number
 147          * of extra slots that this word may need on the data stack. If
 148          * the stack effect is not known, this returns -1.
 149          */
 150         internal virtual int MaxDataStack {
 151                 get {
 152                         SType se = StackEffect;
 153                         if (!se.IsKnown) {
 154                                 return -1;
 155                         }
 156                         if (se.NoExit) {
 157                                 return 0;
 158                         } else {
 159                                 return Math.Min(0, se.DataOut - se.DataIn);
 160                         }
 161                 }
 162         }
 163
 164         /*
 165          * Get maximum return stack usage for this word.
 166          */
 167         internal virtual int MaxReturnStack {
 168                 get {
 169                         return 0;
 170                 }
 171         }
 172 }