Esempio n. 1
0
        internal override void PrintValue(TextWriter tw)
        {
            tw.WriteLine();
            string tname = Compiler.Encode(xo.ObjectType.Name);
            string name  = string.Format("t1v_{0}_{1}",
                                         xo.Serial, tname);

            if (xo is XObjectGen)
            {
                XObjectGen xog = (XObjectGen)xo;
                tw.Write("static const struct t1s_{0} {1} = ",
                         tname, name);
                PrintObjectGen(tw, 0, xog);
            }
            else if (xo is XArrayGeneric)
            {
                XArrayGeneric xag = (XArrayGeneric)xo;
                tw.WriteLine("static const t1x_array {0} = ",
                             name);
                PrintArray(tw, 0, xag);
            }
            else
            {
                throw new Exception(string.Format("internal error: EmitInstanceTopLevel on {0}", xo.GetType()));
            }
            tw.WriteLine(";");
        }
Esempio n. 2
0
    void FinishInterpreter(CPU cpu)
    {
        XValue[]      vv = cpu.PopToMarker();
        XArrayGeneric a  = new XArrayGeneric(XType.ARRAY_OBJECT);

        a.Init(new XBufferGen(vv), 0, vv.Length);
        cpu.Push(new XValue(a));
    }
Esempio n. 3
0
 internal void InitSub(XArrayGeneric src, int off, int len)
 {
     if (src.dataBuf == null)
     {
         throw new Exception("making sub-view of uninitialized array");
     }
     if (off < 0 || off > src.dataLen ||
         len < 0 || len > (src.dataLen - off))
     {
         throw new Exception(string.Format("sub-view ({0},{1}) does not fit in source array length {2}", off, len, src.dataLen));
     }
     this.dataBuf = src.dataBuf;
     this.dataOff = src.dataOff + off;
     this.dataLen = len;
 }
Esempio n. 4
0
    internal static void PrintArray(
        TextWriter tw, int indent, XArrayGeneric xag)
    {
        XType xt = xag.ObjectType;

        tw.WriteLine("{");
        Compiler.Indent(tw, indent + 1);
        tw.WriteLine("(void *)&t1t_{0},", Compiler.Encode(xt.Name));
        XBuffer xb = xag.dataBuf;

        if (xb == null)
        {
            /*
             * Uninitialized array.
             */
            Compiler.Indent(tw, indent + 1);
            tw.WriteLine("0, 0, 0");
        }
        else
        {
            EmitInstance ei;
            if (!toEmit.TryGetValue(xb, out ei))
            {
                throw new Exception("internal error: buffer is not scheduled for emission");
            }
            EmitInstanceBuffer eib = ei as EmitInstanceBuffer;
            if (eib == null)
            {
                throw new Exception("buffer not associated with EmitInstanceBuffer");
            }
            int range;
            int off;
            eib.FindRange(xag.dataOff, out range, out off);
            Compiler.Indent(tw, indent + 1);
            tw.WriteLine("(void *)&t1b_{0}_{1},",
                         xb.Serial, range);
            Compiler.Indent(tw, indent + 1);
            tw.WriteLine("{0},", off);
            Compiler.Indent(tw, indent + 1);
            tw.WriteLine("{0}", xag.dataLen);
        }
        Compiler.Indent(tw, indent);
        tw.Write("}");
    }
Esempio n. 5
0
    /*
     * Warning: this function does not check compatibility of values
     * with the destination type.
     */
    internal static XArrayGeneric Concat(
        XType type, params XArrayGeneric[] aa)
    {
        List <XValue> r = new List <XValue>();

        foreach (XArrayGeneric a in aa)
        {
            int n = a.Length;
            for (int i = 0; i < n; i++)
            {
                r.Add(a[i]);
            }
        }
        XArrayGeneric xag = new XArrayGeneric(type);
        XBuffer       xb  = new XBufferGen(r.ToArray());

        xag.Init(xb, 0, r.Count);
        return(xag);
    }
Esempio n. 6
0
    /*
     * Implementation of std::check-type-element.
     */
    internal void NativeCheckTypeElements(CPU cpu)
    {
        XArrayGeneric a = cpu.Pop().XObject as XArrayGeneric;
        int           n = a.Length;

        if (n == 0)
        {
            cpu.Push(false);
            return;
        }
        if (n == 1)
        {
            XValue xv = a[0];
            if (xv.VType == XType.INT)
            {
                cpu.Push(false);
                return;
            }
            if (xv.VType == XType.XTYPE)
            {
                cpu.Push(true);
                return;
            }
            throw new Exception(string.Format("unexpected object of type {0} in type definition", xv.VType.Name));
        }
        if (n == 2)
        {
            XValue xv = a[0];
            if (xv.VType != XType.INT)
            {
                throw new Exception(string.Format("unexpected object of type {0} in type definition", xv.VType.Name));
            }
            xv = a[1];
            if (xv.VType != XType.XTYPE)
            {
                throw new Exception(string.Format("unexpected object of type {0} in type definition", xv.VType.Name));
            }
            cpu.Push(true);
            return;
        }
        throw new Exception("too many elements for type definition");
    }
Esempio n. 7
0
    /*
     * Implementation of std::concat (on arrays of objects).
     */
    internal void NativeConcatArrayObject(CPU cpu)
    {
        XArrayGeneric b    = cpu.Pop().XObject as XArrayGeneric;
        XArrayGeneric a    = cpu.Pop().XObject as XArrayGeneric;
        int           alen = a.Length;
        int           blen = b.Length;
        XBuffer       xb   = new XBufferGen(a.Length + b.Length);

        for (int i = 0; i < alen; i++)
        {
            xb.Set(i, a[i]);
        }
        for (int i = 0; i < blen; i++)
        {
            xb.Set(alen + i, b[i]);
        }
        XArrayGeneric c = new XArrayGeneric(XType.ARRAY_OBJECT);

        c.Init(xb, 0, alen + blen);
        cpu.Push(new XValue(c));
    }
Esempio n. 8
0
    /*
     * Implementation of std::add-struct-element.
     */
    internal void NativeAddStructElement(CPU cpu)
    {
        XArrayGeneric a     = cpu.Pop().XObject as XArrayGeneric;
        bool          embed = cpu.Pop().Bool;
        string        name  = cpu.Pop().String;

        if (currentStruct == null)
        {
            throw new Exception("no current struct");
        }
        if (a.Length == 1)
        {
            XType xt = a[0].XTypeInstance;
            if (embed)
            {
                currentStruct.AddEmbed(name, xt);
            }
            else
            {
                currentStruct.AddField(name, xt);
            }
        }
        else if (a.Length == 2)
        {
            int   size = a[0].Int;
            XType xt   = a[1].XTypeInstance;
            if (embed)
            {
                currentStruct.AddArrayEmbed(name, size, xt);
            }
            else
            {
                currentStruct.AddArrayField(name, size, xt);
            }
        }
        else
        {
            throw new Exception("invalid type definition");
        }
    }
Esempio n. 9
0
    /*
     * Implementation of std::define-typed-local.
     */
    internal void NativeAddTypedLocal(CPU cpu)
    {
        XArrayGeneric a     = cpu.Pop().XObject as XArrayGeneric;
        bool          embed = cpu.Pop().Bool;
        string        name  = cpu.Pop().String;

        if (a.Length == 1)
        {
            XType xt = a[0].XTypeInstance;
            if (embed)
            {
                CurrentBuilder.DefLocalEmbed(name, xt);
            }
            else
            {
                CurrentBuilder.DefLocalField(name, xt);
            }
        }
        else if (a.Length == 2)
        {
            int   size = a[0].Int;
            XType xt   = a[1].XTypeInstance;
            if (embed)
            {
                CurrentBuilder.DefLocalEmbedArray(
                    name, size, xt);
            }
            else
            {
                CurrentBuilder.DefLocalFieldArray(
                    name, size, xt);
            }
        }
        else
        {
            throw new Exception("invalid type definition");
        }
    }
Esempio n. 10
0
    static EmitInstance AddInstance(XObject xo,
                                    EmitInstance container, int index)
    {
        EmitInstance ei;

        if (toEmit.TryGetValue(xo, out ei))
        {
            /*
             * We already have an EmitInstance for this object.
             *
             * If container is null, then we can simply keep
             * the existing instance, and we do not have to
             * propagate things any further: the object is
             * already handled.
             *
             * If container is not null, but the existing
             * instance is top-level, then we must convert it
             * to an EmitInstanceEmbedded; all its embedded
             * values automatically follow.
             *
             * Since embedding is a tree, there should be no
             * case where container is not null AND the
             * existing EmitInstance is also of embedded type.
             */
            if (container != null)
            {
                if (!(ei is EmitInstanceTopLevel))
                {
                    throw new Exception("internal error: instance already embedded, or not embeddable");
                }
                ei = new EmitInstanceEmbedded(xo,
                                              container, index);
                toEmit[xo] = ei;
            }
            return(ei);
        }

        /*
         * We have a new instance. We create the object, then
         * recursively walk over its fields and embedded values.
         */
        if (xo is XObjectGen)
        {
            if (container != null)
            {
                ei = new EmitInstanceEmbedded(xo,
                                              container, index);
            }
            else
            {
                ei = new EmitInstanceTopLevel(xo);
            }
            XObjectGen xog = (XObjectGen)xo;
            int        n;
            n = xog.fields.Length;
            for (int i = 0; i < n; i++)
            {
                AddValueInner(xog.fields[i]);
            }
            n = xog.embeds.Length;
            for (int i = 0; i < n; i++)
            {
                AddInstance(xog.embeds[i], ei, i);
            }
        }
        else if (xo is XArrayGeneric)
        {
            if (container != null)
            {
                ei = new EmitInstanceEmbedded(xo,
                                              container, index);
            }
            else
            {
                ei = new EmitInstanceTopLevel(xo);
            }
            XArrayGeneric xag = (XArrayGeneric)xo;
            AddBuffer(xag.dataBuf,
                      xag.ObjectType.GetArrayElementType(),
                      xag.ObjectType.arrayElementEmbedded,
                      xag.dataOff, xag.dataLen);

            /* obsolete
             * } else if (xo is XString) {
             *      throw new Exception("NYI");
             */
        }
        else if (xo is XType)
        {
            ei = new EmitXType((XType)xo);
        }
        else
        {
            throw new Exception(string.Format("unsupported object type for serialization: {0}", xo.ObjectType.Name));
        }
        toEmit[xo] = ei;
        return(ei);
    }