private void ExecuteBegin() { Codigo.Add(".method static public void _principal() {"); Codigo.Add(" .entrypoint"); AddCode(); Idents.Push(Ident); }
private void ExecuteEnd() { AddCode(); AddCode("ret"); AddCode("}"); Idents.Pop(); AddCode("}"); }
/// <summary> /// Adds data from the specified <c>ident</c> or <c>rdg</c> element. /// The <see cref="Idents"/> list contains <c>ident</c>'s values with /// their <c>n</c> attribute, eventually followed by the value of the /// <c>n</c> attribute of the parent <c>rdg</c> element. /// This in turn comes from merging an overlapping <c>app</c> element /// into another one, and preserves the original from-to location of /// the overlapping <c>app</c>. /// </summary> /// <param name="identElem">The ident element.</param> /// <exception cref="ArgumentNullException">identElem</exception> public void AddIdent(XElement identElem) { if (identElem == null) { throw new ArgumentNullException(nameof(identElem)); } if (identElem.Name.LocalName != "ident" && identElem.Name.LocalName != "rdg") { return; } string identValue = identElem.Name.LocalName == "rdg" ? $"@{identElem.Attribute("n")?.Value}" : $"{identElem.Value.Trim()}#{identElem.Attribute("n")!.Value}"; if (string.IsNullOrEmpty(identValue) || identValue == "@") { return; } string?rdgLoc = Idents.FirstOrDefault( i => i.StartsWith("@", StringComparison.Ordinal)); if (rdgLoc != null) { if (identValue.StartsWith("@", StringComparison.Ordinal)) { // this should never happen Logger?.LogError("Duplicate rdg@n attribute in idents list"); Idents.Add(identValue); } else { Idents.Insert(Idents.IndexOf(rdgLoc), identValue); } } else { Idents.Add(identValue); } }
public QueryLexerToken NextToken(QueryLexerTokenKind tokContext = QueryLexerTokenKind.UNKNOWN) { if (TokenCache.Kind != QueryLexerTokenKind.UNKNOWN) { QueryLexerToken tok = TokenCache; TokenCache = new QueryLexerToken(); return(tok); } if (ArgI == ArgEnd) { if (!BeginEnumerator.MoveNext()) { return(new QueryLexerToken(QueryLexerTokenKind.END_REACHED)); } else { SetArg(); } } resume: switch (Arg[ArgI]) { case '\0': throw new InvalidOperationException(); case '\'': case '"': case '/': { string pat = String.Empty; char closing = Arg[ArgI]; bool foundClosing = false; for (++ArgI; ArgI != ArgEnd; ++ArgI) { if (Arg[ArgI] == '\\') { if (++ArgI == ArgEnd) { throw new ParseError(ParseError.ParseError_UnexpectedBackslashAtEndOfPattern); } } else if (Arg[ArgI] == closing) { ++ArgI; foundClosing = true; break; } pat += Arg[ArgI]; } if (!foundClosing) { throw new ParseError(String.Format(ParseError.ParseError_ExpectedSmthAtEndOfPattern, closing)); } if (String.IsNullOrEmpty(pat)) { throw new ParseError(ParseError.ParseError_MatchPatternIsEmpty); } return(new QueryLexerToken(QueryLexerTokenKind.TERM, pat)); } } if (MultipleArgs && ConsumeNextArg) { ConsumeNextArg = false; QueryLexerToken tok = new QueryLexerToken(QueryLexerTokenKind.TERM, Arg.Substring(ArgI)); PrevArgI = ArgI; ArgI = ArgEnd; return(tok); } bool consumeNext = false; switch (Arg[ArgI]) { case '\0': throw new InvalidOperationException(); case ' ': case '\t': case '\r': case '\n': if (++ArgI == ArgEnd) { return(NextToken(tokContext)); } goto resume; case '(': ++ArgI; if (tokContext == QueryLexerTokenKind.TOK_EXPR) { ConsumeWhitespace = true; } return(new QueryLexerToken(QueryLexerTokenKind.LPAREN)); case ')': ++ArgI; if (tokContext == QueryLexerTokenKind.TOK_EXPR) { ConsumeWhitespace = false; } return(new QueryLexerToken(QueryLexerTokenKind.RPAREN)); case '&': ++ArgI; return(new QueryLexerToken(QueryLexerTokenKind.TOK_AND)); case '|': ++ArgI; return(new QueryLexerToken(QueryLexerTokenKind.TOK_OR)); case '!': ++ArgI; return(new QueryLexerToken(QueryLexerTokenKind.TOK_NOT)); case '@': ++ArgI; return(new QueryLexerToken(QueryLexerTokenKind.TOK_PAYEE)); case '#': ++ArgI; return(new QueryLexerToken(QueryLexerTokenKind.TOK_CODE)); case '%': ++ArgI; return(new QueryLexerToken(QueryLexerTokenKind.TOK_META)); case '=': ++ArgI; consumeNext = true; return(new QueryLexerToken(QueryLexerTokenKind.TOK_EQ)); default: { if (Arg[ArgI] == '\\') { ++ArgI; consumeNext = true; } string ident = String.Empty; for (; ArgI != ArgEnd; ++ArgI) { switch (Arg[ArgI]) { case '\0': throw new InvalidOperationException(); case ' ': case '\t': case '\n': case '\r': if (!MultipleArgs && !ConsumeWhitespace && !ConsumeNextArg) { goto test_ident; } else { ident += Arg[ArgI]; } break; case ')': if (!consumeNext) // DM - the second part of condition "... && tok_context == token_t::TOK_EXPR)" is redundant since it meets an opposite condition after falling through. See query.cc:166 { goto test_ident; } ident += Arg[ArgI]; break; case '(': case '&': case '|': case '!': case '@': case '#': case '%': case '=': if (!consumeNext && tokContext != QueryLexerTokenKind.TOK_EXPR) { goto test_ident; } ident += Arg[ArgI]; break; default: ident += Arg[ArgI]; break; } } ConsumeWhitespace = false; test_ident: QueryLexerTokenKind kind; if (Idents.TryGetValue(ident, out kind)) { if (kind == QueryLexerTokenKind.TOK_EXPR) { ConsumeNextArg = true; } return(new QueryLexerToken(kind)); } return(new QueryLexerToken(QueryLexerTokenKind.TERM, ident)); } } // Unreachable code... return new QueryLexerToken(QueryLexerTokenKind.UNKNOWN); }
private void ParseRecursively(List <mValue> ValueList, int chunkOffset, int chunkNumber) { for (int i = 0; i < ValueList.Count; i++) { object name; switch (ValueList[i].Attributes) { case mValue.ObjectAttributes.TagBlock: { if ((chunkOffset + ValueList[i].Offset) <= ((int)Map.IO.In.BaseStream.Length)) { break; } continue; } case mValue.ObjectAttributes.TagData: { if ((chunkOffset + ValueList[i].Offset) <= ((int)Map.IO.In.BaseStream.Length)) { goto Label_0224; } continue; } case mValue.ObjectAttributes.TagReference: { if ((chunkOffset + ValueList[i].Offset) <= ((int)Map.IO.In.BaseStream.Length)) { goto Label_03B7; } continue; } case mValue.ObjectAttributes.StringID: { if ((chunkOffset + ValueList[i].Offset) <= ((int)Map.IO.In.BaseStream.Length)) { goto Label_05E5; } continue; } default: { continue; } } Map.IO.In.BaseStream.Position = chunkOffset + ValueList[i].Offset; mTagBlock block = (mTagBlock)ValueList[i]; Structure item = new Structure { Name = block.Name }; if (chunkNumber != -1) { name = item.Name; item.Name = string.Concat(new object[] { name, " [", chunkNumber, "]" }); } item.Size = block.Size; item.Count = Map.IO.In.ReadInt32(); item.Pointer = Map.IO.In.ReadInt32() - Map.Map_Header.mapMagic; if (!(((item.Count <= 0) | (item.Pointer <= 0)) | (item.Count > 0x186a0))) { item.Offset = chunkOffset + block.Offset; Structures.Add(item); for (int j = 0; j < item.Count; j++) { ParseRecursively(block.Values, item.Pointer + (j * item.Size), j); } } continue; Label_0224: Map.IO.In.BaseStream.Position = chunkOffset + ValueList[i].Offset; mTagData data = (mTagData)ValueList[i]; TagData data2 = new TagData { Name = data.Name }; if (chunkNumber != -1) { name = data2.Name; data2.Name = string.Concat(new object[] { name, " [", chunkNumber, "]" }); } data2.Size = Map.IO.In.ReadInt32(); Stream baseStream = Map.IO.In.BaseStream; baseStream.Position += 8L; data2.Pointer = Map.IO.In.ReadInt32() - Map.Map_Header.mapMagic; if (!((data2.Size <= 0) | (data2.Pointer <= 0))) { data2.Offset = chunkOffset + data.Offset; Tag_Data_Blocks.Add(data2); } continue; Label_03B7: Map.IO.In.BaseStream.Position = (chunkOffset + ValueList[i].Offset) + 12; mTagReference reference = (mTagReference)ValueList[i]; Ident ident = new Ident { Name = reference.Name }; if (chunkNumber != -1) { name = ident.Name; ident.Name = string.Concat(new object[] { name, " [", chunkNumber, "]" }); } ident.Offset = chunkOffset + reference.Offset; ident.ID = Map.IO.In.ReadInt32(); int tagIndexByIdent = Map.GetTagIndexByIdent(ident.ID); if (tagIndexByIdent != -1) { ident.TagClass = Map.Index_Items[tagIndexByIdent].Class; } else { ident.TagClass = "Null"; } if (tagIndexByIdent != -1) { int key = Map.Index_Items[tagIndexByIdent].Ident; string str = Map.Index_Items[tagIndexByIdent].Name; if (Map.tagNameList.TagPaths.ContainsKey(key)) { try { str = Map.tagNameList.TagPaths[key]; } catch { } } ident.TagName = str + "." + Map.Index_Items[tagIndexByIdent].Class; } else { ident.TagName = "Null"; } Idents.Add(ident); continue; Label_05E5: Map.IO.In.BaseStream.Position = chunkOffset + ValueList[i].Offset; mStringID gid = (mStringID)ValueList[i]; StringIdentifier identifier = new StringIdentifier { Name = gid.Name }; if (chunkNumber != -1) { name = identifier.Name; identifier.Name = string.Concat(new object[] { name, " [", chunkNumber, "]" }); } identifier.Offset = chunkOffset + gid.Offset; identifier.Identifier = Map.IO.In.ReadInt32(); tagIndexByIdent = Map.String_Table.GetStringItemIndexByID(Map, identifier.Identifier); identifier.StringIndex = tagIndexByIdent; try { identifier.StringName = Map.String_Table.StringItems[tagIndexByIdent].Name; } catch { identifier.StringName = "<<invalid sid>>"; } Strings.Add(identifier); } }
private void ParseRecursively(List <mValue> ValueList, int chunkOffset, int chunkNumber) { //Loop through values for (int i = 0; i < ValueList.Count; i++) { //Determine the value type switch (ValueList[i].Attributes) { case mValue.ObjectAttributes.Reflexive: { //If the offset is rediculous.. if (chunkOffset + ValueList[i].Offset > (int)Map.IO.In.BaseStream.Length) { break; } //Go to the reflexive offset Map.IO.In.BaseStream.Position = chunkOffset + ValueList[i].Offset; //Get the reflexive mReflexive mreflexive = (mReflexive)ValueList[i]; //Initialize our instance of structure Structure structure = new Structure(); //Assign the name structure.Name = mreflexive.Name; //Add chunk modifier if (chunkNumber != -1) { structure.Name += " [" + chunkNumber + "]"; } //Assign the size structure.Size = mreflexive.Size; //Read the count structure.Count = Map.IO.In.ReadInt32(); //Read the pointer structure.Pointer = Map.IO.In.ReadInt32() - Map.MapHeader.mapMagic; //If the count or pointer are bad, break out and dont add it to the list if (structure.Count <= 0 | structure.Pointer <= 0 | structure.Count > 100000) { break; } //Assign the offset structure.Offset = chunkOffset + mreflexive.Offset; //Add it to the list Structures.Add(structure); //Loop through all the chunks for (int z = 0; z < structure.Count; z++) { //Parse recursively ParseRecursively(mreflexive.Values, structure.Pointer + (z * structure.Size), z); } break; } case mValue.ObjectAttributes.Ident: { //If the offset is rediculous.. if (chunkOffset + ValueList[i].Offset > (int)Map.IO.In.BaseStream.Length) { break; } //Go to the ident offset Map.IO.In.BaseStream.Position = chunkOffset + ValueList[i].Offset; //Get the ident instance mIdent mident = (mIdent)ValueList[i]; //Initialize our instance of the ident Ident ident = new Ident(); //Assign the name ident.Name = mident.Name; if (chunkNumber != -1) { ident.Name += " [" + chunkNumber + "]"; } //Assign the offset ident.Offset = chunkOffset + mident.Offset - 12; //Assign the Ident ident.ID = Map.IO.In.ReadInt32(); //Get the tag index int index = Map.GetTagIndexByIdent(ident.ID); //Assign the class if (index != -1) { ident.TagClass = Map.IndexItems[index].Class; } else { ident.TagClass = "Null"; } //Assign the name if (index != -1) { ident.TagName = Map.IndexItems[index].Name; } else { ident.TagName = "Null"; } //Add to the ident to the list Idents.Add(ident); break; } case mValue.ObjectAttributes.StringID: { //If the offset is rediculous.. if (chunkOffset + ValueList[i].Offset > (int)Map.IO.In.BaseStream.Length) { break; } //Go to the ident offset Map.IO.In.BaseStream.Position = chunkOffset + ValueList[i].Offset; //Get the ident instance mStringID mstringid = (mStringID)ValueList[i]; //Initialize our instance of the string id. StringIdentifier str = new StringIdentifier(); //Assign the name str.Name = mstringid.Name; if (chunkNumber != -1) { str.Name += " [" + chunkNumber + "]"; } //Assign the offset str.Offset = chunkOffset + mstringid.Offset; //Assign the Ident str.Identifier = Map.IO.In.ReadInt32(); //Get the string index int index = Map.StringTable.GetStringItemIndexByID(Map, str.Identifier); //Assign the string index str.StringIndex = index; //Try to.. try { //Assign the string name str.StringName = Map.StringTable.StringItems[index].Name; } catch { //Assign our invalid name str.StringName = "<<invalid sid>>"; } //Add to the string to the list Strings.Add(str); break; } } } }