internal JSArgumentField AddNewArgumentField(String name) { JSArgumentField result = new JSArgumentField(name, Missing.Value); AddField(result); return(result); }
internal CatchScope(ActivationObject parent, Context argContext, JSParser parser) : base(parent, argContext, parser) { // get the name of the catch variable m_name = Context.Code; // add it to the catch-scope's name table JSVariableField field = new JSArgumentField(m_name, null); NameTable[m_name] = field; FieldTable.Add(field); }
internal bool IsArgumentTrimmable(JSArgumentField targetArgumentField) { // walk backward until we either find the given argument field or the // first parameter that is referenced. // If we find the argument field, then we can trim it because there are no // referenced parameters after it. // if we find a referenced argument, then the parameter is not trimmable. JSArgumentField argumentField = null; for (int index = m_parameterDeclarations.Length - 1; index >= 0; --index) { argumentField = m_parameterDeclarations[index].Field; if (argumentField != null && (argumentField == targetArgumentField || argumentField.IsReferenced)) { break; } } // if the argument field we landed on is the same as the target argument field, // then we found the target argument BEFORE we found a referenced parameter. Therefore // the argument can be trimmed. return(argumentField == targetArgumentField); }
public override string ToCode(ToCodeFormat format) { StringBuilder sb = new StringBuilder(); if (!Parser.Settings.MinifyCode || !HideFromOutput) { if (LeftHandFunctionExpression) { sb.Append('('); } if (format != ToCodeFormat.NoFunction) { sb.Append("function"); if (m_identifier != null) { // we don't want to show the name for named function expressions where the // name is never referenced. Don't use IsReferenced because that will always // return true for function expressions. Since we really only want to know if // the field name is referenced, check the refcount directly on the field. // also output the function expression name if this is debug mode if (FunctionType != FunctionType.Expression || !(Parser.Settings.RemoveFunctionExpressionNames && Parser.Settings.IsModificationAllowed(TreeModifications.RemoveFunctionExpressionNames)) || m_variableField.RefCount > 0) { sb.Append(' '); sb.Append(m_identifier.ToCode()); } } } sb.Append('('); if (m_parameterDeclarations.Length > 0) { // figure out the last referenced argument so we can skip // any that aren't actually referenced int lastRef = m_parameterDeclarations.Length - 1; // if we're not known at compile time, then we can't leave off unreferenced parameters // (also don't leave things off if we're not hypercrunching) // (also check the kill flag for removing unused parameters) if (Parser.Settings.RemoveUnneededCode && m_functionScope.IsKnownAtCompileTime && Parser.Settings.MinifyCode && Parser.Settings.IsModificationAllowed(TreeModifications.RemoveUnusedParameters)) { while (lastRef >= 0) { // we want to loop backwards until we either find a parameter that is referenced. // at that point, lastRef will be the index of the last referenced parameter so // we can output from 0 to lastRef JSArgumentField argumentField = m_parameterDeclarations[lastRef].Field; if (argumentField != null && !argumentField.IsReferenced) { --lastRef; } else { // found a referenced parameter, or something weird -- stop looking break; } } } for (int ndx = 0; ndx <= lastRef; ++ndx) { if (ndx > 0) { sb.Append(','); } sb.Append(m_parameterDeclarations[ndx].Name); } } sb.Append(')'); if (Body != null) { if (Body.Count == 0) { sb.Append("{}"); } else { sb.Append(Body.ToCode(ToCodeFormat.AlwaysBraces)); } } if (LeftHandFunctionExpression) { sb.Append(')'); } } return(sb.ToString()); }
internal virtual void AnalyzeScope() { // check for unused local fields or arguments foreach (JSVariableField variableField in m_nameTable.Values) { JSLocalField locField = variableField as JSLocalField; if (locField != null && !locField.IsReferenced && locField.OriginalContext != null) { if (locField.FieldValue is FunctionObject) { Context ctx = ((FunctionObject)locField.FieldValue).IdContext; if (ctx == null) { ctx = locField.OriginalContext; } ctx.HandleError(JSError.FunctionNotReferenced, false); } else if (!locField.IsGenerated) { JSArgumentField argumentField = locField as JSArgumentField; if (argumentField != null) { // we only want to throw this error if it's possible to remove it // from the argument list. And that will only happen if there are // no REFERENCED arguments after this one in the formal parameter list. // Assertion: because this is a JSArgumentField, this should be a function scope, // let's walk up to the first function scope we find, just in case. FunctionScope functionScope = this as FunctionScope; if (functionScope == null) { ActivationObject scope = this.Parent; while (scope != null) { functionScope = scope as FunctionScope; if (scope != null) { break; } } } if (functionScope == null || functionScope.IsArgumentTrimmable(argumentField)) { locField.OriginalContext.HandleError( JSError.ArgumentNotReferenced, false ); } } else if (locField.OuterField == null || !locField.OuterField.IsReferenced) { locField.OriginalContext.HandleError( JSError.VariableDefinedNotReferenced, false ); } } } } // rename fields if we need to RenameFields(); // recurse foreach (ActivationObject activationObject in m_childScopes) { try { Parser.ScopeStack.Push(activationObject); activationObject.AnalyzeScope(); } finally { Parser.ScopeStack.Pop(); } } }
internal bool IsArgumentTrimmable(JSArgumentField targetArgumentField) { // walk backward until we either find the given argument field or the // first parameter that is referenced. // If we find the argument field, then we can trim it because there are no // referenced parameters after it. // if we find a referenced argument, then the parameter is not trimmable. JSArgumentField argumentField = null; if (m_parameterDeclarations != null) { for (int index = m_parameterDeclarations.Length - 1; index >= 0; --index) { argumentField = m_parameterDeclarations[index].Field; if (argumentField != null && (argumentField == targetArgumentField || argumentField.IsReferenced)) { break; } } } // if the argument field we landed on is the same as the target argument field, // then we found the target argument BEFORE we found a referenced parameter. Therefore // the argument can be trimmed. return (argumentField == targetArgumentField); }
internal bool IsArgumentTrimmable(JSArgumentField argumentField) { return m_owningFunctionObject.IsArgumentTrimmable(argumentField); }
/* internal void Remove(JSLocalField localField) { NameTable.Remove(localField.Name); FieldTable.Remove(localField); } */ internal JSArgumentField AddNewArgumentField(String name) { JSArgumentField result = new JSArgumentField(name, Missing.Value); AddField(result); return result; }
internal bool IsArgumentTrimmable(JSArgumentField argumentField) { return(m_owningFunctionObject.IsArgumentTrimmable(argumentField)); }