Example #1
0
 /// <summary>
 /// Unions in C are translated into Java classes implementing the interface that defines the union
 /// </summary>
 /// <param name="u"></param>
 void GenUnion(TpmUnion u)
 {
     WriteComment(u);
     Write($"public interface {u.Name} extends TpmUnion");
     TabIn("{");
     Write($"public {GetUnionSelectorType(u)} GetUnionSelector();");
     TabOut("}", false);
 }
Example #2
0
 public void RegisterContainingUnion(TpmUnion u)
 {
     if (u.Implement && !ContainingUnions.Contains(u))
     {
         ContainingUnions.Add(u);
         if (DerivedFrom != null)
         {
             DerivedFrom.RegisterContainingUnion(u);
         }
     }
 }
Example #3
0
 public bool IsSubsetOf(TpmUnion u)
 {
     foreach (UnionMember m in Members)
     {
         if (!u.Members.Contains(m) &&
             !m.Type.SpecName.StartsWith("TPMS_NULL_"))
         {
             return(false);
         }
     }
     return(true);
 }
Example #4
0
        static void FixEnumTypeCollisions()
        {
            List <TpmStruct> toAdd = new List <TpmStruct>();

            for (int j = 0; j < TpmTypes.TheTypes.Count; j++)
            {
                TpmType tp = TpmTypes.TheTypes[j];
                if (!(tp is TpmUnion &&
                      tp.SpecName.IsOneOf(new string[] { "TPMU_PUBLIC_ID", "TPMU_SIGNATURE" })))
                {
                    continue;
                }

                // See if we have collisions.
                // Collided member types are converted into derived types by adding selector name to the base
                // type name. Struct that became a base one inherits from all the union interfaces, while
                // a derived struct only inherits from the base one and implements interfaces of the unions,
                // of which it is a member.
                // Base class B provides a union interface implementation only if this union contains a member
                // of type B. If a union U contains members of types derived from B, then B's implementation
                // of U's interface methods just throws NotImplementedException exception.
                TpmUnion u    = (TpmUnion)tp;
                var      dict = new Dictionary <string, UnionMember>();
                foreach (UnionMember m in u.Members)
                {
                    string typeName     = m.Type.SpecName;
                    string selectorName = m.SelectorValue.Name;
                    if (dict.ContainsKey(typeName))
                    {
                        // Collision detected.
                        Debug.WriteLine("Collision in {0} [{1}] -- {2}", u.Name, selectorName, typeName);

                        TpmStruct baseStruct = (TpmStruct)TpmTypes.Lookup(typeName);
                        AddDerivedStruct(baseStruct, m, u,
                                         "Auto-derived from " + baseStruct.SpecName +
                                         " to provide unique GetUnionSelector() implementation");
                        if (dict[typeName] != null)
                        {
                            // Create the derived structure for the first occurrence.
                            AddDerivedStruct(baseStruct, dict[typeName], u);
                            // But do it only once...
                            dict[typeName] = null;
                        }
                    }
                    else
                    {
                        dict.Add(typeName, m);
                    }
                }
            }
        } // FixEnumTypeCollisions()
Example #5
0
        /// <param name="selVal"> Upon return set to the value (qualified enum memeber) of the selector (or null). </param>
        /// <returns> Union selector type name if 's' is a member of a tagged union. Otherwise null. </returns>
        public static string GetUnionMemberSelectorInfo(TpmStruct s, out string selVal)
        {
            selVal = null;
            if (s.IsCmdStruct() || s.ContainingUnions.Count == 0)
            {
                return(null);
            }

            // If a struct is a member of multiple unions, all of them are expected to use the same selector value
            TpmUnion u = s.ContainingUnions.ElementAt(0);

            selVal = s.SpecName == TpmTypes.EmptyUnionBaseName ? TpmTypes.AlgNull
                   : u.GetMemberOfType(s).SelectorValue.QualifiedName;
            return(GetUnionSelectorType(u));
        }
Example #6
0
        void GenUnion(TpmUnion u)
        {
            if (!u.Implement)
            {
                return;
            }

            WriteComment(u);
            Write("class _DLLEXP_ " + u.Name + ": public virtual TpmUnion");
            TabIn("{");

            // Note: cannot sink GetUnionSelector() to the base TpmUnion interafce in C++,
            // as some unions use different unrelated enums as return types.
            Write($"public: virtual {GetUnionSelectorType(u)} GetUnionSelector() const = 0;");

            Write("public: virtual TpmStructure*  Clone() const { _ASSERT(FALSE); return NULL; };");
            TabOut("};");
        } // GenUnion()
Example #7
0
        public static void AddDerivedStruct(TpmStruct baseStruct, UnionMember curMember,
                                            TpmUnion curUnion, string comment = null)
        {
            string baseTypeName = baseStruct.SpecName;
            string newTypeName  = baseTypeName + "_" + RemoveEnumPrefix(curMember.SelectorValue.SpecName,
                                                                        curMember.SelectorValue.EnclosingEnum.SpecName);

            if (!TpmTypes.Contains(newTypeName))
            {
                var newStruct = new TpmStruct(newTypeName,
                                              comment ?? "Auto-derived from " + baseTypeName,
                                              baseStruct);
                TpmTypes.Add(newStruct);
            }

            var s = (TpmStruct)TpmTypes.Lookup(newTypeName);

            s.RegisterContainingUnion(curUnion);
            // Fix up the union field
            curMember.Type = s;
        }
Example #8
0
 /// <param name="selVal"> Upon return set to the value (qualified enum memeber) of the selector (or null). </param>
 /// <returns> Union selector type name if 's' is a member of a tagged union. Otherwise null. </returns>
 public static string GetUnionSelectorType(TpmUnion u)
 {
     return(u.Members[0].SelectorValue.EnclosingEnum.Name);
 }