private static string GetSeverityString(int severity)
{
// From jscriptexception.js:
//
//guide: 0 == there will be a run-time error if this code executes
// 1 == the programmer probably did not intend to do this
// 2 == this can lead to problems in the future.
// 3 == this can lead to performance problems
// 4 == this is just not right
switch (severity)
{
case 0:
return(StringMgr.GetString("Severity0"));
case 1:
return(StringMgr.GetString("Severity1"));
case 2:
return(StringMgr.GetString("Severity2"));
case 3:
return(StringMgr.GetString("Severity3"));
case 4:
return(StringMgr.GetString("Severity4"));
default:
return(StringMgr.GetString("SeverityUnknown", severity));
}
}
// NAME [SCOPE TYPE] [crunched to CRUNCH]
//
// SCOPE: global, local, outer, ''
// TYPE: var, function, argument, arguments array, possibly undefined
private void WriteMemberReport(JSVariableField variableField, ActivationObject immediateScope)
{
// skip any *unreferenced* named-function-expression fields
JSNamedFunctionExpressionField namedFuncExpr = variableField as JSNamedFunctionExpressionField;
if (namedFuncExpr == null || namedFuncExpr.RefCount > 0 || !m_removeFunctionExpressionNames)
{
string scope = string.Empty;
string type = string.Empty;
string crunched = string.Empty;
string name = variableField.Name;
if (variableField.IsLiteral)
{
name = variableField.FieldValue.ToString();
}
// calculate the crunched label
JSLocalField localField = variableField as JSLocalField;
if (localField != null)
{
if (localField.CrunchedName != null)
{
crunched = StringMgr.GetString("CrunchedTo", localField.CrunchedName, localField.RefCount);
}
}
// get the field's default scope and type
GetFieldScopeType(variableField, immediateScope, out scope, out type);
if (variableField is JSWithField)
{
// if the field is a with field, we won't be using the crunched field (since
// those fields can't be crunched), so let's overload it with what the field
// could POSSIBLY be if the with object doesn't have a property of that name
string outerScope;
string outerType;
GetFieldScopeType(variableField.OuterField, immediateScope, out outerScope, out outerType);
crunched = StringMgr.GetString("MemberInfoWithPossibly", outerScope, outerType);
}
// format the entire string
WriteProgress(StringMgr.GetString(
"MemberInfoFormat",
name,
scope,
type,
crunched
));
}
}
protected JScriptException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
if (info == null)
{
throw new ArgumentException(StringMgr.GetString("InternalCompilerError"));
}
m_code = HResult = info.GetInt32("Code");
m_valueObject = info.GetValue("Value", typeof(System.Object));
if (m_valueObject == null)
{
m_valueObject = Missing.Value;
}
m_isError = info.GetBoolean("IsError");
}
/// <summary>
/// Prepare the unknwon surrogate pair for encoding
/// </summary>
/// <param name="unknownCharHigh">high surrogate pair character</param>
/// <param name="unknownCharLow">low surrogate pair character</param>
/// <param name="index">index of character in the stream</param>
/// <returns></returns>
public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
{
// if we're not done with the current buffer, we're being recursive.
if (m_position < m_fallbackString.Length)
{
throw new ArgumentException(StringMgr.GetString("FallbackEncodingFailed"));
}
// get the fallback string
m_fallbackString = GetEncoding((int)charUnknownHigh) + GetEncoding((int)charUnknownLow);
m_position = 0;
// return false if we have no string, indicating we didn't encode it
return(m_fallbackString.Length > 0);
}
private void WriteScopeReport(FunctionObject funcObj, ActivationObject scope)
{
// output the function header
if (scope is GlobalScope)
{
WriteProgress(StringMgr.GetString("GlobalObjectsHeader"));
}
else
{
FunctionScope functionScope = scope as FunctionScope;
if (functionScope != null && funcObj != null)
{
WriteFunctionHeader(funcObj, scope.IsKnownAtCompileTime);
}
else
{
BlockScope blockScope = scope as BlockScope;
if (blockScope is CatchScope)
{
WriteBlockHeader(blockScope, StringMgr.GetString("BlockTypeCatch"));
}
else if (blockScope is WithScope)
{
WriteBlockHeader(blockScope, StringMgr.GetString("BlockTypeWith"));
}
else
{
WriteProgress();
WriteProgress(StringMgr.GetString("UnknownScopeType", scope.GetType().ToString()));
}
}
}
// get all the fields in the scope
JSVariableField[] scopeFields = scope.GetFields();
// sort the fields
Array.Sort(scopeFields, FieldComparer.Instance);
// iterate over all the fields
foreach (JSVariableField variableField in scopeFields)
{
// don't report placeholder fields
if (!variableField.IsPlaceholder)
{
WriteMemberReport(variableField, scope);
}
}
}
private void WriteUnrefedReport()
{
if (m_undefined != null && m_undefined.Count > 0)
{
// sort the undefined reference exceptions
m_undefined.Sort(UndefinedComparer.Instance);
// write the report
WriteProgress();
WriteProgress(StringMgr.GetString("UndefinedGlobalHeader"));
foreach (UndefinedReferenceException ex in m_undefined)
{
WriteProgress(StringMgr.GetString(
"UndefinedInfo",
ex.Name,
ex.Line,
ex.Column,
ex.ReferenceType.ToString()
));
}
}
}
private void WriteBlockHeader(BlockScope blockScope, string blockType)
{
string knownMarker = string.Empty;
if (!blockScope.IsKnownAtCompileTime)
{
StringBuilder sb = new StringBuilder();
sb.Append('[');
sb.Append(StringMgr.GetString("NotKnown"));
sb.Append(']');
knownMarker = sb.ToString();
}
WriteProgress();
WriteProgress(StringMgr.GetString(
"BlockScopeHeader",
blockType,
blockScope.Context.StartLineNumber,
blockScope.Context.StartColumn,
knownMarker
));
}
private int ProcessCssFile(string sourceFileName, ResourceStrings resourceStrings, StringBuilder outputBuilder, ref long sourceLength)
{
int retVal = 0;
try
{
// read our chunk of code
string source;
if (sourceFileName.Length > 0)
{
using (StreamReader reader = new StreamReader(sourceFileName, m_encodingInput))
{
WriteProgress(
StringMgr.GetString("CrunchingFile", Path.GetFileName(sourceFileName))
);
source = reader.ReadToEnd();
}
// add the actual file length in to the input source length
FileInfo inputFileInfo = new FileInfo(sourceFileName);
sourceLength += inputFileInfo.Length;
}
else
{
WriteProgress(StringMgr.GetString("CrunchingStdIn"));
try
{
// try setting the input encoding
Console.InputEncoding = m_encodingInput;
}
catch (IOException e)
{
// error setting the encoding input; just use whatever the default is
Debug.WriteLine(e.ToString());
}
source = Console.In.ReadToEnd();
if (m_analyze)
{
// calculate the actual number of bytes read using the input encoding
// and the string that we just read and
// add the number of bytes read into the input length.
sourceLength += Console.InputEncoding.GetByteCount(source);
}
else
{
// don't bother calculating the actual bytes -- the number of characters
// is sufficient if we're not doing the analysis
sourceLength += source.Length;
}
}
// process input source...
CssParser parser = new CssParser();
parser.CssError += new EventHandler <CssErrorEventArgs>(OnCssError);
parser.FileContext = sourceFileName;
parser.Settings.CommentMode = m_cssComments;
parser.Settings.ExpandOutput = m_prettyPrint;
parser.Settings.IndentSpaces = m_indentSize;
parser.Settings.Severity = m_warningLevel;
parser.Settings.TermSemicolons = m_terminateWithSemicolon;
parser.Settings.ColorNames = m_colorNames;
parser.Settings.MinifyExpressions = m_minifyExpressions;
parser.Settings.AllowEmbeddedAspNetBlocks = m_allowAspNet;
parser.ValueReplacements = resourceStrings;
// if the kill switch was set to 1 (don't preserve important comments), then
// we just want to set the comment mode to none, regardless of what the actual comment
// mode may be.
if ((m_killSwitch & 1) != 0)
{
parser.Settings.CommentMode = CssComment.None;
}
// crunch the source and output to the string builder we were passed
string crunchedStyles = parser.Parse(source);
if (crunchedStyles != null)
{
Debug.WriteLine(crunchedStyles);
}
else
{
// there was an error and no output was generated
retVal = 1;
}
if (m_echoInput)
{
// just echo the input to the output
outputBuilder.Append(source);
}
else if (!string.IsNullOrEmpty(crunchedStyles))
{
// send the crunched styles to the output
outputBuilder.Append(crunchedStyles);
}
}
catch (IOException e)
{
// probably an error with the input file
retVal = 1;
System.Diagnostics.Debug.WriteLine(e.ToString());
WriteError(CreateBuildError(
null,
null,
true,
"JS-IO",
e.Message
));
}
return(retVal);
}
private static void GetFieldScopeType(JSVariableField variableField, ActivationObject immediateScope, out string scope, out string type)
{
JSLocalField localField = variableField as JSLocalField;
JSPredefinedField predefinedField = variableField as JSPredefinedField;
JSNamedFunctionExpressionField namedFuncExpr = variableField as JSNamedFunctionExpressionField;
// default scope is blank
scope = string.Empty;
if (variableField is JSArgumentField)
{
type = StringMgr.GetString("MemberInfoTypeArgument");
}
else if (variableField is JSArgumentsField)
{
type = StringMgr.GetString("MemberInfoTypeArguments");
}
else if (predefinedField != null)
{
switch (predefinedField.GlobalObject)
{
case GlobalObjectInstance.GlobalObject:
scope = StringMgr.GetString("MemberInfoScopeGlobalObject");
break;
case GlobalObjectInstance.WindowObject:
scope = StringMgr.GetString("MemberInfoScopeWindowObject");
break;
case GlobalObjectInstance.Other:
scope = StringMgr.GetString("MemberInfoScopeOtherObject");
break;
}
switch (predefinedField.MemberType)
{
case MemberTypes.Method:
type = StringMgr.GetString("MemberInfoBuiltInMethod");
break;
case MemberTypes.Property:
type = StringMgr.GetString("MemberInfoBuiltInProperty");
break;
default:
type = StringMgr.GetString("MemberInfoBuiltInObject");
break;
}
}
else if (variableField is JSGlobalField)
{
if ((variableField.Attributes & FieldAttributes.RTSpecialName) == FieldAttributes.RTSpecialName)
{
// this is a special "global." It might not be a global, but something referenced
// in a with scope somewhere down the line.
type = StringMgr.GetString("MemberInfoPossiblyUndefined");
}
else if (variableField.FieldValue is FunctionObject)
{
if (variableField.NamedFunctionExpression == null)
{
type = StringMgr.GetString("MemberInfoGlobalFunction");
}
else
{
type = StringMgr.GetString("MemberInfoFunctionExpression");
}
}
else
{
type = StringMgr.GetString("MemberInfoGlobalVar");
}
}
else if (variableField is JSWithField)
{
type = StringMgr.GetString("MemberInfoWithField");
}
else if (namedFuncExpr != null)
{
type = StringMgr.GetString("MemberInfoSelfFuncExpr");
}
else if (localField != null)
{
// type string
if (localField.FieldValue is FunctionObject)
{
if (localField.NamedFunctionExpression == null)
{
type = StringMgr.GetString("MemberInfoLocalFunction");
}
else
{
type = StringMgr.GetString("MemberInfoFunctionExpression");
}
}
else if (localField.IsLiteral)
{
type = StringMgr.GetString("MemberInfoLocalLiteral");
}
else
{
type = StringMgr.GetString("MemberInfoLocalVar");
}
// scope string
// this is a local variable, so there MUST be a non-null function scope passed
// to us. That function scope will be the scope we are expecting local variables
// to be defined in. If the field is defined in that scope, it's local -- otherwise
// it must be an outer variable.
JSVariableField scopeField = immediateScope[variableField.Name];
if (scopeField == null || scopeField.OuterField != null)
{
scope = StringMgr.GetString("MemberInfoScopeOuter");
}
else
{
scope = StringMgr.GetString("MemberInfoScopeLocal");
}
}
else
{
type = StringMgr.GetString("MemberInfoBuiltInObject");
}
}
//TYPE "NAME" - Starts at line LINE, col COLUMN STATUS [crunched to CRUNCH]
//
//TYPE: Function, Function getter, Function setter
//STATUS: '', Unknown, Unreachable
private void WriteFunctionHeader(FunctionObject funcObj, bool isKnown)
{
// get the crunched value (if any)
string crunched = string.Empty;
JSLocalField localField = funcObj.LocalField as JSLocalField;
if (localField != null && localField.CrunchedName != null)
{
crunched = StringMgr.GetString("CrunchedTo", localField.CrunchedName, localField.RefCount);
}
// get the status if the function
StringBuilder statusBuilder = new StringBuilder();
if (!isKnown)
{
statusBuilder.Append('[');
statusBuilder.Append(StringMgr.GetString("NotKnown"));
}
if (funcObj.FunctionScope.Parent is GlobalScope)
{
// global function.
// if this is a named function expression, we still want to know if it's
// referenced by anyone
if (funcObj.FunctionType == FunctionType.Expression &&
!string.IsNullOrEmpty(funcObj.Name))
{
// output a comma separator if not the first item, otherwise
// open the square bracket
if (statusBuilder.Length > 0)
{
statusBuilder.Append(", ");
}
else
{
statusBuilder.Append('[');
}
statusBuilder.Append(StringMgr.GetString(
"FunctionInfoReferences",
funcObj.RefCount
));
}
}
else if (!funcObj.FunctionScope.IsReferenced(null))
{
// local function that isn't referenced -- unreachable!
// output a comma separator if not the first item, otherwise
// open the square bracket
if (statusBuilder.Length > 0)
{
statusBuilder.Append(", ");
}
else
{
statusBuilder.Append('[');
}
statusBuilder.Append(StringMgr.GetString("Unreachable"));
}
if (statusBuilder.Length > 0)
{
statusBuilder.Append(']');
}
string status = statusBuilder.ToString();
string functionType;
switch (funcObj.FunctionType)
{
case FunctionType.Getter:
functionType = "FunctionTypePropGet";
break;
case FunctionType.Setter:
functionType = "FunctionTypePropSet";
break;
case FunctionType.Expression:
functionType = "FunctionTypeExpression";
break;
default:
functionType = "FunctionTypeFunction";
break;
}
// output
WriteProgress();
WriteProgress(StringMgr.GetString(
"FunctionHeader",
StringMgr.GetString(functionType),
funcObj.Name,
funcObj.Context.StartLineNumber,
funcObj.Context.StartColumn,
status,
crunched
));
}
private bool m_preprocessOnly; // = false;
#endregion
#region file processing
private int ProcessJSFile(string sourceFileName, ResourceStrings resourceStrings, StringBuilder outputBuilder, ref bool lastEndedSemicolon, ref long sourceLength)
{
int retVal = 0;
// read our chunk of code
string source;
if (sourceFileName.Length > 0)
{
using (StreamReader reader = new StreamReader(sourceFileName, m_encodingInput))
{
WriteProgress(
StringMgr.GetString("CrunchingFile", Path.GetFileName(sourceFileName))
);
source = reader.ReadToEnd();
}
}
else
{
WriteProgress(StringMgr.GetString("CrunchingStdIn"));
try
{
// try setting the input encoding
Console.InputEncoding = m_encodingInput;
}
catch (IOException e)
{
// error setting the encoding input; just use whatever the default is
Debug.WriteLine(e.ToString());
}
source = Console.In.ReadToEnd();
if (m_analyze)
{
// calculate the actual number of bytes read using the input encoding
// and the string that we just read and
// add the number of bytes read into the input length.
sourceLength += Console.InputEncoding.GetByteCount(source);
}
else
{
// don't bother calculating the actual bytes -- the number of characters
// is sufficient if we're not doing the analysis
sourceLength += source.Length;
}
}
// add the input length to the running total
sourceLength += source.Length;
// create the a parser object for our chunk of code
JSParser parser = new JSParser(source);
// set up the file context for the parser
parser.FileContext = sourceFileName;
// hook the engine events
parser.CompilerError += OnCompilerError;
parser.UndefinedReference += OnUndefinedReference;
// put the resource strings object into the parser
parser.ResourceStrings = resourceStrings;
// set our flags
CodeSettings settings = new CodeSettings();
settings.ManualRenamesProperties = m_renameProperties;
settings.CollapseToLiteral = m_collapseToLiteral;
settings.CombineDuplicateLiterals = m_combineDuplicateLiterals;
settings.EvalLiteralExpressions = m_evalLiteralExpressions;
settings.EvalTreatment = m_evalTreatment;
settings.IndentSize = m_indentSize;
settings.InlineSafeStrings = m_safeForInline;
settings.LocalRenaming = m_localRenaming;
settings.MacSafariQuirks = m_macSafariQuirks;
settings.OutputMode = (m_prettyPrint ? OutputMode.MultipleLines : OutputMode.SingleLine);
settings.PreserveFunctionNames = m_preserveFunctionNames;
settings.RemoveFunctionExpressionNames = m_removeFunctionExpressionNames;
settings.RemoveUnneededCode = m_removeUnneededCode;
settings.StripDebugStatements = m_stripDebugStatements;
settings.AllowEmbeddedAspNetBlocks = m_allowAspNet;
settings.SetKnownGlobalNames(m_globals == null ? null : m_globals.ToArray());
settings.SetNoAutoRename(m_noAutoRename == null ? null : m_noAutoRename.ToArray());
settings.IgnoreConditionalCompilation = m_ignoreConditionalCompilation;
// if there are defined preprocessor names
if (m_defines != null && m_defines.Count > 0)
{
// set the list of defined names to our array of names
settings.SetPreprocessorDefines(m_defines.ToArray());
}
// if there are rename entries...
if (m_renameMap != null && m_renameMap.Count > 0)
{
// add each of them to the parser
foreach (var sourceName in m_renameMap.Keys)
{
settings.AddRenamePair(sourceName, m_renameMap[sourceName]);
}
}
// cast the kill switch numeric value to the appropriate TreeModifications enumeration
settings.KillSwitch = (TreeModifications)m_killSwitch;
string resultingCode = null;
if (m_preprocessOnly)
{
// we only want to preprocess the code. Call that api on the parser
resultingCode = parser.PreprocessOnly(settings);
}
else
{
Block scriptBlock = parser.Parse(settings);
if (scriptBlock != null)
{
if (m_analyze)
{
// output our report
CreateReport(parser.GlobalScope);
}
// crunch the output and write it to debug stream
resultingCode = scriptBlock.ToCode();
}
else
{
// no code?
WriteProgress(StringMgr.GetString("NoParsedCode"));
}
}
if (!string.IsNullOrEmpty(resultingCode))
{
// always output the crunched code to debug stream
System.Diagnostics.Debug.WriteLine(resultingCode);
// if the last block of code didn't end in a semi-colon,
// then we need to add one now
if (!lastEndedSemicolon)
{
outputBuilder.Append(';');
}
// we'll output either the crunched code (normal) or
// the raw source if we're just echoing the input
string outputCode = (m_echoInput ? source : resultingCode);
// send the output code to the output stream
outputBuilder.Append(outputCode);
// check if this string ended in a semi-colon so we'll know if
// we need to add one between this code and the next block (if any)
lastEndedSemicolon = (outputCode[outputCode.Length - 1] == ';');
}
else
{
// resulting code is null or empty
Debug.WriteLine(StringMgr.GetString("OutputEmpty"));
}
return(retVal);
}
private static string GetLocalizedMsg()
{
string code = ((int)JSError.SyntaxError).ToString(CultureInfo.InvariantCulture);
return(StringMgr.GetString(code));
}
