/// <summary>
/// Merge selected items from the SORTED lists without duplicate values
///
/// </summary>
/// <param name="list">Items to merge</param>
/// <param name="mask">Filter by mask</param>
/// <param name="filterStatic">Ignore static members (inheritance)</param>
public void Merge(ASMemberList list, FlagType mask, bool filterStatic)
{
int index = 0;
bool added;
foreach (ASMember m in list)
{
if ((m.Flags & mask) == mask && (!filterStatic || (m.Flags & FlagType.Static) == 0))
{
added = false;
while (index < items.Count)
{
if (m.CompareTo(items[index]) <= 0)
{
if (!m.Equals(items[index]))
{
items.Insert(index, m);
}
added = true;
break;
}
index++;
}
if (!added)
{
items.Add(m);
}
}
}
}
public static NpcFlag ToNpc(this FlagType flag)
{
switch (flag)
{
case FlagType.Damage:
return(NpcFlag.PrimaryHit);
case FlagType.FacingDir:
return(NpcFlag.FacingCoordinate);
case FlagType.InteractingEntity:
return(NpcFlag.InteractingEntity);
case FlagType.DefinitionChange:
return(NpcFlag.Definition);
case FlagType.ParticleEffect:
return(NpcFlag.ParticleEffect);
case FlagType.Animation:
return(NpcFlag.Animation);
case FlagType.OverheadText:
return(NpcFlag.Text);
default:
throw new ArgumentOutOfRangeException(nameof(flag), flag, null);
}
}
public static string ToText(this FlagType t)
{
string text;
switch (t)
{
case FlagType.Ascii:
text = Values.Ascii;
break;
case FlagType.Utf8:
text = Values.Utf8;
break;
case FlagType.Long:
text = Values.Long;
break;
case FlagType.Numeric:
text = Values.Numeric;
break;
default:
text = Values.Ascii;
break;
}
return(text);
}
//各种click函数
private void addButton_Click(object sender, EventArgs e)
{
ControlStatus();
BoxStatus();
ClearControls();
flag = FlagType.Add;
}
private void BindFlagTypeDropDownList()
{
this.flagDropDownlist.DataSource = FlagType.GetFlagTypes(this.Catalog);
this.flagDropDownlist.DataTextField = "FlagTypeName";
this.flagDropDownlist.DataValueField = "FlagTypeId";
this.flagDropDownlist.DataBind();
}
public object this[FlagType flag]
{
get
{
for (int i = 0; i < cells.Length; i++)
{
if (cells[i].Flag == flag)
{
return(cells[i].Value);
}
}
return(null);
}
set
{
for (int i = 0; i < cells.Length; i++)
{
if (cells[i].Flag == flag)
{
cells[i].Value = value;
}
}
}
}
private void ReadFromJSON()
{
string jsonString = PlayerPrefs.GetString(m_UserKey);
if (!string.IsNullOrEmpty(jsonString))
{
m_UserData = JSON.Parse(jsonString);
uint version = m_UserData["version"].AsUInt;
m_Flags = m_UserData["flags"].AsUInt;
m_Eggs = m_UserData["eggs"].AsInt;
m_MuteMusic = m_UserData["muteMusic"].AsBool;
m_MuteSound = m_UserData["muteSound"].AsBool;
m_LanguageCode = m_UserData["language"].Value;
m_NumLevelsCompleted = m_UserData["numLevelsCompleted"].AsInt;
m_StampData = m_UserData["stampData"];
m_LevelIndex = m_UserData["levelIndex"].AsInt;
m_TutorialLevel = (FlagType)m_UserData["tutorialLevel"].AsUInt;
// If we're dealing with old save data, the flags are invalid.
if (version == 0)
{
// We keep the seen flags. Tutorials have changed.
m_Flags &= (uint)(FlagType.Seen_Intro);
m_TutorialLevel = 0;
}
}
else
{
m_UserData = new JSONClass();
}
}
void AddChilds(XmlWriter xmlwr, BaseNode parentNode, FlagType flagMask, bool onlyChanges)
{
foreach (BaseNode child in parentNode.Children)
{
if (onlyChanges && !child.AnyChanges())
{
continue;
}
xmlwr.WriteStartElement(child.Name);
BaseNode childNode = child;
if (resolveMirrors && (child.GetType() == typeof(MirrorNode)))
{
MirrorNode mirror = (child as MirrorNode);
if (mirror.IsLinked())
{
childNode = mirror.MirrorSource;
}
}
AddNodeAttributes(xmlwr, childNode, onlyChanges);
if (childNode.Children.Count > 0)
{
AddChilds(xmlwr, childNode, flagMask, onlyChanges);
}
xmlwr.WriteEndElement();
}
}
internal static string GetFlagName(FlagType flagType)
{
switch (flagType)
{
case FlagType.Parley:
return(ModEntry.i18n.Get("item.ancient_flag.parely.name"));
case FlagType.JollyRoger:
return(ModEntry.i18n.Get("item.ancient_flag.jolly_roger.name"));
case FlagType.GamblersCrest:
return(ModEntry.i18n.Get("item.ancient_flag.gamblers_crest.name"));
case FlagType.MermaidsBlessing:
return(ModEntry.i18n.Get("item.ancient_flag.mermaids_blessing.name"));
case FlagType.PatronSaint:
return(ModEntry.i18n.Get("item.ancient_flag.patron_saint.name"));
case FlagType.SharksFin:
return(ModEntry.i18n.Get("item.ancient_flag.sharks_fin.name"));
case FlagType.Worldly:
return(ModEntry.i18n.Get("item.ancient_flag.worldly_flag.name"));
case FlagType.SlimeKing:
return(ModEntry.i18n.Get("item.ancient_flag.slime_king.name"));
default:
return(ModEntry.i18n.Get("item.ancient_flag.unknown.name"));
}
}
public FlagServiceCommand(int clientId, int serviceId, FlagType flagType, string message)
{
Message = message;
ClientId = clientId;
ServiceId = serviceId;
FlagType = flagType;
}
public FlagServiceCommand(int clientId, int serviceId, FlagType flagType, string message)
{
Message = message;
ClientId = clientId;
ServiceId = serviceId;
FlagType = flagType;
}
/// <summary>
/// Merge selected items from the SORTED lists without duplicate values
/// </summary>
/// <param name="list">Items to merge</param>
public void Merge(MemberList list, FlagType mask)
{
int index = 0;
bool added;
foreach (MemberModel m in list)
{
if ((m.Flags & mask) == mask)
{
added = false;
while (index < items.Count)
{
if (m.CompareTo(items[index]) <= 0)
{
if (!m.Equals(items[index]))
{
items.Insert(index, m);
}
added = true;
break;
}
index++;
}
if (!added)
{
items.Add(m);
}
}
}
}
public static PlayerFlag ToPlayer(this FlagType flag)
{
switch (flag)
{
case FlagType.Damage:
return(PlayerFlag.PrimaryHit);
case FlagType.FacingDir: return(PlayerFlag.FacingCoordinate);
case FlagType.InteractingEntity:
return(PlayerFlag.InteractEnt);
case FlagType.Appearance:
return(PlayerFlag.Appearance);
case FlagType.ChatMessage:
return(PlayerFlag.Chat);
case FlagType.ForcedMovement:
return(PlayerFlag.ForcedMovement);
case FlagType.ParticleEffect:
return(PlayerFlag.ParticleEffect);
case FlagType.Animation:
return(PlayerFlag.Animation);
case FlagType.OverheadText:
return(PlayerFlag.ForcedText);
default:
throw new ArgumentOutOfRangeException(nameof(flag), flag, null);
}
}
private void GetFlags()
{
switch (RawHeaderBytes[5])
{
case 128:
Flags = FlagType.Unsynchronisation;
break;
case 64:
Flags = FlagType.Extendedheader;
break;
case 32:
Flags = FlagType.Experimemtalindicator;
break;
case 0:
Flags = FlagType.Normal;
break;
default:
Flags = FlagType.Break;
break;
}
}
public MemberModel(string name, string type, FlagType flags, Visibility access)
{
Name = name;
Type = type;
Flags = flags;
Access = access;
}
private SqlCommand AddParameters_Booking(SqlCommand cmd, FlagType flag, DTO.Booking Ob)
{
cmd.Parameters.Add(new SqlParameter("@Flag", flag));
cmd.Parameters.Add(new SqlParameter("@BookingNumber", Ob.BookingNumber));
cmd.Parameters.Add(new SqlParameter("@IsHomeReceipt", Ob.IsHomeReceipt));
cmd.Parameters.Add(new SqlParameter("@HomeReceiptNumber", Ob.HomeReceiptNumber));
cmd.Parameters.Add(new SqlParameter("@CustomerID", Ob.CustomerID));
cmd.Parameters.Add(new SqlParameter("@DueDate", Ob.DueDate));
cmd.Parameters.Add(new SqlParameter("@DueTime", Ob.DueTime));
cmd.Parameters.Add(new SqlParameter("@IsUrgent", Ob.IsUrgent));
cmd.Parameters.Add(new SqlParameter("@IsSMS", Ob.IsSMS));
cmd.Parameters.Add(new SqlParameter("@IsEmail", Ob.IsEmail));
cmd.Parameters.Add(new SqlParameter("@ReceiptRemarks", Ob.ReceiptRemarks));
cmd.Parameters.Add(new SqlParameter("@SalesManUserID", Ob.SalesManUserID));
cmd.Parameters.Add(new SqlParameter("@CheckedByUserID", Ob.CheckedByUserID));
cmd.Parameters.Add(new SqlParameter("@TotalGrossAmount", Ob.TotalGrossAmount));
cmd.Parameters.Add(new SqlParameter("@TotalDiscount", Ob.TotalDiscount));
cmd.Parameters.Add(new SqlParameter("@TotalTax", Ob.TotalTax));
cmd.Parameters.Add(new SqlParameter("@TotalAdvance", Ob.TotalAdvance));
cmd.Parameters.Add(new SqlParameter("@ReceiptStatus", Ob.ReceiptStatus));
cmd.Parameters.Add(new SqlParameter("@Active", Ob.CommonFields.Active));
cmd.Parameters.Add(new SqlParameter("@DateCreated", Ob.CommonFields.DateCreated));
cmd.Parameters.Add(new SqlParameter("@DateModified", Ob.CommonFields.DateModified));
cmd.Parameters.Add(new SqlParameter("@CreatedBy", Ob.CommonFields.CreatedBy));
cmd.Parameters.Add(new SqlParameter("@ModifiedBy", Ob.CommonFields.ModifiedBy));
cmd.Parameters.Add(new SqlParameter("@BranchId", Ob.CommonFields.BranchId));
cmd.Parameters.Add(new SqlParameter("@XMLName", Ob.XMLName));
return(cmd);
}
static public int GetMemberIcon(FlagType flag, Visibility access)
{
int rst = 0;
if ((flag & FlagType.Constant) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_CONST :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_CONST : ICON_CONST;
}
else if ((flag & FlagType.Variable) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_VAR :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_VAR : ICON_VAR;
}
else if ((flag & (FlagType.Getter | FlagType.Setter)) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_PROPERTY :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_PROPERTY : ICON_PROPERTY;
}
else if ((flag & FlagType.Function) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_FUNCTION :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_FUNCTION : ICON_FUNCTION;
}
return(rst);
}
public GlobalFlag(string name, FlagType type, string value)
{
this.name = name;
this.flagType = flagType;
this.value = value;
}
public Vector3F GetFlagSpawn(FlagType flag)
{
Vector3F pos = new Vector3F(0, 0, 0);
ComputeFlagSpawnPoint?.Invoke(this, World, flag, ref pos);
return(pos);
}
protected FlagInstance SetupNewFlag(FlagType flag, Vector3F location, bool spawnInAir)
{
FlagInstance inst = new FlagInstance();
inst.Flag = flag;
inst.Position = location;
inst.Owner = null;
inst.OwnerID = -1;
if (spawnInAir)
{
inst.Status = FlagStatuses.FlagComing;
ComputeFlagAdd?.Invoke(null, inst);
}
else
{
inst.Status = FlagStatuses.FlagOnGround;
}
inst.FlagID = GetNewFlagID();
if (inst.FlagID < 0)
{
return(null);
}
lock (ActiveFlags)
{
ActiveFlags.Add(inst.FlagID, inst);
WorldFlags.Add(inst.FlagID, inst);
}
Logger.Log3("Setup new flag " + inst.FlagID.ToString() + " of type " + flag.FlagAbbv);
return(inst);
}
private string GetFlagDescription(FlagType flagType)
{
switch (flagType)
{
case FlagType.Parley:
return(ModEntry.i18n.Get("item.ancient_flag.parely.description"));
case FlagType.JollyRoger:
return(ModEntry.i18n.Get("item.ancient_flag.jolly_roger.description"));
case FlagType.GamblersCrest:
return(ModEntry.i18n.Get("item.ancient_flag.gamblers_crest.description"));
case FlagType.MermaidsBlessing:
return(ModEntry.i18n.Get("item.ancient_flag.mermaids_blessing.description"));
case FlagType.PatronSaint:
return(ModEntry.i18n.Get("item.ancient_flag.patron_saint.description"));
case FlagType.SharksFin:
return(ModEntry.i18n.Get("item.ancient_flag.sharks_fin.description"));
case FlagType.Worldly:
return(ModEntry.i18n.Get("item.ancient_flag.worldly_flag.description"));
case FlagType.SlimeKing:
return(ModEntry.i18n.Get("item.ancient_flag.slime_king.description"));
case FlagType.KingCrab:
return(ModEntry.i18n.Get("item.ancient_flag.king_crab.description"));
default:
return(ModEntry.i18n.Get("item.ancient_flag.unknown.description"));
}
}
private static List <ICompletionListItem> GetTagAttributeValues(ClassModel tagClass, string ns, string attribute)
{
ClassModel curClass = mxmlContext.model.GetPublicClass();
ClassModel tmpClass = tagClass;
FlagType mask = FlagType.Variable | FlagType.Setter;
Visibility acc = context.TypesAffinity(curClass, tmpClass);
if (tmpClass.InFile.Package != "mx.builtin" && tmpClass.InFile.Package != "fx.builtin" && attribute == "id")
{
return(null);
}
while (tmpClass != null && !tmpClass.IsVoid())
{
string className = tmpClass.Name;
foreach (MemberModel member in tmpClass.Members)
{
if ((member.Flags & FlagType.Dynamic) > 0 && (member.Flags & mask) > 0 &&
(member.Access & acc) > 0)
{
if (member.Name == attribute)
{
string mtype = member.Type;
if ((member.Flags & FlagType.Setter) > 0)
{
if (member.Parameters != null && member.Parameters.Count > 0)
{
mtype = member.Parameters[0].Type;
}
else
{
mtype = null;
}
}
return(GetAutoCompletionValuesFromType(mtype));
}
}
}
List <ICompletionListItem> retVal;
if (GetAutoCompletionValuesFromMetaData(tmpClass.InFile, attribute, tagClass, tmpClass, out retVal))
{
return(retVal);
}
tmpClass = tmpClass.Extends;
if (tmpClass != null && tmpClass.InFile.Package == "" && tmpClass.Name == "Object")
{
break;
}
// members visibility
acc = context.TypesAffinity(curClass, tmpClass);
}
return(null);
}
public CustomPacket(FlagType Flag, HeaderTypes basic, string Command, List <string> Args, object Payload)
{
this.Flag = Flag;
this.Header = Header;
this.Command = Command;
this.Args = Args;
this.Payload = Payload;
}
private void BindFlagTypeDropDownList()
{
this.flagDropDownlist.DataSource = FlagType.GetFlagTypes(this.Catalog);
this.flagDropDownlist.DataTextField = "FlagTypeName";
this.flagDropDownlist.CssClass = "ui fluid search dropdown";
this.flagDropDownlist.DataValueField = "FlagTypeId";
this.flagDropDownlist.DataBind();
}
public void SetFlag(FlagType inFlag, bool inbOn)
{
if (inbOn != Bits.Contains(m_Flags, (byte)inFlag))
{
Bits.Set(ref m_Flags, (byte)inFlag, inbOn);
m_Modified = true;
}
}
public void SetFlag(FlagType flag, string value)
{
if (value == null)
{
value = string.Empty;
}
FlagDictionary[flag] = value;
}
/// <summary>
/// Construct new instance of <see cref="AnalysisSecurityWarning"/>
/// </summary>
/// <param name="fullFileName">Full name of source code file</param>
/// <param name="message">Warning message</param>
/// <param name="element">Element, where the warning was produced</param>
/// <param name="programPoint">The program point, where the warning was produced</param>
/// <param name="cause">Flag type</param>
public AnalysisSecurityWarning(string fullFileName, string message, LangElement element, ProgramPointBase programPoint, FlagType cause) :
base(programPoint)
{
FullFileName = fullFileName;
Message = message;
LangElement = element;
Flag = cause;
}
private void saveButton_Click(object sender, EventArgs e)
{
if (CheckData() == true)
{
switch (flag)
{
case FlagType.Add:
if (empMethod.Add(employee))
{
MessageBox.Show("添加成功");
}
else
{
MessageBox.Show("添加失败");
}
flag = FlagType.Begin;
empMethod.Find(dataGridView1);
ClearControls();
ControlStatus();
BoxStatus();
break;
case FlagType.Delete:
if (empMethod.Delete(employee))
{
MessageBox.Show("删除成功");
}
else
{
MessageBox.Show("删除失败");
}
flag = FlagType.Begin;
empMethod.Find(dataGridView1);
ClearControls();
ControlStatus();
break;
case FlagType.Update:
if (empMethod.Update(employee))
{
MessageBox.Show("修改成功");
}
else
{
MessageBox.Show("修改失败");
}
flag = FlagType.Begin;
empMethod.Find(dataGridView1);
ClearControls();
BoxStatus();
ControlStatus();
break;
default:
break;
}
}
}
protected void raise_FlagChanged(FlagType i1, [MarshalAs(UnmanagedType.U1)] bool i2)
{
ToolboxFlagHandler flagChanged = this.FlagChanged;
if (flagChanged != null)
{
flagChanged(i1, i2);
}
}
public static bool GetDebugFlag(FlagType type) {
switch (type) {
case FlagType.HOME:
return Instance.HOME_SCENE_DEBUG;
case FlagType.ADVENTURE:
return Instance.ADV_SCENE_DEBUG;
}
return false;
}
private void cancelButton_Click(object sender, EventArgs e)
{
ClearControls();
ControlStatus();
if (flag == FlagType.Add || flag == FlagType.Update)
{
BoxStatus();
}
flag = FlagType.Begin;
}
public HeaderStructure(FlagType flagType, CommandType commandType, int actualLength)
{
this.Command = new Command();
this.Flag = new Flag();
this.HeaderLength = new HeaderLength();
this.FlagType = flagType;
this.CommandType = commandType;
this.ActualLength = actualLength;
}
public bool GetValue(FlagType flag, [NotNullWhen(true)] out string?value)
{
if (!FlagDictionary.TryGetValue(flag, out var res))
{
value = null;
return(false);
}
value = res;
return(true);
}
public static void SetDebugFlag(FlagType type, bool value) {
switch (type) {
case FlagType.HOME:
Instance.HOME_SCENE_DEBUG = value;
break;
case FlagType.ADVENTURE:
Instance.ADV_SCENE_DEBUG = value;
break;
}
#if UNITY_EDITOR
EditorUtility.SetDirty(Instance);
AssetDatabase.SaveAssets();
#endif
}
/// <summary>
/// Initializes a new instance of the <see cref="Flags"/> struct.
/// </summary>
/// <param name="id">The ID.</param>
public Flags(uint id)
{
this.ID = id;
this.Type = FlagType.Merged;
switch (this.ID) {
case 000: this.Type = FlagType.None; break;
case 001: this.Type = FlagType.Poison; break;
case 002: this.Type = FlagType.Burn; break;
case 004: this.Type = FlagType.Eletric; break;
case 008: this.Type = FlagType.Drunk; break;
case 016: this.Type = FlagType.MShield; break;
case 032: this.Type = FlagType.Slowed; break;
case 064: this.Type = FlagType.Haste; break;
case 128: this.Type = FlagType.Battle; break;
case 256: this.Type = FlagType.Drowing; break;
}
}
public static int GetIcon(FlagType flag, Visibility access)
{
int rst = 0;
bool isStatic = (flag & FlagType.Static) > 0;
if ((flag & FlagType.Constant) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_CONST :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_CONST : ICON_CONST;
if (isStatic) rst += 3;
}
else if ((flag & FlagType.Variable) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_VAR :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_VAR : ICON_VAR;
if (isStatic) rst += 3;
}
else if ((flag & (FlagType.Getter | FlagType.Setter)) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_PROPERTY :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_PROPERTY : ICON_PROPERTY;
if (isStatic) rst += 3;
}
else if ((flag & FlagType.Function) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_FUNCTION :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_FUNCTION : ICON_FUNCTION;
if (isStatic) rst += 3;
}
else if ((flag & (FlagType.Interface | FlagType.TypeDef)) > 0)
{
rst = ICON_INTERFACE;
}
else if (flag == FlagType.Package)
rst = PluginUI.ICON_PACKAGE;
else if (flag == FlagType.Declaration)
rst = PluginUI.ICON_DECLARATION;
else if (flag == FlagType.Template)
rst = PluginUI.ICON_TEMPLATE;
else
{
rst = ((flag & FlagType.Intrinsic) > 0) ? ICON_INTRINSIC_TYPE :
((flag & FlagType.Interface) > 0) ? ICON_INTERFACE : ICON_TYPE;
}
return rst;
}
public bool MatchesFlag(string name, FlagType type, bool caseSensitive)
{
return Type.HasFlag(type) && FlagName.Equals(name, caseSensitive ? StringComparison.InvariantCulture : StringComparison.InvariantCultureIgnoreCase);
}
static public int GetMemberIcon(FlagType flag, Visibility access)
{
int rst = 0;
if ((flag & FlagType.Constant) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_CONST :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_CONST : ICON_CONST;
}
else if ((flag & FlagType.Variable) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_VAR :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_VAR : ICON_VAR;
}
else if ((flag & (FlagType.Getter | FlagType.Setter)) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_PROPERTY :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_PROPERTY : ICON_PROPERTY;
}
else if ((flag & FlagType.Function) > 0)
{
rst = ((access & Visibility.Private) > 0) ? ICON_PRIVATE_FUNCTION :
((access & Visibility.Protected) > 0) ? ICON_PROTECTED_FUNCTION : ICON_FUNCTION;
}
return rst;
}
public static void AddMembersGrouped(TreeNodeCollection tree, MemberList members)
{
FlagType[] typePriority = new FlagType[] { FlagType.Constructor, FlagType.Function, FlagType.Getter | FlagType.Setter, FlagType.Variable, FlagType.Constant };
Visibility[] visibilityPriority = new Visibility[] { Visibility.Internal, Visibility.Private, Visibility.Protected, Visibility.Public };
Dictionary<FlagType, List<MemberModel>> typeGroups = new Dictionary<FlagType, List<MemberModel>>();
FlagType type;
List<MemberModel> groupList;
MemberTreeNode node = null;
foreach (MemberModel member in members)
{
if (node != null && node.Text == member.ToString())
continue;
// member type
if ((member.Flags & FlagType.Constant) > 0)
type = FlagType.Constant;
else if ((member.Flags & FlagType.Variable) > 0)
type = FlagType.Variable;
else if ((member.Flags & (FlagType.Getter | FlagType.Setter)) > 0)
type = (FlagType.Getter | FlagType.Setter);
else if ((member.Flags & FlagType.Constructor) > 0)
type = FlagType.Constructor;
else type = FlagType.Function;
// group
if (!typeGroups.ContainsKey(type))
{
groupList = new List<MemberModel>();
typeGroups.Add(type, groupList);
}
else groupList = typeGroups[type];
groupList.Add(member);
}
MemberModel prevMember = null;
for (int i = 0; i < typePriority.Length; i++)
{
if (typeGroups.ContainsKey(typePriority[i]))
{
groupList = typeGroups[typePriority[i]];
if (groupList.Count == 0)
continue;
groupList.Sort();
TreeNode groupNode = new TreeNode(typePriority[i].ToString(), ICON_FOLDER_CLOSED, ICON_FOLDER_OPEN);
int img;
node = null;
foreach (MemberModel member in groupList)
{
if (prevMember != null && prevMember.Name == member.Name)
continue;
img = GetIcon(member.Flags, member.Access);
node = new MemberTreeNode(member, img);
groupNode.Nodes.Add(node);
}
if (typePriority[i] != FlagType.Constructor) groupNode.Expand();
tree.Add(groupNode);
}
}
}
/// <summary>
/// Eval a token depending on the parser context
/// </summary>
/// <param name="evalContext">The token could be an identifier</param>
/// <param name="evalKeyword">The token could be a keyword</param>
/// <param name="position">Parser position</param>
/// <returns>A keyword was found</returns>
private bool EvalToken(bool evalContext, bool evalKeyword, int position)
{
bool hadContext = (context != 0);
bool hadKeyword = (foundKeyword != 0);
foundKeyword = 0;
string token = curToken.Text;
Debug.WriteLine("\t\t\t\t\t'"+token+"' @"+curToken.Position+" ("+evalKeyword+") after "+context);
/* KEYWORD EVALUATION */
if (evalKeyword && (token.Length > 2))
{
// members
if (token == "var")
{
foundKeyword = FlagType.Variable;
}
else if (token == "function")
{
foundKeyword = FlagType.Function;
}
else if (haXe && token == "property")
{
foundKeyword = FlagType.Function;
modifiers |= FlagType.HXProperty;
}
else if (version == 3 && token == "const")
{
foundKeyword = FlagType.Variable;
modifiers |= FlagType.Constant;
}
else if (version == 3 && token == "namespace")
{
foundKeyword = FlagType.Namespace;
}
// class declaration
else if (tryPackage && token == "package")
{
foundKeyword = FlagType.Package;
if (version < 3)
{
version = 3;
model.Namespaces.Insert(1, "protected");
model.Namespaces.Add("internal");
}
}
else if (token == "class")
{
foundKeyword = FlagType.Class;
if (version == 1) version = 2;
}
else if (token == "interface")
{
foundKeyword = FlagType.Class;
modifiers |= FlagType.Interface;
if (version == 1) version = 2;
}
else if (haXe && token == "enum")
{
foundKeyword = FlagType.Enum;
}
// head declarations
else if (token == "import")
{
foundKeyword = FlagType.Import;
}
// modifiers
else
{
if (context == FlagType.Class)
{
if (token == "extends")
{
foundKeyword = FlagType.Class;
curModifiers = FlagType.Extends;
return true;
}
else if (token == "implements")
{
foundKeyword = FlagType.Class;
curModifiers = FlagType.Implements;
return true;
}
}
// modifiers
else if (context == FlagType.Function)
{
if (token == "get")
{
foundKeyword = FlagType.Function;
curModifiers |= FlagType.Getter;
return true;
}
else if (token == "set")
{
foundKeyword = FlagType.Function;
curModifiers |= FlagType.Setter;
return true;
}
}
FlagType foundModifier = 0;
// namespace modifier
foreach(string ns in model.Namespaces)
if (token == ns)
{
curNamespace = token;
foundModifier = FlagType.Namespace;
}
// other modifiers
if (foundModifier == 0)
if (token == "static")
{
foundModifier = FlagType.Static;
}
else if (version <= 3 && token == "intrinsic")
{
foundModifier = FlagType.Intrinsic;
}
else if (version == 3 && token == "override")
{
foundModifier = FlagType.Override;
}
else if (version == 3 && token == "native")
{
foundModifier = FlagType.Intrinsic | FlagType.Native;
}
else if (version == 4 && token == "extern")
{
foundModifier = FlagType.Intrinsic | FlagType.Extern;
}
else if (token == "dynamic")
{
foundModifier = FlagType.Dynamic;
}
// a declaration modifier was recognized
if (foundModifier != 0)
{
if (inParams && inValue) valueKeyword = new Token(curToken);
inParams = false;
inEnum = false;
inValue = false;
inType = false;
foundColon = false;
if (context != 0)
{
modifiers = 0;
context = 0;
}
if (modifiers == 0)
{
modifiersLine = curToken.Line;
//modifiersPos = curToken.Position;
}
modifiers |= foundModifier;
return true;
}
}
}
// a declaration keyword was recognized
if (foundKeyword != 0)
{
if (inParams && inValue) valueKeyword = new Token(curToken);
inParams = false;
inEnum = false;
inValue = false;
foundColon = false;
context = foundKeyword;
curModifiers = modifiers;
curComment = lastComment;
if (foundKeyword != FlagType.Import)
lastComment = null;
modifiers = 0;
curMember = null;
return true;
}
else if (!evalContext)
return false;
/* EVAL DECLARATION */
if (foundColon && curMember != null)
{
foundColon = false;
//Debug.WriteLine(" "+curMember.Name+":/*"+lastComment+"*/"+curToken);
curMember.Type = curToken.Text;
curMember.LineTo = curToken.Line;
// Typed Arrays
if (curMember.Type == "Array" && lastComment != null && re_typedArray.IsMatch(lastComment))
{
curMember.Type = "/*"+lastComment+"*/Array";
}
}
else if (hadContext && (hadKeyword || inParams))
{
//if (curModifiers != 0)
//Debug.WriteLine(" @"+modifiersLine+" "+modifiersPos+" *");
//else
//Debug.WriteLine(" @"+curToken.Line+" "+curToken.Position);
if (curComment != null && context != FlagType.Import)
{
curComment = curComment.Trim();
Match mTip = re_tip.Match(curComment+"@");
if (mTip.Success)
{
//Debug.WriteLine("@tiptext: "+re_cleanTip.Replace(mTip.Groups["tip"].Value, " ").Trim());
}
////Debug.WriteLine("\t/**"+curComment+"*/");
}
MemberModel member;
switch (context)
{
case FlagType.Package:
//Debug.WriteLine("package "+token);
//
if (prevToken.Text == "package")
{
model.Package = token;
}
break;
case FlagType.Namespace:
//Debug.WriteLine("namespace "+token);
//
if (prevToken.Text == "namespace")
{
model.Namespaces.Add(token);
}
break;
case FlagType.Import:
//Debug.WriteLine("import "+token+" ("+prevToken.Text+")");
//
if (prevToken.Text == "import")
{
member = new MemberModel();
member.Name = LastStringToken(token, ".");
member.Type = token;
model.Imports.Add(member);
}
break;
case FlagType.Class:
if (curModifiers == FlagType.Extends)
{
//Debug.WriteLine("extends "+token);
// TODO Get extended class from context
/*if (curClass != null)
{
ClassModel exClass = new ClassModel();
exClass.ClassName = token;
curClass.Extends = exClass;
}*/
}
else if (curModifiers == FlagType.Implements)
{
//Debug.WriteLine("implements "+token);
/*if (curClass != null)
{
if (curClass.Implements == null) curClass.Implements = new ArrayList();
// TODO Get implemented class from context
ClassModel impClass = new ClassModel();
impClass.ClassName = token;
curClass.Implements.Add(impClass);
}*/
}
else if (prevToken.Text == "class" || prevToken.Text == "interface")
{
//Debug.WriteLine(curNamespace+" "+curModifiers+" class "+token);
//
if (curClass != null)
{
curClass.LineTo = (curModifiers != 0) ? modifiersLine-1 : curToken.Line-1;
}
// check classname
int p = token.LastIndexOf('.');
if (p > 0)
{
if (version < 3)
{
string package = token.Substring(0, p);
model.Package = package;
token = token.Substring(p+1);
}
else
{
//TODO Error: AS3 & haXe classes are qualified by their package declaration
}
}
curClass = new ClassModel();
model.Classes.Add(curClass);
curClass.InFile = model;
curClass.Comments = curComment;
curClass.ClassName = token;
curClass.Constructor = (haXe) ? "new" : token;
curClass.Flags = curModifiers;
curClass.Namespace = curNamespace;
curClass.LineFrom = (curModifiers != 0) ? modifiersLine : curToken.Line;
curClass.LineTo = curToken.Line;
}
else
{
context = 0;
modifiers = 0;
}
break;
case FlagType.Enum:
if (inEnum)
{
//Debug.WriteLine("value "+token);
//
member = new MemberModel();
member.Comments = curComment;
member.Name = token;
member.Flags = curModifiers | FlagType.Variable | FlagType.Enum;
member.Namespace = curNamespace;
member.LineFrom = member.LineTo = curToken.Line;
//curClass.Vars.Add(member);
curClass.Members.Add(member);
//
curMember = member;
}
else
{
//Debug.WriteLine(curNamespace+" "+curModifiers+" enum "+token);
//
if (curClass != null)
{
curClass.LineTo = (curModifiers != 0) ? modifiersLine-1 : curToken.Line-1;
}
curClass = new ClassModel();
model.Enums.Add(curClass);
curClass.InFile = model;
curClass.Comments = curComment;
curClass.ClassName = token;
curClass.Flags = curModifiers | FlagType.Enum;
curClass.Namespace = curNamespace;
curClass.LineFrom = (curModifiers != 0) ? modifiersLine : curToken.Line;
curClass.LineTo = curToken.Line;
}
break;
case FlagType.Variable:
/*if (inParams && curMethod != null)
{
if (inEnum)
Debug.WriteLine(" *"+curMethod.Name+"("+token);
else
Debug.WriteLine(" "+curMethod.Name+"("+token);
}
else Debug.WriteLine(curNamespace+" "+curModifiers+" var "+token);*/
//
// haXe type: T -> T
if (haXe && curMember != null && curMember.Type != null && curMember.Type.EndsWith("->"))
{
curMember.Type += " "+token;
return false;
}
else
{
member = new MemberModel();
member.Comments = curComment;
member.Name = token;
member.Flags = curModifiers | FlagType.Variable;
member.Namespace = curNamespace;
member.LineFrom = (curModifiers != 0) ? modifiersLine : curToken.Line;
member.LineTo = curToken.Line;
//
// method parameter
if (inParams && curMethod != null)
{
if (inEnum) member.Flags |= FlagType.Enum;
if (curMethod.Parameters == null) curMethod.Parameters = new ArrayList();
curMethod.Parameters.Add(member);
}
// class member
else if (curClass != null)
{
//curClass.Vars.Add(member);
curClass.Members.Add(member);
}
// package member
else model.Members.Add(member);
//
curMember = member;
}
break;
case FlagType.Function:
//Debug.WriteLine("{"+curNamespace+" "+curModifiers+" function "+token);
//
member = new MemberModel();
member.Comments = curComment;
member.Name = token;
member.Flags = curModifiers | FlagType.Function;
member.Namespace = curNamespace;
member.LineFrom = (curModifiers != 0) ? modifiersLine : curToken.Line;
member.LineTo = curToken.Line;
//
if (curClass != null)
{
if (token == curClass.Constructor) member.Flags |= FlagType.Constructor;
//if ((curModifiers & (FlagType.Getter | FlagType.Setter)) > 0) curClass.Properties.Add(member);
//else curClass.Methods.Add(member);
curClass.Members.Add(member);
}
else model.Members.Add(member);
//
curMember = member;
break;
}
if (context != FlagType.Function && !inParams) curMethod = null;
curComment = null;
curNamespace = "public";
modifiers = 0;
tryPackage = false;
}
return false;
}
/// <summary>
/// Merge selected items from the SORTED lists without duplicate values
///
/// </summary>
/// <param name="list">Items to merge</param>
/// <param name="mask">Filter by mask</param>
/// <param name="filterStatic">Ignore static members (inheritance)</param>
public void Merge(ASMemberList list, FlagType mask, bool filterStatic)
{
int index = 0;
bool added;
foreach (ASMember m in list)
if ((m.Flags & mask) == mask && (!filterStatic || (m.Flags & FlagType.Static) == 0))
{
added = false;
while (index < items.Count)
{
if (m.CompareTo(items[index]) <= 0)
{
if (!m.Equals(items[index]))
items.Insert(index, m);
added = true;
break;
}
index++;
}
if (!added) items.Add(m);
}
}
static private MemberModel FindLatest(FlagType match, Visibility visi, ClassModel inClass)
{
MemberList list;
if (inClass == ClassModel.VoidClass)
list = ASContext.Context.CurrentModel.Members;
else list = inClass.Members;
MemberModel fallback = null;
MemberModel latest = null;
foreach (MemberModel member in list)
{
fallback = member;
if ((member.Flags & match) > 0 && (visi == 0 || (member.Access & visi) > 0))
{
latest = member;
}
}
return latest ?? fallback;
}
/// <summary>
/// Merge selected items from the SORTED lists without duplicate values
/// </summary>
/// <param name="list">Items to merge</param>
public void Merge(MemberList list, FlagType mask)
{
int index = 0;
bool added;
foreach (MemberModel m in list)
if ((m.Flags & mask) == mask)
{
added = false;
while (index < items.Count)
{
if (m.CompareTo(items[index]) <= 0)
{
if (!m.Equals(items[index]))
items.Insert(index, m);
added = true;
break;
}
index++;
}
if (!added) items.Add(m);
}
}
static private MemberModel FindLatest(FlagType match, ClassModel inClass)
{
return FindLatest(match, 0, inClass);
}
static private MemberModel FindLatest(FlagType match, Visibility visi, ClassModel inClass,
bool isFlagMatchStrict, bool isVisibilityMatchStrict)
{
MemberList list;
if (inClass == ClassModel.VoidClass)
list = ASContext.Context.CurrentModel.Members;
else
list = inClass.Members;
MemberModel latest = null;
MemberModel fallback = null;
foreach (MemberModel member in list)
{
fallback = member;
if (isFlagMatchStrict && isVisibilityMatchStrict)
{
if ((member.Flags & match) == match && (visi == 0 || (member.Access & visi) == visi))
{
latest = member;
}
}
else if (isFlagMatchStrict && !isVisibilityMatchStrict)
{
if ((member.Flags & match) == match && (visi == 0 || (member.Access & visi) > 0))
{
latest = member;
}
}
else if (!isFlagMatchStrict && isVisibilityMatchStrict)
{
if ((member.Flags & match) > 0 && (visi == 0 || (member.Access & visi) == visi))
{
latest = member;
}
}
else
{
if ((member.Flags & match) > 0 && (visi == 0 || (member.Access & visi) > 0))
{
latest = member;
}
}
}
if (isFlagMatchStrict || isVisibilityMatchStrict)
fallback = null;
return latest ?? fallback;
}
private static MemberModel NewMember(string contextToken, MemberModel calledFrom, FlagType kind, Visibility visi)
{
string type = (kind == FlagType.Function && !ASContext.Context.Features.hasInference)
? ASContext.Context.Features.voidKey : null;
if (calledFrom != null && (calledFrom.Flags & FlagType.Static) > 0)
kind |= FlagType.Static;
return new MemberModel(contextToken, type, kind, visi);
}
/// <summary>
/// Eval a token depending on the parser context
/// </summary>
/// <param name="evalContext">The token could be an identifier</param>
/// <param name="evalKeyword">The token could be a keyword</param>
/// <param name="position">Parser position</param>
/// <returns>A keyword was found</returns>
private bool EvalToken(bool evalContext, bool evalKeyword, int position)
{
bool hadContext = (context != 0);
bool hadKeyword = (foundKeyword != 0);
foundKeyword = 0;
/* KEYWORD EVALUATION */
string token = curToken.Text;
int dotIndex = token.LastIndexOf('.');
if (evalKeyword && (token.Length > 2))
{
if (dotIndex > 0) token = token.Substring(dotIndex + 1);
// members
if (token == "var" || (token == "catch" && !haXe))
{
foundKeyword = FlagType.Variable;
}
else if (token == "function")
{
foundKeyword = FlagType.Function;
}
else if (features.hasConsts && token == "const")
{
foundKeyword = FlagType.Variable;
modifiers |= FlagType.Constant;
}
else if (features.hasNamespaces && token == "namespace")
{
if (context == 0 && prevToken.Text != "use")
foundKeyword = FlagType.Namespace;
}
else if (features.hasDelegates && token == "delegate")
{
foundKeyword = FlagType.Function;
modifiers |= FlagType.Delegate;
}
// class declaration
else if (tryPackage && token == "package")
{
foundKeyword = FlagType.Package;
if (version < 3)
{
version = 3;
hasPackageSection = true;
//model.Namespaces.Add("AS3", Visibility.Public);
//model.Namespaces.Add("ES", Visibility.Public);
}
}
else if (token == "class")
{
foundKeyword = FlagType.Class;
modifiers |= FlagType.Class;
if (version == 1)
{
version = 2;
hasPackageSection = true;
}
}
else if (token == "interface")
{
foundKeyword = FlagType.Class;
modifiers |= FlagType.Class | FlagType.Interface;
if (version == 1)
{
version = 2;
hasPackageSection = true;
}
}
else if (features.hasTypeDefs && token == "typedef")
{
foundKeyword = FlagType.TypeDef;
modifiers |= FlagType.TypeDef;
}
else if (features.hasTypeDefs && token == "abstract")
{
foundKeyword = FlagType.Abstract;
modifiers |= FlagType.Abstract;
}
else if (features.hasStructs && token == "struct")
{
foundKeyword = FlagType.Struct;
modifiers |= FlagType.Class | FlagType.Struct;
}
else if (features.hasEnums && token == "enum")
{
foundKeyword = FlagType.Enum;
modifiers |= FlagType.Enum;
}
// head declarations
else if (token == features.importKey || (haXe && token == features.importKeyAlt))
{
foundKeyword = FlagType.Import;
}
// modifiers
else
{
if (context == FlagType.Class || context == FlagType.TypeDef)
{
if (token == "extends")
{
foundKeyword = FlagType.Class;
curModifiers = FlagType.Extends;
return true;
}
else if (token == "implements")
{
foundKeyword = FlagType.Class;
curModifiers = FlagType.Implements;
return true;
}
}
else if (context == FlagType.Abstract)
{
if (features.hasTypeDefs && token == "from")
{
foundKeyword = FlagType.Class;
curModifiers = FlagType.Extends;
return true;
}
}
// properties
else if (context == FlagType.Function)
{
if (token == "get")
{
foundKeyword = FlagType.Function;
curModifiers |= FlagType.Getter;
return true;
}
else if (token == "set")
{
foundKeyword = FlagType.Function;
curModifiers |= FlagType.Setter;
return true;
}
}
FlagType foundModifier = 0;
// access modifiers
if (token == "public")
{
foundModifier = FlagType.Access;
curAccess = Visibility.Public;
}
else if (token == "private")
{
foundModifier = FlagType.Access;
curAccess = Visibility.Private;
}
else if (token == features.protectedKey)
{
foundModifier = FlagType.Access;
curAccess = Visibility.Protected;
}
else if (token == features.internalKey)
{
foundModifier = FlagType.Access;
curAccess = Visibility.Internal;
}
else if (version == 3 && !hadContext) // TODO Handle namespaces properly
{
if (token == "AS3")
{
foundModifier = FlagType.Access;
curAccess = Visibility.Public;
curNamespace = token;
}
else if (token == "flash_proxy")
{
foundModifier = FlagType.Access;
curAccess = Visibility.Public;
curNamespace = token;
}
}
// other modifiers
if (foundModifier == 0)
{
if (token == "static")
{
foundModifier = FlagType.Static;
}
else if (version <= 3 && token == "intrinsic")
{
foundModifier = FlagType.Intrinsic;
}
else if (token == "override")
{
foundModifier = FlagType.Override;
}
else if (version == 3 && token == "native")
{
foundModifier = FlagType.Intrinsic | FlagType.Native;
}
else if (version == 4 && token == "extern")
{
foundModifier = FlagType.Intrinsic | FlagType.Extern;
}
else if (token == "final")
{
foundModifier = FlagType.Final;
}
else if (token == "dynamic")
{
foundModifier = FlagType.Dynamic;
}
// namespace modifier
else if (features.hasNamespaces && model.Namespaces.Count > 0)
foreach (KeyValuePair<string, Visibility> ns in model.Namespaces)
if (token == ns.Key)
{
curAccess = ns.Value;
curNamespace = token;
foundModifier = FlagType.Namespace;
}
}
// a declaration modifier was recognized
if (foundModifier != 0)
{
if (inParams && inValue) valueKeyword = new Token(curToken);
inParams = false;
inEnum = false;
inTypedef = false;
inAbstract = false;
inValue = false;
inConst = false;
inType = false;
inGeneric = false;
valueMember = null;
foundColon = false;
if (curNamespace == "internal") curNamespace = "";
if (context != 0)
{
modifiers = 0;
context = 0;
}
if (modifiers == 0)
{
modifiersLine = curToken.Line;
//modifiersPos = curToken.Position;
}
modifiers |= foundModifier;
return true;
}
}
}
// a declaration keyword was recognized
if (foundKeyword != 0)
{
if (dotIndex > 0)
{
// an unexpected keyword was found, ignore previous context
curToken.Text = token;
curToken.Line = line;
// TODO Should the parser note this error?
}
if (inParams && inValue) valueKeyword = new Token(curToken);
inParams = false;
inEnum = false;
inTypedef = false;
inAbstract = false;
inGeneric = false;
inValue = false;
inConst = false;
if (token != "function") valueMember = null;
foundColon = false;
foundConstant = false;
context = foundKeyword;
curModifiers = modifiers;
if (!isBlockComment) lastComment = null;
curComment = lastComment;
if (foundKeyword != FlagType.Import)
lastComment = null;
modifiers = 0;
curMember = null;
return true;
}
else
{
// when not in a class, parse if/for/while blocks
if (ScriptMode)
{
if (token == "catch" || (haXe && token == "for"))
{
curModifiers = 0;
foundKeyword = FlagType.Variable;
context = FlagType.Variable;
return false;
}
}
if (inValue && valueMember != null) valueMember = null;
if (!evalContext) return false;
if (dotIndex > 0) token = curToken.Text;
// some heuristic around Enums & Typedefs
if (inEnum && !inValue)
{
curModifiers = 0;
curAccess = Visibility.Public;
}
if (inTypedef && !inValue && curModifiers != FlagType.Extends)
{
curModifiers = 0;
curAccess = Visibility.Public;
}
else if (!inTypedef && curModifiers == FlagType.TypeDef && curClass != null && token != "extends")
{
curClass.ExtendsType = token;
curModifiers = 0;
context = 0;
curComment = null;
curClass = null;
curNamespace = "internal";
curAccess = 0;
modifiers = 0;
modifiersLine = 0;
return true;
}
}
/* EVAL DECLARATION */
if (foundColon && curMember != null)
{
foundColon = false;
if (haXe && curMember.Type != null) curMember.Type += " " + curToken.Text;
else curMember.Type = curToken.Text;
curMember.LineTo = curToken.Line;
// Typed Arrays
if (TypeCommentUtils.Parse(lastComment, curMember) != TypeDefinitionKind.Null)
lastComment = null;
}
else if (hadContext && (hadKeyword || inParams || inEnum || inTypedef))
{
MemberModel member;
switch (context)
{
case FlagType.Package:
if (prevToken.Text == "package")
{
model.Package = token;
model.Comments = curComment;
}
break;
case FlagType.Namespace:
if (prevToken.Text == "namespace")
{
if (!model.Namespaces.ContainsKey(token))
{
model.Namespaces.Add(token, curAccess);
// namespace is treated as a variable
member = new MemberModel();
member.Comments = curComment;
member.Name = token;
member.Type = "Namespace";
member.Flags = FlagType.Dynamic | FlagType.Variable | FlagType.Namespace;
member.Access = (curAccess == 0) ? features.varModifierDefault : curAccess;
member.Namespace = curNamespace;
member.LineFrom = (modifiersLine != 0) ? modifiersLine : curToken.Line;
member.LineTo = curToken.Line;
if (curClass != null) curClass.Members.Add(member);
else
{
member.InFile = model;
member.IsPackageLevel = true;
model.Members.Add(member);
}
}
}
break;
case FlagType.Import:
if (prevToken.Text == features.importKey)
{
member = new MemberModel();
member.Name = LastStringToken(token, ".");
member.Type = token;
member.LineFrom = prevToken.Line;
member.LineTo = curToken.Line;
member.Flags = (token.EndsWith("*")) ? FlagType.Package : FlagType.Class;
if (flattenNextBlock > 0) // this declaration is inside a config block
member.Flags |= FlagType.Constant;
model.Imports.Add(member);
}
else if (prevToken.Text == features.importKeyAlt)
{
member = new MemberModel();
member.Name = LastStringToken(token, ".");
member.Type = token;
member.LineFrom = prevToken.Line;
member.LineTo = curToken.Line;
member.Flags = FlagType.Class | FlagType.Using;
model.Imports.Add(member);
}
break;
case FlagType.Class:
case FlagType.Struct:
if (curModifiers == FlagType.Extends)
{
if (curClass != null)
{
// typed Array & Proxy
if ((token == "Array" || token == "Proxy" || token == "flash.utils.Proxy")
&& lastComment != null && ASFileParserRegexes.ValidTypeName.IsMatch(lastComment))
{
Match m = ASFileParserRegexes.ValidTypeName.Match(lastComment);
if (m.Success)
{
token += "<" + m.Groups["type"].Value + ">";
lastComment = null;
}
}
curClass.ExtendsType = token;
if (inTypedef) context = FlagType.TypeDef;
}
}
else if (curModifiers == FlagType.Implements)
{
if (curClass != null)
{
if (curClass.Implements == null) curClass.Implements = new List<string>();
curClass.Implements.Add(token);
}
}
else if ((context == FlagType.Class && (prevToken.Text == "class" || prevToken.Text == "interface"))
|| (context == FlagType.Struct && prevToken.Text == "struct"))
{
if (curClass != null)
{
curClass.LineTo = (modifiersLine != 0) ? modifiersLine - 1 : curToken.Line - 1;
}
// check classname
int p = token.LastIndexOf('.');
if (p > 0)
{
if (version < 3)
{
model.Package = token.Substring(0, p);
token = token.Substring(p + 1);
}
else
{
//TODO Error: AS3 & haXe classes are qualified by their package declaration
}
}
if (model.PrivateSectionIndex != 0 && curToken.Line > model.PrivateSectionIndex)
curAccess = Visibility.Private;
curClass = new ClassModel();
curClass.InFile = model;
curClass.Comments = curComment;
var qtype = QualifiedName(model, token);
curClass.Type = qtype.Type;
curClass.Template = qtype.Template;
curClass.Name = qtype.Name;
curClass.Constructor = (haXe) ? "new" : token;
curClass.Flags = curModifiers;
curClass.Access = (curAccess == 0) ? features.classModifierDefault : curAccess;
curClass.Namespace = curNamespace;
curClass.LineFrom = (modifiersLine != 0) ? modifiersLine : curToken.Line;
curClass.LineTo = curToken.Line;
AddClass(model, curClass);
}
else
{
context = 0;
modifiers = 0;
}
break;
case FlagType.Enum:
if (inEnum && curClass != null && prevToken.Text != "enum")
{
member = new MemberModel();
member.Comments = curComment;
member.Name = token;
member.Flags = curModifiers | FlagType.Variable | FlagType.Enum | FlagType.Static;
member.Access = Visibility.Public;
member.Namespace = curNamespace;
member.LineFrom = member.LineTo = curToken.Line;
curClass.Members.Add(member);
//
curMember = member;
}
else
{
if (curClass != null)
{
curClass.LineTo = (modifiersLine != 0) ? modifiersLine - 1 : curToken.Line - 1;
}
curClass = new ClassModel();
curClass.InFile = model;
curClass.Comments = curComment;
var qtype = QualifiedName(model, token);
curClass.Type = qtype.Type;
curClass.Template = qtype.Template;
curClass.Name = qtype.Name;
curClass.Flags = curModifiers;
curClass.Access = (curAccess == 0) ? features.enumModifierDefault : curAccess;
curClass.Namespace = curNamespace;
curClass.LineFrom = (modifiersLine != 0) ? modifiersLine : curToken.Line;
curClass.LineTo = curToken.Line;
AddClass(model, curClass);
}
break;
case FlagType.TypeDef:
if (curModifiers == FlagType.Extends) // cached syntax
{
if (curClass != null)
{
curClass.ExtendsType = token;
}
}
else if (inTypedef && curClass != null && prevToken.Text != "typedef")
{
member = new MemberModel();
member.Comments = curComment;
member.Name = token;
member.Flags = curModifiers | FlagType.Variable | FlagType.Dynamic;
member.Access = Visibility.Public;
member.Namespace = curNamespace;
member.LineFrom = member.LineTo = curToken.Line;
curClass.Members.Add(member);
//
curMember = member;
}
else
{
if (curClass != null)
{
curClass.LineTo = (modifiersLine != 0) ? modifiersLine - 1 : curToken.Line - 1;
}
curClass = new ClassModel();
curClass.InFile = model;
curClass.Comments = curComment;
var qtype = QualifiedName(model, token);
curClass.Type = qtype.Type;
curClass.Template = qtype.Template;
curClass.Name = qtype.Name;
curClass.Flags = FlagType.Class | FlagType.TypeDef;
curClass.Access = (curAccess == 0) ? features.typedefModifierDefault : curAccess;
curClass.Namespace = curNamespace;
curClass.LineFrom = (modifiersLine != 0) ? modifiersLine : curToken.Line;
curClass.LineTo = curToken.Line;
AddClass(model, curClass);
}
break;
case FlagType.Abstract:
if (inAbstract && curClass != null && prevToken.Text != "abstract")
{
member = new MemberModel();
member.Comments = curComment;
member.Name = token;
member.Flags = curModifiers | FlagType.Variable | FlagType.Dynamic;
member.Access = Visibility.Public;
member.Namespace = curNamespace;
member.LineFrom = member.LineTo = curToken.Line;
curClass.Members.Add(member);
//
curMember = member;
}
else if (!inAbstract && curClass != null && (curClass.Flags & FlagType.Abstract) > 0)
{
if (prevToken.Text == "to") { /* can be casted to X */ }
else curClass.ExtendsType = curToken.Text;
}
else
{
if (curClass != null)
{
curClass.LineTo = (modifiersLine != 0) ? modifiersLine - 1 : curToken.Line - 1;
}
curClass = new ClassModel();
curClass.InFile = model;
curClass.Comments = curComment;
var qtype = QualifiedName(model, token);
curClass.Type = qtype.Type;
curClass.Template = qtype.Template;
curClass.Name = qtype.Name;
curClass.Flags = FlagType.Class | FlagType.Abstract;
curClass.Access = (curAccess == 0) ? features.typedefModifierDefault : curAccess;
curClass.Namespace = curNamespace;
curClass.LineFrom = (modifiersLine != 0) ? modifiersLine : curToken.Line;
curClass.LineTo = curToken.Line;
AddClass(model, curClass);
}
break;
case FlagType.Variable:
// haXe signatures: T -> T
if (haXe && curMember != null && curMember.Type != null
&& curMember.Type.EndsWith("->"))
{
curMember.Type += " " + token;
return false;
}
else
{
member = new MemberModel();
member.Comments = curComment;
member.Name = token;
if ((curModifiers & FlagType.Static) == 0) curModifiers |= FlagType.Dynamic;
member.Flags = curModifiers | FlagType.Variable;
member.Access = (curAccess == 0) ? features.varModifierDefault : curAccess;
member.Namespace = curNamespace;
member.LineFrom = (modifiersLine != 0) ? modifiersLine : curToken.Line;
member.LineTo = curToken.Line;
//
// method parameter
if (inParams && curMethod != null)
{
member.Flags = FlagType.Variable | FlagType.ParameterVar;
if (inEnum) member.Flags |= FlagType.Enum;
if (curMethod.Parameters == null) curMethod.Parameters = new List<MemberModel>();
member.Access = 0;
if (member.Name.Length > 0)
curMethod.Parameters.Add(member);
}
// class member
else if (curClass != null)
{
FlagType forcePublic = FlagType.Interface;
if (haXe) forcePublic |= FlagType.Intrinsic | FlagType.TypeDef;
if ((curClass.Flags & forcePublic) > 0)
member.Access = Visibility.Public;
curClass.Members.Add(member);
curClass.LineTo = member.LineTo;
}
// package member
else
{
member.InFile = model;
member.IsPackageLevel = true;
model.Members.Add(member);
}
//
curMember = member;
}
break;
case FlagType.Function:
member = new MemberModel();
member.Comments = curComment;
member.Name = token;
if ((curModifiers & FlagType.Static) == 0) curModifiers |= FlagType.Dynamic;
if ((curModifiers & (FlagType.Getter | FlagType.Setter)) == 0)
curModifiers |= FlagType.Function;
member.Flags = curModifiers;
member.Access = (curAccess == 0) ? features.methodModifierDefault : curAccess;
member.Namespace = curNamespace;
member.LineFrom = (modifiersLine != 0) ? modifiersLine : curToken.Line;
member.LineTo = curToken.Line;
//
if (curClass != null)
{
if (token == curClass.Constructor)
{
if (haXe) // constructor is: new()
{
member.Name = curClass.Name;
curClass.Constructor = curClass.Name;
}
member.Flags |= FlagType.Constructor;
if ((member.Flags & FlagType.Dynamic) > 0) member.Flags -= FlagType.Dynamic;
if (curAccess == 0) curAccess = Visibility.Public;
}
FlagType forcePublic = FlagType.Interface;
if (haXe) forcePublic |= FlagType.Intrinsic | FlagType.TypeDef;
if (curAccess == 0 && (curClass.Flags & forcePublic) > 0)
member.Access = Visibility.Public;
curClass.Members.Add(member);
curClass.LineTo = member.LineTo;
}
// package-level function
else
{
member.InFile = model;
member.IsPackageLevel = true;
model.Members.Add(member);
}
//
curMember = member;
break;
}
if (context != FlagType.Function && !inParams) curMethod = null;
curComment = null;
curNamespace = "internal";
curAccess = 0;
modifiers = 0;
modifiersLine = 0;
inGeneric = false;
tryPackage = false;
}
return false;
}
public MemberModel Search(string name, FlagType mask) {
foreach (MemberModel m in items)
if ((m.Name.Equals(name)) && ((m.Flags & mask) == mask)) return m;
return null;
}
private static MemberModel GetMember(MemberInfo info, FlagType baseFlags)
{
MemberModel member = new MemberModel();
member.Name = info.name.localName;
member.Flags = baseFlags;
member.Access = Visibility.Public;
member.Namespace = "public";
if (info.metadata != null && info.metadata.Count > 0)
{
var metadatas = member.MetaDatas;
foreach (var metaInfo in info.metadata)
{
if (metaInfo.name == "__go_to_definition_help") continue;
var meta = new ASMetaData(metaInfo.name);
var rawParams = new StringBuilder();
meta.Params = new Dictionary<string, string>(metaInfo.Count);
foreach (var entry in metaInfo)
{
if (entry.Length != 2) continue;
meta.Params[entry[0]] = entry[1];
if (rawParams.Length > 0) rawParams.Append(",");
rawParams.Append(entry[0] + "=\"" + entry[1] + "\"");
}
meta.RawParams = rawParams.ToString();
if (metadatas == null) metadatas = new List<ASMetaData>(info.metadata.Count);
metadatas.Add(meta);
}
member.MetaDatas = metadatas;
}
if (info is SlotInfo)
{
SlotInfo slot = info as SlotInfo;
member.Flags |= FlagType.Variable;
if (slot.kind == TraitMember.Const) member.Flags |= FlagType.Constant;
if (slot.value is Namespace)
{
member.Flags |= FlagType.Namespace;
member.Value = '"' + (slot.value as Namespace).uri + '"';
}
member.Type = ImportType(slot.type);
}
else if (info is MethodInfo)
{
switch (info.kind)
{
case TraitMember.Setter: member.Flags |= FlagType.Setter; break;
case TraitMember.Getter: member.Flags |= FlagType.Getter; break;
default: member.Flags |= FlagType.Function; break;
}
MethodInfo method = info as MethodInfo;
QName type = method.returnType;
member.Type = ImportType(type);
member.Parameters = new List<MemberModel>();
int n = method.paramTypes.Length;
int defaultValues = (method.optionalValues != null) ? n - method.optionalValues.Length : n;
for (int i = 0; i < n; i++)
{
MemberModel param = new MemberModel();
param.Flags = FlagType.ParameterVar | FlagType.Variable;
param.Name = (!inSWF && method.paramNames != null) ? method.paramNames[i] : "param" + i;
type = method.paramTypes[i];
param.Type = ImportType(type);
if (param.Name[0] == '.' && param.Type == "Array") // ...rest
{
param.Type = "";
}
else if (i >= defaultValues)
{
SetDefaultValue(param, method.optionalValues[i - defaultValues]);
}
member.Parameters.Add(param);
}
}
else
{
member = null;
}
return member;
}
static public void AddMembersGrouped(TreeNodeCollection tree, MemberList members)
{
FlagType[] typePriority = new FlagType[] { FlagType.Constructor, FlagType.Function, FlagType.Getter | FlagType.Setter, FlagType.Variable, FlagType.Constant };
Dictionary<FlagType, List<MemberModel>> typeGroups = new Dictionary<FlagType, List<MemberModel>>();
FlagType type;
List<MemberModel> groupList;
MemberTreeNode node = null;
foreach (MemberModel member in members)
{
// member type
if ((member.Flags & FlagType.Constant) > 0)
type = FlagType.Constant;
else if ((member.Flags & FlagType.Variable) > 0)
type = FlagType.Variable;
else if ((member.Flags & (FlagType.Getter | FlagType.Setter)) > 0)
type = (FlagType.Getter | FlagType.Setter);
else if ((member.Flags & FlagType.Constructor) > 0)
type = FlagType.Constructor;
else type = FlagType.Function;
// group
if (!typeGroups.TryGetValue(type, out groupList))
{
groupList = new List<MemberModel>();
typeGroups.Add(type, groupList);
}
groupList.Add(member);
}
for (int i = 0, count = typePriority.Length; i < count; i++)
{
type = typePriority[i];
if (typeGroups.TryGetValue(type, out groupList))
{
if (groupList.Count == 0)
continue;
groupList.Sort();
TreeNode groupNode = new TreeNode(type.ToString(), ICON_FOLDER_CLOSED, ICON_FOLDER_OPEN);
int img;
foreach (MemberModel member in groupList)
{
img = GetIcon(member.Flags, member.Access);
node = new MemberTreeNode(member, img);
groupNode.Nodes.Add(node);
}
if (type != FlagType.Constructor) groupNode.Expand();
tree.Add(groupNode);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Flags"/> struct.
/// </summary>
/// <param name="type">The type.</param>
public Flags(FlagType type)
{
this.Type = type;
this.ID = Convert.ToUInt32(this.Type.GetHashCode());
}
public MemberList MultipleSearch(string name, FlagType mask) {
MemberList result = new MemberList();
foreach (MemberModel m in items)
if ((m.Name.Equals(name)) && ((m.Flags & mask) == mask)) result.Add(m);
return result;
}
public void ParseSrc(FileModel fileModel, string ba, bool allowBaReExtract)
{
//TraceManager.Add("Parsing " + Path.GetFileName(fileModel.FileName));
model = fileModel;
model.OutOfDate = false;
model.CachedModel = false;
if (model.Context != null) features = model.Context.Features;
if (features != null && features.hasModules)
model.Module = Path.GetFileNameWithoutExtension(model.FileName);
// pre-filtering
if (allowBaReExtract && model.HasFiltering && model.Context != null)
ba = model.Context.FilterSource(fileModel.FileName, ba);
model.InlinedIn = null;
model.InlinedRanges = null;
// language features
model.Imports.Clear();
model.Classes.Clear();
model.Members.Clear();
model.Namespaces.Clear();
model.Regions.Clear();
model.PrivateSectionIndex = 0;
model.Package = "";
model.MetaDatas = null;
// state
int len = ba.Length;
if (len < 0)
return;
int i = 0;
line = 0;
// when parsing cache file including multiple files
resetParser:
char c1;
char c2;
int matching = 0;
bool isInString = false;
int inString = 0;
int braceCount = 0;
bool inCode = true;
// comments
char[] commentBuffer = new char[COMMENTS_BUFFER];
int commentLength = 0;
lastComment = null;
curComment = null;
// tokenisation
tryPackage = true;
hasPackageSection = false;
haXe = model.haXe;
TypeCommentUtils.ObjectType = haXe ? "Dynamic" : "Object";
version = (haXe) ? 4 : 1;
curToken = new Token();
prevToken = new Token();
int tokPos = 0;
int tokLine = 0;
curMethod = null;
curMember = null;
valueKeyword = null;
valueMember = null;
curModifiers = 0;
curNamespace = "internal";
curAccess = 0;
char[] buffer = new char[TOKEN_BUFFER];
int length = 0;
char[] valueBuffer = new char[VALUE_BUFFER];
int valueLength = 0;
int paramBraceCount = 0;
int paramTempCount = 0;
int paramParCount = 0;
int paramSqCount = 0;
bool hadWS = true;
bool hadDot = false;
inParams = false;
inEnum = false;
inTypedef = false;
inAbstract = false;
inValue = false;
inConst = false;
inType = false;
inGeneric = false;
inAnonType = false;
bool addChar = false;
int evalToken = 0;
//bool evalKeyword = true;
context = 0;
modifiers = 0;
foundColon = false;
bool handleDirectives = features.hasDirectives || cachedPath != null;
bool inlineDirective = false;
while (i < len)
{
c1 = ba[i++];
isInString = (inString > 0);
/* MATCH COMMENTS / STRING LITERALS */
switch (matching)
{
// look for comment block/line and preprocessor commands
case 0:
if (!isInString)
{
// new comment
if (c1 == '/' && i < len)
{
c2 = ba[i];
if (c2 == '/')
{
// Check if this this is a /// comment
if (i + 1 < len && ba[i + 1] == '/')
{
// This is a /// comment
matching = 4;
isBlockComment = true;
i++;
}
else
{
// This is a regular comment
matching = 1;
isBlockComment = false;
}
inCode = false;
i++;
continue;
}
else if (c2 == '*')
{
isBlockComment = (i + 1 < len && ba[i + 1] == '*');
matching = 2;
inCode = false;
i++;
while (i < len - 1)
{
c2 = ba[i];
if (c2 == '*' && ba[i + 1] != '/') i++;
else break;
}
continue;
}
}
// don't look for comments in strings
else if (c1 == '"')
{
isInString = true;
inString = 1;
}
else if (c1 == '\'')
{
isInString = true;
inString = 2;
}
// preprocessor statements
else if (c1 == '#' && handleDirectives)
{
int ls = i - 2;
inlineDirective = false;
while (ls > 0)
{
c2 = ba[ls--];
if (c2 == 10 || c2 == 13) break;
else if (c2 > 32) { inlineDirective = true; break; }
}
c2 = ba[i];
if (i < 2 || ba[i - 2] < 33 && c2 >= 'a' && c2 <= 'z')
{
matching = 3;
inCode = false;
continue;
}
}
}
// end of string
else if (isInString)
{
if (c1 == '\\') { i++; continue; }
else if (c1 == 10 || c1 == 13) inString = 0;
else if ((inString == 1) && (c1 == '"')) inString = 0;
else if ((inString == 2) && (c1 == '\'')) inString = 0;
// extract "include" declarations
if (inString == 0 && length == 7 && context == 0)
{
string token = new string(buffer, 0, length);
if (token == "include")
{
string inc = ba.Substring(tokPos, i - tokPos);
if (model.MetaDatas == null) model.MetaDatas = new List<ASMetaData>();
ASMetaData meta = new ASMetaData("Include");
meta.ParseParams(inc);
model.MetaDatas.Add(meta);
}
}
}
break;
// skip commented line
case 1:
if (c1 == 10 || c1 == 13)
{
// ignore single comments
commentLength = 0;
inCode = true;
matching = 0;
}
break;
// skip commented block
case 2:
if (c1 == '*')
{
bool end = false;
while (i < len)
{
c2 = ba[i];
if (c2 == '\\') { i++; continue; }
if (c2 == '/')
{
end = true;
break;
}
else if (c2 == '*') i++;
else break;
}
if (end)
{
lastComment = (commentLength > 0) ? new string(commentBuffer, 0, commentLength) : null;
// TODO parse for TODO statements?
commentLength = 0;
inCode = true;
matching = 0;
i++;
continue;
}
}
break;
// directive/preprocessor statement
case 3:
if (c1 == 10 || c1 == 13 || (inlineDirective && c1 <= 32))
{
if (commentLength > 0)
{
string directive = new string(commentBuffer, 0, commentLength);
if (directive.StartsWith("if"))
{
inCode = true;
}
else if (directive.StartsWith("else"))
{
inCode = true;
}
else if (directive.StartsWith("end"))
{
inCode = true; // directive end
matching = 0;
}
else inCode = true;
// FD cache custom directive
if (cachedPath != null && directive.StartsWith("file-cache "))
{
// parsing done!
FinalizeModel();
// next model
string realFile = directive.Substring(11);
FileModel newModel = model.Context != null ? model.Context.CreateFileModel(realFile) : new FileModel(realFile);
newModel.LastWriteTime = cacheLastWriteTime;
newModel.CachedModel = true;
if (features != null && features.hasModules)
newModel.Module = Path.GetFileNameWithoutExtension(realFile);
haXe = newModel.haXe;
if (!cachedPath.HasFile(realFile) && File.Exists(realFile))
{
newModel.OutOfDate = (File.GetLastWriteTime(realFile) > cacheLastWriteTime);
cachedPath.AddFile(newModel);
}
model = newModel;
goto resetParser; // loop
}
}
else inCode = true;
commentLength = 0;
matching = 0;
}
break;
// We are inside a /// comment
case 4:
{
bool end = false;
bool skipAhead = false;
// See if we just ended a line
if (2 <= i && (ba[i - 2] == 10 || ba[i - 2] == 13))
{
// Check ahead to the next line, see if it has a /// comment on it too.
// If it does, we want to continue the comment with that line. If it
// doesn't, then this comment is finished and we will set end to true.
for (int j = i + 1; j < len; ++j)
{
// Skip whitespace
char twoBack = ba[j - 2];
if (' ' != twoBack && '\t' != twoBack)
{
if ('/' == twoBack && '/' == ba[j - 1] && '/' == ba[j])
{
// There is a comment ahead. Move up to it so we can gather the
// rest of the comment
i = j + 1;
skipAhead = true;
break;
}
else
{
// Not a comment! We're done!
end = true;
break;
}
}
}
}
if (end)
{
// The comment is over and we want to write it out
lastComment = (commentLength > 0) ? new string(commentBuffer, 0, commentLength).Trim() : null;
commentLength = 0;
inCode = true;
matching = 0;
// Back up i so we can start gathering comments from right after the line break
--i;
continue;
}
if (skipAhead)
{
// We just hit another /// and are skipping up to right after it.
continue;
}
break;
}
}
/* LINE/COLUMN NUMBER */
if (c1 == 10 || c1 == 13)
{
if (cachedPath == null) line++; // cache breaks line count
if (c1 == 13 && i < len && ba[i] == 10) i++;
}
/* SKIP CONTENT */
if (!inCode)
{
// store comments
if (matching == 2 || (matching == 3 && handleDirectives) || matching == 4)
{
if (commentLength < COMMENTS_BUFFER) commentBuffer[commentLength++] = c1;
}
else if (matching == 1 && (c1 == '#' || c1 == '{'))
{
commentBuffer[commentLength++] = c1;
while (i < len)
{
c2 = ba[i];
if (commentLength < COMMENTS_BUFFER) commentBuffer[commentLength++] = c2;
if (c2 == 10 || c2 == 13)
break;
i++;
}
string comment = new String(commentBuffer, 0, commentLength);
Match match = ASFileParserRegexes.Region.Match(comment);
if (match.Success)
{
string regionName = match.Groups["name"].Value.Trim();
MemberModel region = new MemberModel(regionName, String.Empty, FlagType.Declaration, Visibility.Default);
region.LineFrom = region.LineTo = line;
model.Regions.Add(region);
}
}
continue;
}
else if (isInString)
{
// store parameter default value
if (inValue && valueLength < VALUE_BUFFER)
valueBuffer[valueLength++] = c1;
continue;
}
if (braceCount > 0 && !inValue)
{
if (c1 == '/')
{
LookupRegex(ref ba, ref i);
}
else if (c1 == '}')
{
lastComment = null;
braceCount--;
if (braceCount == 0 && curMethod != null)
{
curMethod.LineTo = line;
curMethod = null;
}
}
else if (c1 == '{') braceCount++;
// escape next char
else if (c1 == '\\') i++;
continue;
}
/* PARSE DECLARATION VALUES/TYPES */
if (inValue)
{
bool stopParser = false;
bool valueError = false;
if (inType && !inAnonType && !inGeneric && !Char.IsLetterOrDigit(c1) && ".{}-><".IndexOf(c1) < 0)
{
inType = false;
inValue = false;
inGeneric = false;
valueLength = 0;
length = 0;
context = 0;
}
else if (c1 == '{')
{
if (!inType || valueLength == 0 || valueBuffer[valueLength - 1] == '<' || paramBraceCount > 0)
{
paramBraceCount++;
stopParser = true;
}
}
else if (c1 == '}')
{
if (paramBraceCount > 0) { paramBraceCount--; stopParser = true; }
else valueError = true;
}
else if (c1 == '(')
{
paramParCount++;
stopParser = true;
}
else if (c1 == ')')
{
if (paramParCount > 0) { paramParCount--; stopParser = true; }
else valueError = true;
}
else if (c1 == '[') paramSqCount++;
else if (c1 == ']')
{
if (paramSqCount > 0) { paramSqCount--; stopParser = true; }
else valueError = true;
}
else if (c1 == '<')
{
if (i > 1 && ba[i - 2] == '<') paramTempCount = 0; // a << b
else
{
if (inType) inGeneric = true;
paramTempCount++;
}
}
else if (c1 == '>')
{
if (ba[i - 2] == '-') { /*haxe method signatures*/ }
else if (paramTempCount > 0)
{
paramTempCount--;
stopParser = true;
}
else valueError = true;
}
else if (c1 == '/')
{
int i0 = i;
if (LookupRegex(ref ba, ref i) && valueLength < VALUE_BUFFER - 3)
{
valueBuffer[valueLength++] = '/';
for (; i0 < i; i0++)
if (valueLength < VALUE_BUFFER - 2) valueBuffer[valueLength++] = ba[i0];
valueBuffer[valueLength++] = '/';
continue;
}
}
else if (inValue && (inParams || inType || inConst)
&& c1 == '/' && valueLength == 0) // lookup native regex
{
int itemp = i;
valueBuffer[valueLength++] = '/';
while (valueLength < VALUE_BUFFER && i < len)
{
c1 = ba[i++];
if (c1 == '\n' || c1 == '\r')
{
valueLength = 0;
i = itemp;
break;
}
valueBuffer[valueLength++] = c1;
if (c1 == '\\' && i < len)
{
c1 = ba[i++];
valueBuffer[valueLength++] = c1;
}
else if (c1 == '/') break;
}
}
else if ((c1 == ':' || c1 == ',') && paramBraceCount > 0) stopParser = true;
// end of value
if ((valueError || (!stopParser && paramBraceCount == 0 && paramParCount == 0 && paramSqCount == 0 && paramTempCount == 0))
&& (c1 == ',' || c1 == ';' || c1 == '}' || c1 == '\r' || c1 == '\n' || (inParams && c1 == ')') || inType))
{
if (!inType && (!inValue || c1 != ','))
{
length = 0;
context = 0;
}
inValue = false;
inGeneric = false;
//if (valueLength < VALUE_BUFFER) valueBuffer[valueLength++] = c1;
}
// in params, store the default value
else if ((inParams || inType || inConst) && valueLength < VALUE_BUFFER)
{
if (c1 <= 32)
{
if (valueLength > 0 && valueBuffer[valueLength - 1] != ' ')
valueBuffer[valueLength++] = ' ';
}
else valueBuffer[valueLength++] = c1;
}
// detect keywords
if (!Char.IsLetterOrDigit(c1))
{
// escape next char
if (c1 == '\\' && i < len)
{
c1 = ba[i++];
if (valueLength < VALUE_BUFFER) valueBuffer[valueLength++] = c1;
continue;
}
if (stopParser) continue;
else if (valueError && c1 == ')') inValue = false;
else if (inType && inGeneric && (c1 == '<' || c1 == '.')) continue;
else if (inAnonType) continue;
hadWS = true;
}
}
// store type / parameter value
if (!inValue && valueLength > 0)
{
string param = /*(valueBuffer[0] == '{' && valueBuffer[0] != '[') ? "..."
:*/ new string(valueBuffer, 0, valueLength);
// get text before the last keyword found
if (valueKeyword != null)
{
int p = param.LastIndexOf(valueKeyword.Text);
if (p > 0) param = param.Substring(0, p).TrimEnd();
}
if (curMember == null)
{
if (inType)
{
prevToken.Text = curToken.Text;
prevToken.Line = curToken.Line;
prevToken.Position = curToken.Position;
curToken.Text = param;
curToken.Line = tokLine;
curToken.Position = tokPos;
EvalToken(true, true/*false*/, i - 1 - valueLength);
evalToken = 0;
}
}
else if (inType)
{
foundColon = false;
if (haXe)
{
if (param.EndsWith("}") || param.Contains(">"))
{
param = ASFileParserRegexes.Spaces.Replace(param, "");
param = param.Replace(",", ", ");
param = param.Replace("->", " -> ");
}
}
curMember.Type = param;
}
// AS3 const or method parameter's default value
else if (version > 2 && (curMember.Flags & FlagType.Variable) > 0)
{
if (inParams || inConst) curMember.Value = param;
curMember.LineTo = line;
if (c1 == '\r' || c1 == '\n') curMember.LineTo--;
if (inConst && c1 != ',')
{
context = 0;
inConst = false;
}
}
//
valueLength = 0;
valueMember = null;
if (!inParams && !(inConst && context != 0) && c1 != '{') continue;
else length = 0;
}
/* TOKENIZATION */
// whitespace
if (c1 <= 32)
{
hadWS = true;
continue;
}
// a dot can be in an identifier
if (c1 == '.')
{
if (length > 0 || (inParams && version == 3))
{
hadWS = false;
hadDot = true;
addChar = true;
if (!inValue && context == FlagType.Variable && !foundColon)
{
bool keepContext = inParams && (length == 0 || buffer[0] == '.');
if (!keepContext) context = 0;
}
}
else continue;
}
else
{
// should we evaluate the token?
if (hadWS && !hadDot && !inGeneric && length > 0)
{
evalToken = 1;
}
hadWS = false;
hadDot = false;
bool shortcut = true;
// valid char for keyword
if (c1 >= 'a' && c1 <= 'z')
{
addChar = true;
}
else
{
// valid chars for identifiers
if (c1 >= 'A' && c1 <= 'Z')
{
addChar = true;
}
else if (c1 == '$' || c1 == '_')
{
addChar = true;
}
else if (length > 0)
{
if (c1 >= '0' && c1 <= '9')
{
addChar = true;
}
else if (c1 == '*' && context == FlagType.Import)
{
addChar = true;
}
// AS3/haXe generics
else if (features.hasGenerics && c1 == '<')
{
if (!inValue && i > 2 && length > 1 && i < len - 3
&& Char.IsLetterOrDigit(ba[i - 3]) && (Char.IsLetter(ba[i]) || (haXe && ba[i] == '{'))
&& (Char.IsLetter(buffer[0]) || buffer[0] == '_'))
{
if (curMember == null)
{
evalToken = 0;
if (inGeneric) paramTempCount++;
else
{
paramTempCount = 1;
inGeneric = true;
}
addChar = true;
}
else
{
evalToken = 0;
inGeneric = true;
inValue = true;
inType = true;
inAnonType = false;
valueLength = 0;
for (int j = 0; j < length; j++)
valueBuffer[valueLength++] = buffer[j];
valueBuffer[valueLength++] = c1;
length = 0;
paramBraceCount = 0;
paramParCount = 0;
paramSqCount = 0;
paramTempCount = 1;
continue;
}
}
}
else if (inGeneric && (c1 == ',' || c1 == '.' || c1 == '-' || c1 == '>' || c1 == ':'))
{
hadWS = false;
hadDot = false;
evalToken = 0;
if (!inValue)
{
addChar = true;
if (c1 == '>' && inGeneric)
{
if (paramTempCount > 0) paramTempCount--;
if (paramTempCount == 0 && paramBraceCount == 0
&& paramSqCount == 0 && paramParCount == 0) inGeneric = false;
}
}
}
else
{
evalToken = 2;
shortcut = false;
}
}
// star is valid in import statements
else if (c1 == '*' && version == 3)
{
addChar = true;
}
// conditional haXe parameter
else if (c1 == '?' && haXe && inParams && length == 0)
{
addChar = true;
}
else shortcut = false;
}
// eval this word
if (evalToken > 0)
{
prevToken.Text = curToken.Text;
prevToken.Line = curToken.Line;
prevToken.Position = curToken.Position;
curToken.Text = new string(buffer, 0, length);
curToken.Line = tokLine;
curToken.Position = tokPos;
EvalToken(!inValue, (c1 != '=' && c1 != ','), i - 1 - length);
length = 0;
evalToken = 0;
}
if (!shortcut)
// start of block
if (c1 == '{')
{
if (context == FlagType.Package || context == FlagType.Class) // parse package/class block
{
context = 0;
}
else if (context == FlagType.Enum) // parse enum block
{
if (curClass != null && (curClass.Flags & FlagType.Enum) > 0)
inEnum = true;
else
{
context = 0;
curModifiers = 0;
braceCount++; // ignore block
}
}
else if (context == FlagType.TypeDef) // parse typedef block
{
if (curClass != null && (curClass.Flags & FlagType.TypeDef) > 0)
{
inTypedef = true;
if (i < len && ba[i] == '>')
{
buffer[0] = 'e'; buffer[1] = 'x'; buffer[2] = 't'; buffer[3] = 'e'; buffer[4] = 'n'; buffer[5] = 'd'; buffer[6] = 's';
length = 7;
context = FlagType.Class;
}
}
else
{
context = 0;
curModifiers = 0;
braceCount++; // ignore block
}
}
else if (context == FlagType.Abstract) // parse abstract block
{
if (curClass != null && (curClass.Flags & FlagType.Abstract) > 0)
inAbstract = true;
else
{
context = 0;
curModifiers = 0;
braceCount++; // ignore block
}
}
else if (foundColon && haXe && length == 0) // copy haXe anonymous type
{
inValue = true;
inType = true;
inAnonType = true;
valueLength = 0;
valueBuffer[valueLength++] = c1;
paramBraceCount = 1;
paramParCount = 0;
paramSqCount = 0;
paramTempCount = 0;
continue;
}
else if (foundConstant) // start config block
{
flattenNextBlock++;
foundConstant = false;
context = 0;
}
else if (ScriptMode) // not in a class, parse if/for/while/do blocks
{
context = 0;
}
else braceCount++; // ignore block
}
// end of block
else if (c1 == '}')
{
curComment = null;
foundColon = false;
foundConstant = false;
if (flattenNextBlock > 0) // content of this block was parsed
{
flattenNextBlock--;
}
// outside of a method, the '}' ends the current class
else if (curClass != null)
{
if (curClass != null) curClass.LineTo = line;
curClass = null;
inEnum = false;
inTypedef = false;
inAbstract = false;
}
else
{
if (hasPackageSection && model.PrivateSectionIndex == 0) model.PrivateSectionIndex = line + 1;
}
}
// member type declaration
else if (c1 == ':' && !inValue && !inGeneric)
{
foundColon = curMember != null && curMember.Type == null;
// recognize compiler config block
if (!foundColon && braceCount == 0
&& i < len - 2 && ba[i] == ':' && Char.IsLetter(ba[i + 1]))
foundConstant = true;
}
// next variable declaration
else if (c1 == ',')
{
if ((context == FlagType.Variable || context == FlagType.TypeDef) && curMember != null)
{
curAccess = curMember.Access;
foundKeyword = FlagType.Variable;
foundColon = false;
lastComment = null;
}
else if (context == FlagType.Class && prevToken.Text == "implements")
{
curToken.Text = "implements";
foundKeyword = FlagType.Implements;
}
}
else if (c1 == '(')
{
if (!inValue && context == FlagType.Variable && curToken.Text != "catch" && (!haXe || curToken.Text != "for"))
if (haXe && curMember != null && valueLength == 0) // haXe properties
{
curMember.Flags -= FlagType.Variable;
curMember.Flags |= FlagType.Getter | FlagType.Setter;
context = FlagType.Function;
}
else context = 0;
// beginning of method parameters
if (context == FlagType.Function)
{
context = FlagType.Variable;
inParams = true;
inGeneric = false;
if (valueMember != null && curMember == null)
{
valueLength = 0;
//valueMember.Flags -= FlagType.Variable; ???
valueMember.Flags = FlagType.Function;
curMethod = curMember = valueMember;
valueMember = null;
}
else if (curMember == null)
{
context = FlagType.Function;
if ((curModifiers & FlagType.Getter) > 0)
{
curModifiers -= FlagType.Getter;
EvalToken(true, false, i);
curMethod = curMember;
context = FlagType.Variable;
}
else if ((curModifiers & FlagType.Setter) > 0)
{
curModifiers -= FlagType.Setter;
EvalToken(true, false, i);
curMethod = curMember;
context = FlagType.Variable;
}
else
{
inParams = false;
context = 0;
}
}
else
{
curMethod = curMember;
}
}
// an Enum value with parameters
else if (inEnum && curToken != null)
{
context = FlagType.Variable;
inParams = true;
curMethod = curMember ?? new MemberModel();
curMethod.Name = curToken.Text;
curMethod.Flags = curModifiers | FlagType.Function | FlagType.Static;
curMethod.Parameters = new List<MemberModel>();
//
if (curClass != null && curMember == null) curClass.Members.Add(curMethod);
}
// a TypeDef method with parameters
else if (inTypedef && curToken != null)
{
context = FlagType.Variable;
inParams = true;
curMethod = curMember ?? new MemberModel();
curMethod.Name = curToken.Text;
curMethod.Flags = curModifiers | FlagType.Function;
curMethod.Parameters = new List<MemberModel>();
//
if (curClass != null && curMember == null) curClass.Members.Add(curMethod);
}
// an Abstract "opaque type"
else if (context == FlagType.Abstract && prevToken.Text == "abstract")
{
foundKeyword = FlagType.Class;
curModifiers = FlagType.Extends;
}
else if (curMember == null && curToken.Text != "catch" && (!haXe || curToken.Text != "for"))
{
context = 0;
inGeneric = false;
}
}
// end of statement
else if (c1 == ';')
{
context = (inEnum) ? FlagType.Enum : 0;
inGeneric = false;
modifiers = 0;
inParams = false;
curMember = null;
}
// end of method parameters
else if (c1 == ')' && inParams)
{
context = 0;
if (inEnum) context = FlagType.Enum;
else if (inTypedef) context = FlagType.TypeDef;
modifiers = 0;
inParams = false;
curMember = curMethod;
}
// skip value of a declared variable
else if (c1 == '=')
{
if (context == FlagType.Variable || (context == FlagType.Enum && inEnum))
{
if (!inValue && curMember != null)
{
inValue = true;
inConst = (curMember.Flags & FlagType.Constant) > 0;
inType = false;
inGeneric = false;
paramBraceCount = 0;
paramParCount = 0;
paramSqCount = 0;
paramTempCount = 0;
valueLength = 0;
valueMember = curMember;
}
}
}
// metadata
else if (!inValue && c1 == '[')
{
if (version == 3) LookupMeta(ref ba, ref i);
else if (features.hasCArrays && curMember != null && curMember.Type != null)
{
if (ba[i] == ']') curMember.Type = features.CArrayTemplate + "@" + curMember.Type;
}
}
// haXe signatures: T -> T -> T
else if (haXe && c1 == '-' && curMember != null)
{
if (ba[i] == '>' && curMember.Type != null)
{
curMember.Type += " ->";
foundColon = true;
}
}
// escape next char
else if (c1 == '\\') { i++; continue; }
// literal regex
else if (c1 == '/' && version == 3)
{
if (LookupRegex(ref ba, ref i))
continue;
}
}
// put in buffer
if (addChar)
{
if (length < TOKEN_BUFFER) buffer[length++] = c1;
if (length == 1)
{
tokPos = i - 1;
tokLine = line;
}
addChar = false;
}
}
// parsing done!
FinalizeModel();
// post-filtering
if (cachedPath == null && model.HasFiltering && model.Context != null)
model.Context.FilterSource(model);
// Debug.WriteLine("out model: " + model.GenerateIntrinsic(false));
}
private MemberList SelectMembers(MemberList list, FlagType mask)
{
MemberList filtered = new MemberList();
Visibility acc = Visibility.Public | Visibility.Internal;
//MemberModel lastAdded = null;
foreach (MemberModel item in list)
if ((item.Access & acc) > 0 && (item.Flags & mask) > 0)
{
//if (lastAdded != null && lastAdded.Name == item.Name) continue;
//lastAdded = item;
filtered.Add(item);
}
filtered.Sort();
return filtered;
}
private static MemberModel NewMember(string contextToken, MemberModel calledFrom, FlagType kind)
{
return NewMember(contextToken, calledFrom, kind, GetDefaultVisibility());
}
private static MemberList GetMembers(List<MemberInfo> abcMembers, FlagType baseFlags, QName instName)
{
MemberList list = new MemberList();
string package = instName.uri;
string protect = instName.ToString();
foreach (MemberInfo info in abcMembers)
{
MemberModel member = GetMember(info, baseFlags);
if (member == null) continue;
string uri = info.name.uri ?? "";
if (uri.Length > 0)
{
if (uri == "private" || package == "private")
{
continue;
}
else if (uri == protect)
{
member.Access = Visibility.Protected;
member.Namespace = "protected";
}
else if (uri == package)
{
member.Access = Visibility.Internal;
member.Namespace = "internal";
}
else if (uri == "http://adobe.com/AS3/2006/builtin")
{
member.Access = Visibility.Public;
member.Namespace = "AS3";
}
else if (uri == "http://www.adobe.com/2006/flex/mx/internal")
{
continue;
}
else if (uri == "http://www.adobe.com/2006/actionscript/flash/proxy")
{
member.Access = Visibility.Public;
member.Namespace = "flash_proxy";
}
else if (uri == "http://www.adobe.com/2006/actionscript/flash/objectproxy")
{
member.Access = Visibility.Public;
member.Namespace = "object_proxy";
}
else // unknown namespace
{
member.Access = Visibility.Public;
member.Namespace = "internal";
}
}
if (thisDocs != null) GetMemberDoc(member);
list.Add(member);
}
return list;
}
static private MemberModel FindLatest(FlagType match, Visibility visi, ClassModel inClass)
{
return FindLatest(match, visi, inClass, true, true);
}
private static MemberModel GetMember(MemberInfo info, FlagType baseFlags)
{
MemberModel member = new MemberModel();
member.Name = info.name.localName;
member.Flags = baseFlags;
member.Access = Visibility.Public;
member.Namespace = "public";
if (info is SlotInfo)
{
SlotInfo slot = info as SlotInfo;
member.Flags |= FlagType.Variable;
if (slot.kind == TraitMember.Const) member.Flags |= FlagType.Constant;
if (slot.value is Namespace)
{
member.Flags |= FlagType.Namespace;
member.Value = '"' + (slot.value as Namespace).uri + '"';
}
member.Type = ImportType(slot.type);
}
else if (info is MethodInfo)
{
switch (info.kind)
{
case TraitMember.Setter: member.Flags |= FlagType.Setter; break;
case TraitMember.Getter: member.Flags |= FlagType.Getter; break;
default: member.Flags |= FlagType.Function; break;
}
MethodInfo method = info as MethodInfo;
QName type = method.returnType;
member.Type = ImportType(type);
member.Parameters = new List<MemberModel>();
int n = method.paramTypes.Length;
int defaultValues = (method.optionalValues != null) ? n - method.optionalValues.Length : n;
for (int i = 0; i < n; i++)
{
MemberModel param = new MemberModel();
param.Flags = FlagType.ParameterVar | FlagType.Variable;
param.Name = (!inSWF && method.paramNames != null) ? method.paramNames[i] : "param" + i;
type = method.paramTypes[i];
param.Type = ImportType(type);
if (param.Name[0] == '.' && param.Type == "Array") // ...rest
{
param.Type = "";
}
else if (i >= defaultValues)
{
SetDefaultValue(param, method.optionalValues[i - defaultValues]);
}
member.Parameters.Add(param);
}
}
else
{
member = null;
}
return member;
}
/// <summary>
/// Simply checks the given flag combination if they contain a specific flag
/// </summary>
public static bool CheckFlag(FlagType flags, FlagType checkForThisFlag)
{
return (flags & checkForThisFlag) == checkForThisFlag;
}
/// <summary>
/// Cunstructor for normal storyboard commands
/// </summary>
/// <param name="easing"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="startParams"></param>
/// <param name="endParams"></param>
public Flag(FlagType flagType, int startTime, int endTime)
: base(startTime)
{
this.flagType = flagType;
this.endTime = endTime;
}
