private void khs2xml(AxMap pMap, ref XmlTextWriter wr)
{
wr.WriteStartElement("KyHieus");
wr.WriteAttributeString("CX", pMap.CenterX.ToString("#.0000"));
wr.WriteAttributeString("CY", pMap.CenterY.ToString("#.0000"));
wr.WriteAttributeString("Zoom", pMap.Zoom.ToString());
checked
{
try
{
IEnumerator enumerator = this.List.GetEnumerator();
while (enumerator.MoveNext())
{
CSymbol mKH = (CSymbol)enumerator.Current;
wr.WriteStartElement("KyHieu");
bool flag = mKH.Description.Length > 0;
if (flag)
{
wr.WriteAttributeString("Desc", mKH.Description);
}
flag = mKH.Blinking;
if (flag)
{
wr.WriteAttributeString("Blink", mKH.Blinking.ToString());
}
wr.WriteAttributeString("Zoom", mKH.Zoom.ToString());
wr.WriteAttributeString("MWi", mKH.MWidth.ToString());
wr.WriteAttributeString("GocX", mKH.GocX.ToString("#.0000"));
wr.WriteAttributeString("GocY", mKH.GocY.ToString("#.0000"));
try
{
IEnumerator enumerator2 = mKH.GObjs.GetEnumerator();
while (enumerator2.MoveNext())
{
GraphicObject mPart = (GraphicObject)enumerator2.Current;
wr.WriteStartElement("Part");
OBJECTTYPE mType = mPart.GetObjType();
wr.WriteAttributeString("Type", mType.ToString());
flag = (mType == OBJECTTYPE.Text);
if (flag)
{
TextGraphic mTextObj = (TextGraphic)mPart;
wr.WriteAttributeString("Text", mTextObj.Text);
wr.WriteAttributeString("FName", mTextObj.Font.Name);
wr.WriteAttributeString("FSize", mTextObj.Font.Size.ToString());
wr.WriteAttributeString("FStyle", mTextObj.Font.Style.ToString());
wr.WriteAttributeString("FColor", Conversions.ToString(mTextObj.Color.ToArgb()));
wr.WriteStartElement("Pos");
wr.WriteAttributeString("X", mTextObj.X.ToString());
wr.WriteAttributeString("Y", mTextObj.Y.ToString());
wr.WriteAttributeString("A", mTextObj.Rotation.ToString());
wr.WriteEndElement();
}
else
{
flag = (mType == OBJECTTYPE.Table);
if (flag)
{
TableGraphic mTableObj = (TableGraphic)mPart;
wr.WriteStartElement("TBL");
wr.WriteAttributeString("X", mTableObj.X.ToString());
wr.WriteAttributeString("Y", mTableObj.Y.ToString());
wr.WriteAttributeString("W", mTableObj.Width.ToString());
wr.WriteAttributeString("H", mTableObj.Height.ToString());
wr.WriteAttributeString("A", mTableObj.Rotation.ToString());
wr.WriteAttributeString("Cols", mTableObj.ColsNo.ToString());
wr.WriteAttributeString("Rows", mTableObj.RowsNo.ToString());
wr.WriteAttributeString("BColor", Conversions.ToString(mTableObj.BorderColor.ToArgb()));
wr.WriteAttributeString("BWidth", mTableObj.BorderWidth.ToString());
wr.WriteAttributeString("LColor", Conversions.ToString(mTableObj.LineColor.ToArgb()));
wr.WriteAttributeString("LWidth", mTableObj.LineWidth.ToString());
wr.WriteAttributeString("FiColor", Conversions.ToString(mTableObj.FiColor.ToArgb()));
string str = Conversions.ToString(mTableObj.AWidth[0]);
int arg_47A_0 = 1;
int num = mTableObj.ColsNo - 1;
int i = arg_47A_0;
while (true)
{
int arg_4A4_0 = i;
int num2 = num;
if (arg_4A4_0 > num2)
{
break;
}
str = str + "|" + Conversions.ToString(mTableObj.AWidth[i]);
i++;
}
wr.WriteAttributeString("AWS", str);
str = Conversions.ToString(mTableObj.AHeight[0]);
int arg_4CF_0 = 1;
int num3 = mTableObj.RowsNo - 1;
i = arg_4CF_0;
while (true)
{
int arg_4F9_0 = i;
int num2 = num3;
if (arg_4F9_0 > num2)
{
break;
}
str = str + "|" + Conversions.ToString(mTableObj.AHeight[i]);
i++;
}
wr.WriteAttributeString("AHS", str);
i = 0;
try
{
IEnumerator enumerator3 = mTableObj.Cells.GetEnumerator();
while (enumerator3.MoveNext())
{
CCell mCell = (CCell)enumerator3.Current;
i++;
wr.WriteStartElement("Cell");
wr.WriteAttributeString("iR", mCell.iRow.ToString());
wr.WriteAttributeString("iC", mCell.iCol.ToString());
wr.WriteAttributeString("RNo", mCell.RowsNo.ToString());
wr.WriteAttributeString("CNo", mCell.ColsNo.ToString());
wr.WriteAttributeString("Text", mCell.Text);
wr.WriteAttributeString("FName", mCell.Font.Name);
wr.WriteAttributeString("FSize", mCell.Font.Size.ToString());
wr.WriteAttributeString("FStyle", mCell.Font.Style.ToString());
wr.WriteAttributeString("Color", Conversions.ToString(mCell.Color.ToArgb()));
wr.WriteElementString("i", i.ToString());
wr.WriteEndElement();
}
}
finally
{
IEnumerator enumerator3;
flag = (enumerator3 is IDisposable);
if (flag)
{
(enumerator3 as IDisposable).Dispose();
}
}
wr.WriteEndElement();
}
else
{
flag = (mType == OBJECTTYPE.EmbeddedImage);
if (flag)
{
EmbeddedImageGraphic mImageObj = (EmbeddedImageGraphic)mPart;
wr.WriteAttributeString("ITYPE", mImageObj.ImageType);
wr.WriteAttributeString("IMAGEW", mImageObj.Width.ToString());
wr.WriteAttributeString("IMAGEH", mImageObj.Height.ToString());
string strImage = "";
string imageType = mImageObj.ImageType;
if (Operators.CompareString(imageType, "wmf", false) == 0 || Operators.CompareString(imageType, "emf", false) == 0)
{
goto IL_74D;
}
if (Operators.CompareString(imageType, "kro", false) == 0)
{
goto IL_74D;
}
bool arg_74E_0 = false;
IL_74E:
flag = arg_74E_0;
if (flag)
{
try
{
object mFileName = "tmp2.kro";
Image mMetaFile = mImageObj.Image;
mMetaFile.Save(Conversions.ToString(mFileName));
byte[] arrImageByte = this.GetarrImage(Conversions.ToString(mFileName));
strImage = Convert.ToBase64String(arrImageByte);
}
catch (Exception expr_78D)
{
ProjectData.SetProjectError(expr_78D);
Exception ex = expr_78D;
Interaction.MsgBox("kro sai: " + ex.Message, MsgBoxStyle.OkOnly, null);
ProjectData.ClearProjectError();
}
}
else
{
MemoryStream memStream = new MemoryStream();
mImageObj.Image.Save(memStream, ImageFormat.Bmp);
strImage = Convert.ToBase64String(memStream.ToArray());
}
wr.WriteAttributeString("IMAGE", strImage);
wr.WriteStartElement("Pos");
wr.WriteAttributeString("X", mImageObj.X.ToString());
wr.WriteAttributeString("Y", mImageObj.Y.ToString());
wr.WriteAttributeString("A", mImageObj.Rotation.ToString());
wr.WriteEndElement();
goto IL_CDF;
IL_74D:
arg_74E_0 = true;
goto IL_74E;
}
ShapeGraphic mShapeObj = (ShapeGraphic)mPart;
wr.WriteAttributeString("Color", Conversions.ToString(mShapeObj.LineColor.ToArgb()));
wr.WriteAttributeString("Width", mShapeObj.LineWidth.ToString());
flag = (mShapeObj.LineStyle > 0);
if (flag)
{
wr.WriteAttributeString("Style", mShapeObj.LineStyle.ToString());
wr.WriteAttributeString("SWidth", mShapeObj.StyleWidth.ToString());
}
flag = (mShapeObj.Line2Width > 0f);
if (flag)
{
wr.WriteAttributeString("Color2", Conversions.ToString(mShapeObj.Line2Color.ToArgb()));
wr.WriteAttributeString("Width2", mShapeObj.Line2Width.ToString());
}
flag = (mShapeObj.DValues.Length > 6);
if (flag)
{
wr.WriteAttributeString("DV", mShapeObj.DValues);
}
flag = mShapeObj.Fill;
if (flag)
{
wr.WriteAttributeString("Fill", mShapeObj.Fill.ToString());
wr.WriteAttributeString("FColor", Conversions.ToString(mShapeObj.FillColor.ToArgb()));
wr.WriteAttributeString("HColor", Conversions.ToString(mShapeObj.HatchColor.ToArgb()));
wr.WriteAttributeString("HStyle", mShapeObj.HatchStyle.ToString());
}
flag = (mType == OBJECTTYPE.Ellipse);
if (flag)
{
EllipseGraphic mEllipseObj = (EllipseGraphic)mShapeObj;
wr.WriteStartElement("Rect");
wr.WriteAttributeString("X", mEllipseObj.X.ToString());
wr.WriteAttributeString("Y", mEllipseObj.Y.ToString());
wr.WriteAttributeString("W", mEllipseObj.Width.ToString());
wr.WriteAttributeString("H", mEllipseObj.Height.ToString());
wr.WriteAttributeString("A", mEllipseObj.Rotation.ToString());
wr.WriteEndElement();
}
else
{
flag = (mType == OBJECTTYPE.Pie);
if (flag)
{
PieGraphic mPieObj = (PieGraphic)mShapeObj;
wr.WriteStartElement("Pie");
wr.WriteAttributeString("X", mPieObj.X.ToString());
wr.WriteAttributeString("Y", mPieObj.Y.ToString());
wr.WriteAttributeString("W", mPieObj.Width.ToString());
wr.WriteAttributeString("H", mPieObj.Height.ToString());
wr.WriteAttributeString("ST", mPieObj.StartAngle.ToString());
wr.WriteAttributeString("SW", mPieObj.SweepAngle.ToString());
flag = mPieObj.IsArc;
if (flag)
{
wr.WriteAttributeString("ARC", mPieObj.IsArc.ToString());
}
wr.WriteAttributeString("A", mPieObj.Rotation.ToString());
wr.WriteEndElement();
}
else
{
int i = 0;
NodesShapeGraphic mNodesShapeObj = (NodesShapeGraphic)mShapeObj;
try
{
IEnumerator enumerator4 = mNodesShapeObj.Nodes.GetEnumerator();
while (enumerator4.MoveNext())
{
CNODE mNode = (CNODE)enumerator4.Current;
i++;
wr.WriteStartElement("Node");
wr.WriteAttributeString("X", mNode.Pt.X.ToString());
wr.WriteAttributeString("Y", mNode.Pt.Y.ToString());
flag = mNode.IsControl;
if (flag)
{
wr.WriteAttributeString("Type", mNode.IsControl.ToString());
}
wr.WriteElementString("i", i.ToString());
wr.WriteEndElement();
}
}
finally
{
IEnumerator enumerator4;
flag = (enumerator4 is IDisposable);
if (flag)
{
(enumerator4 as IDisposable).Dispose();
}
}
}
}
}
}
IL_CDF:
wr.WriteEndElement();
}
}
finally
{
IEnumerator enumerator2;
flag = (enumerator2 is IDisposable);
if (flag)
{
(enumerator2 as IDisposable).Dispose();
}
}
wr.WriteEndElement();
}
}
finally
{
IEnumerator enumerator;
bool flag = enumerator is IDisposable;
if (flag)
{
(enumerator as IDisposable).Dispose();
}
}
wr.WriteEndElement();
}
}
public void SendBack(CSymbol aKH)
{
this.List.Remove(aKH);
this.List.Insert(0, aKH);
}
public void SendFront(CSymbol aKH)
{
this.List.Remove(aKH);
this.List.Add(aKH);
}
public Production m_prod; // current production being parsed
internal void DoFirst()
{
// Rule 1: terminals only
Production p;
foreach (CSymbol v in m_symbols.symbols.Values)
{
if (v.m_symtype == CSymbol.SymType.unknown)
{
v.m_symtype = CSymbol.SymType.terminal;
}
if (v.IsTerminal())
{
v.m_first.CheckIn(v);
if (!Find(v))
{
erh.Error(new CSToolsException(31, "Lexer script should define symbol " + v.yytext));
}
}
}
foreach (CSymbol s in m_symbols.literals.Values)
{
s.m_first.CheckIn(s);
}
m_symbols.EOFSymbol.m_first.CheckIn(m_symbols.EOFSymbol);
// Rule 2: Nonterminals with the rhs consisting only of actions
int j, k;
for (k = 1; k < prods.Count; k++)
{
p = (Production)prods[k];
if (p.m_actionsOnly)
{
p.m_lhs.m_first.CheckIn(m_symbols.EmptySequence);
}
}
// Rule 3: The real work begins
bool donesome = true;
while (donesome)
{
donesome = false;
for (k = 1; k < prods.Count; k++)
{
p = (Production)prods[k];
int n = p.m_rhs.Count;
for (j = 0; j < n; j++)
{
CSymbol t = (CSymbol)p.m_rhs[j];
if (t.IsAction())
{
donesome |= t.m_first.CheckIn(m_symbols.EmptySequence);
}
int pos = 0;
foreach (CSymbol a in t.m_first.Keys)
{
if ((a != m_symbols.EmptySequence || pos++ == t.m_first.Count - 1))
{
donesome |= p.m_lhs.m_first.CheckIn(a);
}
}
if (!t.m_first.Contains(m_symbols.EmptySequence))
{
break;
}
}
}
}
}
private Type DefineType(CSymbol CSymbol)
{
return(DefineType(CSymbol.Name, CSymbol.CType));
}
public bool Contains(CSymbol value)
{
return(this.List.Contains(value));
}
void _Create()
{
ptokens tks = new ptokens(erh);
m_outname = "syntax";
tks.m_sgen = this;
m_lexer = tks;
m_symbols.erh = erh;
m_symbols.ClassInit(this);
m_outname = "syntax";
m_outFile.WriteLine("using System;using Tools;");
Production special = new Production(this, m_symbols.Special);
m_lexer.yytext = "error";
CSymbol e = (new CSymbol(this)).Resolve();
e.m_symtype = CSymbol.SymType.nonterminal;
e.m_defined = true;
// 1: INPUT
// top-down parsing of script
m_lexer.Start(m_inFile);
m_tok = (TOKEN)m_lexer.Next();
//Console.WriteLine("Token <{0}> {1}",m_tok.yytext,m_tok.GetType().Name);
while (m_tok != null)
{
ParseProduction();
}
// that's the end of the script
if (!m_parserseen)
{
Error(30, 0, "no parser directive detected - possibly incorrect text encoding?");
}
m_outFile.WriteLine(m_actions); // output the action function
m_outFile.WriteLine("} return null; }");
special.AddToRhs(m_symbols.m_startSymbol);
special.AddToRhs(m_symbols.EOFSymbol);
// 2: PROCESSING
Console.WriteLine("First");
DoFirst();
Console.WriteLine("Follow");
DoFollow();
Console.WriteLine("Parse Table");
ParseState start = new ParseState(this, null);
m_symbols.m_states[0] = start;
start.MaybeAdd(new ProdItem(special, 0));
start.Closure();
start.AddEntries();
Transition tfinal = (Transition)start.m_transitions[m_symbols.m_startSymbol.yytext];
ParserShift pe = tfinal.m_next;
m_symbols.m_accept = pe.m_next;
if (m_symbols.m_accept == null)
{
m_symbols.erh.Error(new CSToolsFatalException(43, 0, 0, "", "No accept state. ParserGenerator cannot continue."));
}
// 2A: Reduce States for the LR(0) parser
foreach (ParseState ps in m_symbols.m_states.Values)
{
ps.ReduceStates();
}
/* if (m_showParser)
* {
* foreach (ParseState ps in m_symbols.m_states.Values)
* {
* ps.Print0();
* if (ps==m_symbols.m_accept)
* Console.WriteLine(" EOF accept");
* }
* } */
// 3: Compute Look-ahead sets
if (m_lalrParser)
{
m_symbols.Transitions(new Builder(Transition.BuildDR));
/* if (m_showParser)
* m_symbols.PrintTransitions(new Func(Transition.DR),"DR"); */
m_symbols.Transitions(new Builder(Transition.BuildReads));
new Digraph(this,
new Relation(Transition.reads),
new Func(Transition.DR),
new Func(Transition.Read),
new AddToFunc(Transition.AddToRead)).Compute();
// detect cycles in Read TBD
/* if (m_showParser)
* m_symbols.PrintTransitions(new Func(Transition.Read),"Read"); */
m_symbols.Transitions(new Builder(Transition.BuildIncludes));
m_symbols.Transitions(new Builder(Transition.BuildLookback));
new Digraph(this,
new Relation(Transition.includes),
new Func(Transition.Read),
new Func(Transition.Follow),
new AddToFunc(Transition.AddToFollow)).Compute();
// detect cycles for which Read is non empty TBD
/* if (m_showParser)
* m_symbols.PrintTransitions(new Func(Transition.Follow),"Follow"); */
m_symbols.Transitions(new Builder(Transition.BuildLA));
}
// 5: OUTPUT
// output the run-time ParsingInfo table
Console.WriteLine("Building parse table");
m_symbols.Transitions(new Builder(Transition.BuildParseTable));
foreach (CSymbol v in m_symbols.symbols.Values)
{
if (v.m_symtype != CSymbol.SymType.nodesymbol)
{
continue;
}
ParsingInfo pi = new ParsingInfo(v.yytext);
CSymbol r = v;
while (r.m_symtype == CSymbol.SymType.nodesymbol)
{
r = r.m_refSymbol;
}
if (m_symbols.symbolInfo[v.yytext] != null)
{
m_symbols.erh.Error(new CSToolsException(45, "Bad %node/%symbol hierarchy"));
}
pi.m_parsetable = m_symbols.GetSymbolInfo(r.yytext).m_parsetable;
m_symbols.symbolInfo[v.yytext] = pi;
}
Console.WriteLine("Writing the output file");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public yy" + m_outname + "():base() { arr = new int[] { ");
m_symbols.Emit(m_outFile);
// output the class factories
CSymbol s;
Console.WriteLine("Class factories");
IDictionaryEnumerator de = m_symbols.symbols.GetEnumerator();
for (int pos = 0; pos < m_symbols.symbols.Count; pos++)
{
de.MoveNext();
string str = (string)de.Key;
s = (CSymbol)de.Value;
if ((s == null) || // might happen because of error recovery
(s.m_symtype != CSymbol.SymType.nonterminal && s.m_symtype != CSymbol.SymType.nodesymbol))
{
continue;
}
//Console.WriteLine("{0} {1}",s.yytext,s.m_symtype);
m_outFile.WriteLine("new Sfactory(this,\"{0}\",new SCreator({0}_factory));", str);
}
m_outFile.WriteLine("}");
de.Reset();
for (int pos = 0; pos < m_symbols.symbols.Count; pos++)
{
de.MoveNext();
string str = (string)de.Key;
s = (CSymbol)de.Value;
if ((s == null) || // might happen because of error recovery
(s.m_symtype != CSymbol.SymType.nonterminal && s.m_symtype != CSymbol.SymType.nodesymbol))
{
continue;
}
//Console.WriteLine("{0} {1}",s.yytext,s.m_symtype);
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public static object " + str + "_factory(Parser yyp) { return new " + str + "(yyp); }");
}
m_outFile.WriteLine("}");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public class " + m_outname + ": Parser {");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public " + m_outname + "():base(new yy" + m_outname + "(),new " + m_lexerClass + "()) {}");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public " + m_outname + "(Symbols syms):base(syms,new " + m_lexerClass + "()) {}");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public " + m_outname + "(Symbols syms,ErrorHandler erh):base(syms,new " + m_lexerClass + "(erh)) {}");
m_outFile.WriteLine(m_actvars);
m_outFile.WriteLine(" }");
if (m_namespace)
{
m_outFile.WriteLine("}");
}
Console.WriteLine("Done");
if (m_showParser)
{
foreach (ParseState ps in m_symbols.m_states.Values)
{
ps.Print();
if (ps == m_symbols.m_accept)
{
Console.WriteLine(" EOF accept");
}
}
}
}
public override void SimpleAction(ParserSimpleAction a)
{
string str = a.yytext.Substring(1, a.yytext.Length - 1);
if (str == "null")
{
m_lexer.yytext = "Null";
a.m_sym = (new CSymbol(this)).Resolve();
NewConstructor(ref a.m_sym, ", " + m_prod.m_lhs.m_yynum + "){}");
return;
}
if (str.Length == 0)
{
str = m_prod.m_lhs.yytext;
}
CSymbol s = (CSymbol)m_symbols.symbols[str];
if (s == null)
{ // not there: define a new node type
//Console.WriteLine("Symbol {0} needs defining",str);
m_lexer.yytext = str;
s = new CSymbol(this);
m_symbols.symbols[str] = s;
s.m_symtype = CSymbol.SymType.nodesymbol;
s.m_refSymbol = (CSymbol)m_prod.m_lhs;
s.m_emitted = true;
m_outFile.WriteLine("public class " + str + " : " + s.m_refSymbol.yytext + " { ");
m_outFile.WriteLine(" public " + str + "(Parser yyq):base(yyq) { }}");
}
else if (s.m_refSymbol != null) // 4.5c
{
CSymbol t = s; // 4.5d
while (t != null && t != (CSymbol)m_prod.m_lhs)
{
t = t.m_refSymbol;
}
if (t == null)
{
Error(46, m_lexer.m_pch, "Simple action " + s.yytext + " does not match symbol type " + m_prod.m_lhs.yytext); // 4.5d
}
} // 4.5c
else
{
s.m_refSymbol = (CSymbol)m_prod.m_lhs;
}
a.m_sym = s;
int ch;
str = ")";
NextNonWhite(out ch);
if (ch == '(')
{
ch = m_lexer.GetChar();
str = "," + GetBracketedSeq(ref ch, ')').Substring(1);
NextNonWhite(out ch);
}
if (str == ",)") // 4.0d
{
str = ")";
}
string init = "{}";
if (ch == '{')
{
ch = m_lexer.GetChar();
string ts = GetBracketedSeq(ref ch, '}'); // 4.5g
init = "{ " + m_outname + " yyp=(" + m_outname + ")yyq;\n" + ts.Substring(1); // 4.5g 4.5h
NextNonWhite(out ch);
}
init = str + init;
NewConstructor(ref a.m_sym, init);
}
private void LoadSymbols()
{
base.ClearModels();
base.ClearBillboards();
this.m_Symbol3Objs.Clear();
double num;
double num2;
checked
{
num = Convert.ToDouble(decimal.Multiply(new decimal(this.m_TexImage.Width), new decimal(1000L))) / (double)(modSaBan.myGRID_WIDTH - 1) / 1000.0;
num2 = Convert.ToDouble(decimal.Multiply(new decimal(this.m_TexImage.Height), new decimal(1000L))) / (double)(modSaBan.myGRID_HEIGHT - 1) / 1000.0;
Graphics graphics = Graphics.FromImage(this.m_TexImage);
}
try
{
IEnumerator enumerator = myModule.fMain.myBando.drawingSymbols.GetEnumerator();
while (enumerator.MoveNext())
{
CSymbol cSymbol = (CSymbol)enumerator.Current;
PointF surfPosition = modSaBan.GetSurfPosition(cSymbol.GocX, cSymbol.GocY);
float valueX = (float)((double)surfPosition.X / num);
float valueY = (float)((double)(checked (modSaBan.myGRID_HEIGHT - 1)) - (double)surfPosition.Y / num2);
float dHeading = -CTerrain.DegreeToRadian(cSymbol.Heading);
Vector3 pPos = new Vector3(valueX, valueY, -7f);
int num3 = base.GetModelMeshIndex(cSymbol.Description);
if (num3 > -1)
{
base.Load1Model(cSymbol.Description, num3, pPos, dHeading);
}
else
{
num3 = base.GetBillboardMeshIndex(cSymbol.Description);
if (num3 > -1)
{
base.Load1Billboard(cSymbol.Description, num3, pPos, dHeading);
}
else
{
double zoom = cSymbol.Zoom / (double)cSymbol.MWidth * (modSaBan.my3DSoPixelsPer1000m / 1000.0);
CGraphicObjs cGraphicObjs = new CGraphicObjs();
try
{
IEnumerator enumerator2 = cSymbol.GObjs.GetEnumerator();
while (enumerator2.MoveNext())
{
GraphicObject graphicObject = (GraphicObject)enumerator2.Current;
GraphicObject aGObj = graphicObject.Clone();
cGraphicObjs.Add(aGObj);
}
}
finally
{
IEnumerator enumerator2;
if (enumerator2 is IDisposable)
{
(enumerator2 as IDisposable).Dispose();
}
}
CSymbol3 cSymbol2 = new CSymbol3(cSymbol.Description, surfPosition, cGraphicObjs);
cSymbol2.Zoom = zoom;
cSymbol2.Heading = cSymbol.Heading;
this.m_Symbol3Objs.Add(cSymbol2);
}
}
}
}
finally
{
IEnumerator enumerator;
if (enumerator is IDisposable)
{
(enumerator as IDisposable).Dispose();
}
}
}
public VariableDeclaration(PositionInfo PositionInfo, CSymbol Symbol, Expression InitialValue)
: base(PositionInfo, InitialValue)
{
this.Symbol = Symbol;
this.InitialValue = InitialValue;
}
/// <summary>
/// Parses whatever comes until the specified stop symbol is reached.
/// </summary>
void ParseObject(CSequence sequence, CSymbol stop)
{
CSymbol symbol;
while ((symbol = ScanNextToken()) != CSymbol.Eof)
{
if (symbol == stop)
{
return;
}
switch (symbol)
{
case CSymbol.Comment:
// ignore comments
break;
case CSymbol.Integer:
CInteger n = new CInteger();
n.Value = lexer.TokenToInteger;
operands.Add(n);
break;
case CSymbol.Real:
CReal r = new CReal();
r.Value = lexer.TokenToReal;
operands.Add(r);
break;
case CSymbol.String:
case CSymbol.HexString:
case CSymbol.UnicodeString:
case CSymbol.UnicodeHexString:
CString s = new CString();
s.Value = lexer.Token;
operands.Add(s);
break;
case CSymbol.Name:
CName name = new CName();
name.Name = lexer.Token;
operands.Add(name);
break;
case CSymbol.Operator:
COperator op = CreateOperator();
operands.Clear();
sequence.Add(op);
break;
case CSymbol.BeginArray:
CArray array = new CArray();
Debug.Assert(operands.Count == 0, "Array within array...");
ParseObject(array, CSymbol.EndArray);
array.Add(operands);
operands.Clear();
operands.Add((CObject)array);
break;
case CSymbol.EndArray:
throw new ContentReaderException("Unexpected: ']'");
}
}
}
public TypeDeclaration(PositionInfo PositionInfo, CSymbol Symbol)
: base(PositionInfo)
{
this.Symbol = Symbol;
}
/// <summary>
/// Parses whatever comes until the specified stop symbol is reached.
/// </summary>
void ParseObject(CSequence sequence, CSymbol stop)
{
CSymbol symbol;
while ((symbol = ScanNextToken()) != CSymbol.Eof)
{
if (symbol == stop)
return;
switch (symbol)
{
case CSymbol.Comment:
// ignore comments
break;
case CSymbol.Integer:
CInteger n = new CInteger();
n.Value = this.lexer.TokenToInteger;
this.operands.Add(n);
break;
case CSymbol.Real:
CReal r = new CReal();
r.Value = this.lexer.TokenToReal;
this.operands.Add(r);
break;
case CSymbol.String:
case CSymbol.HexString:
case CSymbol.UnicodeString:
case CSymbol.UnicodeHexString:
CString s = new CString();
s.Value = this.lexer.Token;
this.operands.Add(s);
break;
case CSymbol.Name:
CName name = new CName();
name.Name = this.lexer.Token;
this.operands.Add(name);
break;
case CSymbol.Operator:
COperator op = CreateOperator();
this.operands.Clear();
sequence.Add(op);
break;
case CSymbol.BeginArray:
CArray array = new CArray();
Debug.Assert(this.operands.Count == 0, "Array within array...");
ParseObject(array, CSymbol.EndArray);
array.Add(this.operands);
this.operands.Clear();
this.operands.Add((CObject)array);
break;
case CSymbol.EndArray:
throw new ContentReaderException("Unexpected: ']'");
}
}
}
/// <summary>
/// Reads the next symbol that must be the specified one.
/// </summary>
CSymbol ReadSymbol(CSymbol symbol)
{
CSymbol current = this.lexer.ScanNextToken();
if (symbol != current)
throw new ContentReaderException(PSSR.UnexpectedToken(this.lexer.Token));
return current;
}
public void Add(CSymbol aSymbol)
{
this.List.Add(aSymbol);
}
/// <summary>
/// Reads the next symbol that must be the specified one.
/// </summary>
CSymbol ReadSymbol(CSymbol symbol)
{
CSymbol current = _lexer.ScanNextToken();
if (symbol != current)
ContentReaderDiagnostics.ThrowContentReaderException(PSSR.UnexpectedToken(_lexer.Token));
return current;
}
public void Remove(CSymbol aSymbol)
{
this.List.Remove(aSymbol);
}
/// <summary>
/// Parses whatever comes until the specified stop symbol is reached.
/// </summary>
void ParseObject(CSequence sequence, CSymbol stop)
{
CSymbol symbol;
while ((symbol = ScanNextToken()) != CSymbol.Eof)
{
if (symbol == stop)
return;
CString s;
COperator op;
switch (symbol)
{
case CSymbol.Comment:
// ignore comments
break;
case CSymbol.Integer:
CInteger n = new CInteger();
n.Value = _lexer.TokenToInteger;
_operands.Add(n);
break;
case CSymbol.Real:
CReal r = new CReal();
r.Value = _lexer.TokenToReal;
_operands.Add(r);
break;
case CSymbol.String:
case CSymbol.HexString:
case CSymbol.UnicodeString:
case CSymbol.UnicodeHexString:
s = new CString();
s.Value = _lexer.Token;
_operands.Add(s);
break;
case CSymbol.Dictionary:
s = new CString();
s.Value = _lexer.Token;
s.CStringType = CStringType.Dictionary;
_operands.Add(s);
op = CreateOperator(OpCodeName.Dictionary);
//_operands.Clear();
sequence.Add(op);
break;
case CSymbol.Name:
CName name = new CName();
name.Name = _lexer.Token;
_operands.Add(name);
break;
case CSymbol.Operator:
op = CreateOperator();
//_operands.Clear();
sequence.Add(op);
break;
case CSymbol.BeginArray:
CArray array = new CArray();
if (_operands.Count != 0)
ContentReaderDiagnostics.ThrowContentReaderException("Array within array...");
ParseObject(array, CSymbol.EndArray);
array.Add(_operands);
_operands.Clear();
_operands.Add((CObject)array);
break;
case CSymbol.EndArray:
ContentReaderDiagnostics.HandleUnexpectedCharacter(']');
break;
#if DEBUG
default:
Debug.Assert(false);
break;
#endif
}
}
}
public void RhSide(Production p)
{
CSymbol s;
ParserOldAction a = null; // last old action seen
while (m_tok != null)
{
if (m_tok.Matches(";"))
{
break;
}
if (m_tok.Matches("|"))
{
break;
}
if (m_tok.Matches(":"))
{
Advance();
p.m_alias[m_tok.yytext] = p.m_rhs.Count;
Advance();
}
else if (m_tok is PrecReference)
{
if (p.m_rhs.Count == 0)
{
erh.Error(new CSToolsException(21, "%prec cannot be at the start of a right hand side"));
}
PrecReference pr = (PrecReference)m_tok;
CSymbol r = (CSymbol)p.m_rhs[p.m_rhs.Count - 1];
r.m_prec = pr.precref.m_prec;
Advance();
}
else
{
s = (CSymbol)m_tok;
if (s.m_symtype == CSymbol.SymType.oldaction)
{
if (a != null)
{
Error(42, s.pos, "adjacent actions");
}
a = (ParserOldAction)s;
if (a.m_action < 0)
{ // an OldAction that has been converted to a SimpleAction: discard it
s = a.m_sym; // add the SimpleAction instead
s.m_symtype = CSymbol.SymType.simpleaction;
ParserSimpleAction sa = (ParserSimpleAction)s;
}
else // add it to the Actions function
{
m_actions += String.Format("\ncase {0} : {1} break;", a.m_action, a.m_initialisation);
}
a = null;
}
else if (s.m_symtype != CSymbol.SymType.simpleaction)
{
s = ((CSymbol)m_tok).Resolve();
}
p.AddToRhs(s);
Advance();
}
}
Precedence.Check(p);
}
/// <summary>
/// Parses whatever comes until the specified stop symbol is reached.
/// </summary>
void ParseObject(CSequence sequence, CSymbol stop)
{
CSymbol symbol;
while ((symbol = ScanNextToken()) != CSymbol.Eof)
{
if (symbol == stop)
{
return;
}
CString s;
COperator op;
switch (symbol)
{
case CSymbol.Comment:
// ignore comments
break;
case CSymbol.Integer:
CInteger n = new CInteger();
n.Value = _lexer.TokenToInteger;
_operands.Add(n);
break;
case CSymbol.Real:
CReal r = new CReal();
r.Value = _lexer.TokenToReal;
_operands.Add(r);
break;
case CSymbol.String:
case CSymbol.HexString:
case CSymbol.UnicodeString:
case CSymbol.UnicodeHexString:
s = new CString();
s.Value = _lexer.Token;
_operands.Add(s);
break;
case CSymbol.Dictionary:
s = new CString();
s.Value = _lexer.Token;
s.CStringType = CStringType.Dictionary;
_operands.Add(s);
op = CreateOperator(OpCodeName.Dictionary);
//_operands.Clear();
sequence.Add(op);
break;
case CSymbol.Name:
CName name = new CName();
name.Name = _lexer.Token;
_operands.Add(name);
break;
case CSymbol.Operator:
op = CreateOperator();
//_operands.Clear();
sequence.Add(op);
break;
case CSymbol.BeginArray:
CArray array = new CArray();
if (_operands.Count != 0)
{
ContentReaderDiagnostics.ThrowContentReaderException("Array within array...");
}
ParseObject(array, CSymbol.EndArray);
array.Add(_operands);
_operands.Clear();
_operands.Add((CObject)array);
break;
case CSymbol.EndArray:
ContentReaderDiagnostics.HandleUnexpectedCharacter(']');
break;
#if DEBUG
default:
Debug.Assert(false);
break;
#endif
}
}
}
public PrecReference(Lexer lx, TOKEN t) : base(lx)
{
precref = ((CSymbol)t).Resolve();
new SymbolType(((ptokens)lx).m_sgen, t.yytext, true);
}
public void DrawSelectedSymbol(AxMap pMap, Graphics g, CSymbol selectedSymbol, float Scale)
{
GraphicObject selectedObject = selectedSymbol.GObjs[0];
System.Drawing.Point ltPt = default(System.Drawing.Point);
float num = (float)ltPt.X;
float num2 = (float)ltPt.Y;
GraphicObject graphicObject = selectedObject;
double num3 = (double)graphicObject.X;
GraphicObject graphicObject2 = selectedObject;
double num4 = (double)graphicObject2.Y;
pMap.ConvertCoord(ref num, ref num2, ref num3, ref num4, ConversionConstants.miMapToScreen);
graphicObject2.Y = (float)num4;
graphicObject.X = (float)num3;
checked
{
ltPt.Y = (int)Math.Round((double)num2);
ltPt.X = (int)Math.Round((double)num);
GraphicsContainer gCon = g.BeginContainer();
g.ScaleTransform(Scale, Scale, MatrixOrder.Append);
GraphicsContainer gCon2 = g.BeginContainer();
g.PageUnit = GraphicsUnit.Pixel;
bool flag = selectedObject != null;
if (flag)
{
Pen selectionPen = new Pen(Color.FromKnownColor(KnownColor.HotTrack));
selectionPen.DashStyle = DashStyle.Dot;
selectionPen.Width = 1f;
flag = (selectedObject.Rotation != 0f);
if (flag)
{
Matrix myMatrix = g.Transform;
Matrix arg_123_0 = myMatrix;
float arg_123_1 = selectedObject.Rotation;
PointF point = new PointF((float)ltPt.X, (float)ltPt.Y);
arg_123_0.RotateAt(arg_123_1, point, MatrixOrder.Append);
g.Transform = myMatrix;
}
PointF[] mPtfs = new PointF[3];
mPtfs[0].X = selectedObject.X;
mPtfs[0].Y = selectedObject.Y;
int mPtsCount;
unchecked
{
mPtfs[1].X = selectedObject.X + selectedObject.Width;
mPtfs[1].Y = selectedObject.Y + selectedObject.Height;
mPtsCount = mPtfs.GetUpperBound(0);
}
System.Drawing.Point[] mPts = new System.Drawing.Point[mPtsCount + 1];
int arg_1B3_0 = 0;
int num5 = mPtsCount;
int i = arg_1B3_0;
while (true)
{
int arg_281_0 = i;
int num6 = num5;
if (arg_281_0 > num6)
{
break;
}
System.Drawing.Point[] arg_1C3_0 = mPts;
int num7 = i;
num2 = (float)arg_1C3_0[num7].X;
System.Drawing.Point[] arg_1DA_0 = mPts;
int num8 = i;
num = (float)arg_1DA_0[num8].Y;
PointF[] arg_1F1_0 = mPtfs;
int num9 = i;
num4 = (double)arg_1F1_0[num9].X;
PointF[] arg_208_0 = mPtfs;
int num10 = i;
num3 = (double)arg_208_0[num10].Y;
pMap.ConvertCoord(ref num2, ref num, ref num4, ref num3, ConversionConstants.miMapToScreen);
mPtfs[num10].Y = (float)num3;
mPtfs[num9].X = (float)num4;
mPts[num8].Y = (int)Math.Round((double)num);
mPts[num7].X = (int)Math.Round((double)num2);
i++;
}
float mW = (float)Math.Abs(mPts[1].X - mPts[0].X);
float mH = (float)Math.Abs(mPts[1].Y - mPts[0].Y);
float mPtX = (float)Math.Min(mPts[0].X, mPts[1].X);
float mPtY = (float)Math.Min(mPts[0].Y, mPts[1].Y);
System.Drawing.Rectangle rect = new System.Drawing.Rectangle((int)Math.Round((double)mPtX), (int)Math.Round((double)mPtY), (int)Math.Round((double)mW), (int)Math.Round((double)mH));
g.DrawRectangle(selectionPen, rect);
}
g.EndContainer(gCon2);
g.EndContainer(gCon);
}
}
// parsing routines
internal void ParseProduction()
{
TOKEN tok = m_tok;
CSymbol lhs = null;
try
{
lhs = ((CSymbol)m_tok).Resolve();
}
catch (Exception e)
{
erh.Error(new CSToolsFatalException(45, tok, string.Format("Syntax error in Parser script - possibly extra semicolon?", e.Message)));
}
m_tok = lhs;
if (m_tok.IsTerminal())
{
Error(39, m_tok.pos, string.Format("Illegal left hand side <{0}> for production", m_tok.yytext));
}
if (m_symbols.m_startSymbol == null)
{
m_symbols.m_startSymbol = lhs;
}
if (lhs.m_symtype == CSymbol.SymType.unknown)
{
lhs.m_symtype = CSymbol.SymType.nonterminal;
}
if ((!lhs.m_defined) && lhs.m_prods.Count == 0)
{ // lhs not defined in %symbol statement and not previously a lhs
// so declare it as a new symbol
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public class " + lhs.yytext + " : SYMBOL {");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine(@"/// <param name='yyq'></param>");
m_outFile.WriteLine(" public "+ lhs.yytext + "(Parser yyq):base(yyq) { }");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine(" public override string yyname() { return \"" + lhs.yytext + "\"; }}");
}
if (!Find(lhs))
{
new SymbolType(this, lhs.yytext);
}
m_prod = new Production(this, lhs);
m_lexer.yy_begin("rhs");
Advance();
if (!m_tok.Matches(":"))
{
Error(40, m_tok.pos, String.Format("Colon expected for production {0}", lhs.yytext));
}
Advance();
RhSide(m_prod);
while (m_tok != null && m_tok.Matches("|"))
{
Advance();
m_prod = new Production(this, lhs);
RhSide(m_prod);
}
if (m_tok == null || !m_tok.Matches(";"))
{
Error(41, m_lexer.m_pch, "Semicolon expected");
}
Advance();
m_prod = null;
m_lexer.yy_begin("YYINITIAL");
}
public bool CouldStart(CSymbol nonterm)
{
return(false);
}
