C# StreamWriterLevel类代码示例

        public static void PrintC(ArrayValue pThis, StreamWriterLevel c, int lev)
        {
            c.WriteLine("{");
            lev++;

            int cnt = pThis.m_children.Count;

            c.P(lev); c.WriteLine("{0},", cnt);

            c.P(lev); c.WriteLine("{");
            for (int i = 0; i < cnt; i++)
            {
                c.P(lev + 1);
                ((ISCCVariable)pThis.m_children[i]).PrintC(c, lev + 1);
                if (i != cnt - 1)
                    c.WriteLine(",");
                else
                    c.WriteLine();
            }
            c.P(lev); c.WriteLine("}");

            lev--;
            c.P(lev);
            c.Write("}");
        }

        public static void Print(StreamWriterLevel c, OrderedDictionary<string, CLocalVariable> vars)
        {
            foreach (CLocalVariable v in vars.Values)
            {
                c.P(1);
                if (v.staticDeclaration)
                    c.Write("static ");

                c.Write("{0} {1}", v.type, v.varName);

                if (v.arrayLen > 0)
                    c.Write("[{0}]",v.arrayLen);

                if (v.initVal != "")
                    c.Write(" = {0}", v.initVal);
                c.WriteLine(";");

                //if (v.arrayLen == 0)
                //{
                //    c.WriteLine("{0} {1} = {2};", v.type, v.varName, v.initVal);
                //}
                //else
                //{
                //    c.WriteLine("{0} {1}[{2}];", v.type, v.varName, v.arrayLen);
                //}

            }
            if (vars.Count > 0)
                c.WriteLine();
        }

        public static void PrintCIsConstraintValid(Asn1Type pThis, PEREffectiveConstraint cns, StreamWriterLevel c, string errorCode, string typeName, string varName, int lev, int arrayDepth)
        {
            string varName2 = varName;
            if (!varName.Contains("->"))
                varName2 = "*" + varName;

            if (pThis.m_constraints.Count > 0)
            {
                c.P(lev); c.Write("if ( !(");
                for (int i = 0; i < pThis.m_constraints.Count; i++)
                {
                    string ret = ((ISCConstraint)pThis.m_constraints[i]).PrintCIsConstraintValid(varName2, lev);
                    c.Write(ret);
                    if (i != pThis.m_constraints.Count - 1)
                        c.Write(" && ");
                }
                c.WriteLine(") ) {");
                c.P(lev + 1);
                c.WriteLine("*pErrCode = ERR_{0};", C.ID(errorCode));
                c.P(lev + 1);
                c.WriteLine("return FALSE;");
                c.P(lev);
                c.WriteLine("}");
            }
        }

        public static void dump(string fileName, string outFileName, bool ignoreExtraBytes, bool handleExtraBytesAsDNA)
        {
            using (MemoryStream f = new MemoryStream(File.ReadAllBytes(fileName), false))
            using (StreamWriterLevel w = new StreamWriterLevel(outFileName))
            {

                do
                {
                    BERNode root = BERNode.Create(f);
                    root.dump(w, 0);
                } while (!ignoreExtraBytes && handleExtraBytesAsDNA && f.Length>f.Position);

                if (!ignoreExtraBytes && !handleExtraBytesAsDNA && f.Position < f.Length)
                {
                    w.WriteLine("File contains {0} extra bytes at the end", f.Length-f.Position);
                    int rdVal = 0;

                    int col = 0;
                    while ((rdVal = f.ReadByte()) != -1)
                    {
                        col++;
                        if (col % 80 == 0)
                            w.WriteLine();
                        byte b = (byte)rdVal;
                        w.Write(b.ToString("X2"));
                    }

                }
            }
        }

        public void PrintCDecode(PEREffectiveConstraint cns, StreamWriterLevel c, string varName, int lev)
        {
            long min = minItems(cns);
            long max = maxItems(cns);
            string i = "i" + (CLocalVariable.GetArrayIndex(varName) + 1);
            string length = "length" + (CLocalVariable.GetArrayIndex(varName) + 1);
            string curBlockSize = "curBlockSize" + (CLocalVariable.GetArrayIndex(varName) + 1);
            string nCount = "nCount" + (CLocalVariable.GetArrayIndex(varName) + 1);
            string prefix = "";
            bool topLevel = !varName.Contains("->");
            if (topLevel)
                prefix = varName + "->";
            else
                prefix = varName + ".";

            if (max < 0x10000)
            {
                if (min != max)
                {
                    c.P(lev);
                    c.WriteLine("if (!BitStream_DecodeConstraintWholeNumber(pBitStrm, &nCount, {0}, {1})) {{", min, max);
                    c.P(lev + 1);
                    c.WriteLine("*pErrCode = ERR_INSUFFICIENT_DATA;");
                    c.P(lev + 1);
                    c.WriteLine("return FALSE;");
                    c.P(lev);
                    c.WriteLine("}");
                    c.P(lev);
                    c.WriteLine("{0}nCount = (long)nCount;", prefix);

                }
                else
                {
                    c.P(lev);
                    c.WriteLine("{0}nCount = {1};", prefix, max);
                }

                c.P(lev);
                c.WriteLine("if (!BitStream_ReadBits(pBitStrm, {0}arr, {0}nCount)) {{", prefix);
                c.P(lev + 1);
                c.WriteLine("*pErrCode = ERR_INSUFFICIENT_DATA;");
                c.P(lev + 1);
                c.WriteLine("return FALSE;");
                c.P(lev);
                c.WriteLine("}");
            }
            else
            {
                PrintCDecodeFragmentation(cns, c, varName, lev,
                        "arr", max, prefix, length, curBlockSize, nCount);
            }
        }

        //Default implementation of PrintHtml for all types
        public static void PrintHtml(Asn1Type pThis, PEREffectiveConstraint cns, StreamWriterLevel o, int lev, List<string> comment, TypeAssigment tas, List<IConstraint> additonalConstraints)
        {
            o.WriteLine("<a name=\"{0}\"></a>", "ICD_" + tas.m_name.Replace("-", "_"));
            o.WriteLine("<table border=\"0\" width=\"100%\" >");
            o.WriteLine("<tbody>");

            o.WriteLine("<tr  bgcolor=\"{0}\">", (tas.m_createdThroughTabulization ? "#379CEE" : "#FF8f00"));
            o.WriteLine("<td height=\"35\" colspan=\"2\"  >");
            o.WriteLine("<font face=\"Verdana\" color=\"#FFFFFF\" size=\"4\">{0}</font><font face=\"Verdana\" color=\"#FFFFFF\" size=\"2\">({1}) </font>", tas.m_name, pThis.Name);
            o.WriteLine("<font face=\"Verdana\" color=\"#FFFFFF\" size=\"2\"><a href=\"#{0}\">ASN.1</a></font>", "ASN1_" + tas.m_name.Replace("-", "_"));
            o.WriteLine("</td>");

            o.WriteLine("<td height=\"35\" align=\"center\">");
            o.WriteLine("    <font face=\"Verdana\" color=\"#FFFFFF\" size=\"2\">min = {0} bytes</font>", (pThis.MinBytesInPER == -1 ? "&#8734" : pThis.MinBytesInPER.ToString()));
            o.WriteLine("</td>");

            o.WriteLine("<td height=\"35\" align=\"center\">");
            o.WriteLine("    <font face=\"Verdana\" color=\"#FFFFFF\" size=\"2\">max = {0} bytes{1}</font>", (pThis.MaxBytesInPER == -1 ? "&#8734" : pThis.MaxBytesInPER.ToString()), pThis.MaxBitsInPER_Explained);
            o.WriteLine("</td>");
            o.WriteLine("</tr>");

            IInternalContentsInHtml pICIH = pThis as IInternalContentsInHtml;
            string tmp = string.Empty;
            if (pICIH != null)
                tmp = pICIH.InternalContentsInHtml(additonalConstraints);
            if (comment.Count > 0 || tmp.Length > 0)
            {
                o.WriteLine("<tr class=\"CommentRow\">");
                o.WriteLine("<td class=\"comment2\" colspan=\"4\">" + o.BR(comment) + tmp + "</td>");
                o.WriteLine("</tr>");
            }

            o.WriteLine("<tr class=\"headerRow\">");
            o.WriteLine("<td class=\"hrconstraint2\" colspan=\"2\">Constraints</td>");
            o.WriteLine("<td class=\"hrMin2\">Min Length (bits)</td>");
            o.WriteLine("<td class=\"hrMax2\">Max Length (bits)</td>");
            o.WriteLine("</tr>");

            o.WriteLine("<tr class=\"OddRow\">");
            o.WriteLine("    <td class=\"constraint\" colspan=\"2\">{0}</td>", o.Constraint(pThis.Constraints + BaseConstraint.AsString(additonalConstraints)));
            o.WriteLine("    <td class=\"min\" >{0}</td>", pThis.MinBitsInPER);
            o.WriteLine("    <td class=\"max\" >{0}{1}</td>", pThis.MaxBitsInPER, pThis.MaxBitsInPER_Explained);
            o.WriteLine("</tr>");

            o.WriteLine("</tbody>");
            o.WriteLine("</table>");
        }

        public void printCode(StreamWriterLevel csFile)
        {
            csFile.WriteLine();

            foreach (ImportedModule im in m_imports)
                csFile.WriteLine("using {0};",C.ID(im.m_moduleID));
            csFile.WriteLine("namespace {0}", NameSpace);
            csFile.WriteLine("{");
            csFile.WriteLine();
            foreach (TypeAssigment tas in m_typeAssigments.Values)
            {
                ICSharpType csType = tas.m_type as ICSharpType;
                csType.DeclareType(csFile, C.ID(tas.m_name), 1);
                csFile.WriteLine();
            }

            csFile.WriteLine("}");
        }

        public void PrintCDecode(PEREffectiveConstraint cns, StreamWriterLevel c, string varName, int lev)
        {
            string varName2 = varName;
            if (!varName.Contains("->"))
                varName2 += "->";
            else
                varName2 += ".";

            int largestIndex = -1;
            foreach (string v in m_children.Keys)
            {
                if (m_children[v].m_extended)
                    continue;
                largestIndex++;
            }

            c.P(lev);
            c.WriteLine("if (!BitStream_DecodeConstraintWholeNumber(pBitStrm, &nChoiceIndex, {0}, {1})) {{", 0, largestIndex);
            c.P(lev + 1);
            c.WriteLine("*pErrCode = ERR_INSUFFICIENT_DATA;");
            c.P(lev + 1);
            c.WriteLine("return FALSE;");
            c.P(lev);
            c.WriteLine("}");
            c.P(lev);
            c.WriteLine("switch(nChoiceIndex)");
            c.P(lev); c.WriteLine("{");
            int choiceIndex = 0;
            foreach (ChoiceChild ch in m_children.Values)
            {
                c.P(lev); c.WriteLine("case {0}:", choiceIndex);
                ((ISCCType)ch.m_type).PrintCDecode(ch.m_type.PEREffectiveConstraint, c,
                    varName2 + "u." + C.ID(ch.m_childVarName), lev + 1);

                c.P(lev + 1);
                c.WriteLine("{0}kind = {1};", varName2, ch.CID);
                c.P(lev + 1);
                c.WriteLine("break;");
                choiceIndex++;
            }
            c.P(lev); c.WriteLine("}");
        }

        public static void PrintCInitialize(ArrayType pThis, PEREffectiveConstraint cns,
            Asn1Value defauleVal, StreamWriterLevel c, string typeName, string varName, int lev, int arrayDepth)
        {
            long min = pThis.minItems(cns);
            long max = pThis.maxItems(cns);
            string i = "i" + arrayDepth.ToString();
            string prefix = "";
            bool topLevel = !varName.Contains("->");
            if (topLevel)
                prefix = varName + "->";
            else
            {
                prefix = varName + ".";
            }

            ArrayValue arVal = defauleVal as ArrayValue;
            if (arVal == null)
            {
                c.P(lev);
                c.WriteLine("{0}nCount = 0;", prefix);

                c.P(lev); c.WriteLine("for({0}=0;{0}<{1};{0}++)", i, pThis.maxItems(cns));
                c.P(lev); c.WriteLine("{");
                ((ISCCType)pThis.m_type).PrintCInitialize(pThis.m_type.PEREffectiveConstraint, pThis.m_type.GetOneValidValue(), c,
                    typeName + "_arr", prefix + "arr[" + i + "]", lev + 1, arrayDepth + 1);
                c.P(lev); c.WriteLine("}");
            }
            else
            {
                c.P(lev);
                c.WriteLine("{0}nCount = {1};", prefix, arVal.m_children.Count);
                for (int k = 0; k < arVal.m_children.Count; k++)
                {
                    c.P(lev); c.WriteLine("{");
                    ((ISCCType)pThis.m_type).PrintCInitialize(pThis.m_type.PEREffectiveConstraint, arVal.m_children[k], c,
                        typeName + "_arr", prefix + "arr[" + k.ToString() + "]", lev + 1, arrayDepth + 1);
                    c.P(lev); c.WriteLine("}");
                }
            }
        }

        public void PrintHtml(StreamWriterLevel wr, int p)
        {
            wr.WriteLine("<div style=\"width: 100%\">");
            wr.WriteLine(string.Format("<h2 >Module : {0}</h2>", m_moduleID));
            wr.WriteLine("<font face=\"Courier\" color=\"DimGray\"><pre>");
            wr.WriteLine(wr.BR(m_comments));
            wr.WriteLine("</pre></font>");

            List<TypeAssigment> topLevelPDUs = GetTopLevelTypes();

            if (!DefaultBackend.displayTypesAsAppearInAsn1Grammar)
            {
                foreach (ICDTypeAssigment tas in topLevelPDUs)
                    tas.PrintHtml(wr, p + 1);
            }

            foreach (ICDTypeAssigment tas in m_typeAssigments.Values)
                if (!topLevelPDUs.Contains(tas))
                {
                    tas.PrintHtml(wr, p + 1);
                }

            wr.WriteLine("</div>");
        }

 public void PrintHtml(PEREffectiveConstraint cns, StreamWriterLevel o, int lev, List<string> comment, TypeAssigment tas, List<IConstraint> additonalConstraints)
 {
     ICDBType.PrintHtml(this, cns, o, lev, comment, tas, additonalConstraints);
 }

 public void PrintCEncode(PEREffectiveConstraint cns, StreamWriterLevel c, string errorCode, string varName, int lev)
 {
     SCCStringBase.PrintCEncode(this, cns, c, errorCode, varName, lev);
 }

 public void PrintHTypeDeclaration(PEREffectiveConstraint cns, StreamWriterLevel h, string typeName, string varName, int lev)
 {
     SCCStringBase.PrintHTypeDeclaration(this, cns, h, typeName, varName, lev);
 }

        private void PrintUtilityDefines(StreamWriterLevel h)
        {
            foreach (Module m in m_modules)
                foreach (SCCTypeAssigment t in m.m_typeAssigments.Values)
                {
                    string uniqueID = DefaultBackend.Instance.TypePrefix + DefaultBackend.Instance.GetUniqueID(C.ID(t.m_name));

                    foreach (EnumeratedType en in t.m_type.GetMySelfAndAnyChildren<EnumeratedType>())
                    {
                        foreach (EnumeratedType.Item item in en.m_enumValues.Values)
                        {
                            if (t.m_type != en)
                                h.WriteLine("#define\tENUM_{0}\t{1}::{0}", item.CID, uniqueID);
                            else
                                h.WriteLine("#define\tENUM_{0}\t{0}", item.CID);
                        }
                    }

                    foreach (ChoiceType ch in t.m_type.GetMySelfAndAnyChildren<ChoiceType>())
                    {
                        foreach (ChoiceChild item in ch.m_children.Values)
                        {
                            h.WriteLine("#define\tCHOICE_{0}\t{1}::{0}", item.CID, uniqueID);
                        }
                    }
                }
        }

 public void PrintCIsConstraintValid(PEREffectiveConstraint cns, StreamWriterLevel c, string errorCode, string typeName, string varName, int lev, int arrayDepth)
 {
     CSSType.PrintCIsConstraintValid(this, cns, c, errorCode, typeName, varName, lev, arrayDepth);
 }