internal void MergeWithDefinition(BrowserDefinition definition)
{
foreach (string str in definition.Capabilities.Keys)
{
this._capabilities[str] = definition.Capabilities[str];
}
foreach (string str2 in definition.Adapters.Keys)
{
this._adapters[str2] = definition.Adapters[str2];
}
this._htmlTextWriterString = definition.HtmlTextWriterString;
}
internal void AddBrowserToCollectionRecursive(BrowserDefinition bd, int depth)
{
if (this._browserDefinitionCollection == null)
{
this._browserDefinitionCollection = new BrowserDefinitionCollection();
}
bd.Depth = depth;
bd.IsDeviceNode = true;
this._browserDefinitionCollection.Add(bd);
foreach (BrowserDefinition definition in bd.Browsers)
{
this.AddBrowserToCollectionRecursive(definition, depth + 1);
}
}
internal void AddCustomBrowserToCollectionRecursive(BrowserDefinition bd, int depth, int index)
{
if (this._customBrowserDefinitionCollections[index] == null)
{
this._customBrowserDefinitionCollections[index] = new BrowserDefinitionCollection();
}
bd.Depth = depth;
bd.IsDeviceNode = true;
((BrowserDefinitionCollection) this._customBrowserDefinitionCollections[index]).Add(bd);
foreach (BrowserDefinition definition in bd.Browsers)
{
this.AddCustomBrowserToCollectionRecursive(definition, depth + 1, index);
}
}
internal void MergeWithDefinition(BrowserDefinition definition)
{
Debug.Assert(definition.IsRefID);
// Copy the capabilities
foreach (String key in definition.Capabilities.Keys)
{
this._capabilities[key] = definition.Capabilities[key];
}
// Copy the adapter definition
foreach (String key in definition.Adapters.Keys)
{
this._adapters[key] = definition.Adapters[key];
}
this._htmlTextWriterString = definition.HtmlTextWriterString;
}
internal CodeStatementCollection GenerateTrackedSingleProcessCall(CodeStatementCollection stmts, BrowserDefinition bd, CodeMemberMethod cmm, string prefix)
{
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), prefix + bd.Name + "Process", new CodeExpression[0]);
expression.Parameters.Add(new CodeVariableReferenceExpression("headers"));
expression.Parameters.Add(new CodeVariableReferenceExpression("browserCaps"));
CodeConditionStatement statement = new CodeConditionStatement {
Condition = expression
};
stmts.Add(statement);
return statement.FalseStatements;
}
internal void GenerateSingleProcessCall(BrowserDefinition bd, CodeMemberMethod cmm, string prefix)
{
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), prefix + bd.Name + "Process", new CodeExpression[0]);
expression.Parameters.Add(new CodeVariableReferenceExpression("headers"));
expression.Parameters.Add(new CodeVariableReferenceExpression("browserCaps"));
cmm.Statements.Add(expression);
}
private void GenerateSetCapabilitiesCode(BrowserDefinition bd, CodeMemberMethod cmm, ref bool regexWorkerGenerated)
{
NameValueCollection capabilities = bd.Capabilities;
this.AddComment("Capabilities: set capabilities", cmm);
foreach (string str in capabilities.Keys)
{
string str2 = capabilities[str];
CodeAssignStatement statement = new CodeAssignStatement {
Left = new CodeIndexerExpression(this._dictionaryRefExpr, new CodeExpression[] { new CodePrimitiveExpression(str) })
};
CodePrimitiveExpression expression = new CodePrimitiveExpression(str2);
if (RegexWorker.RefPat.Match(str2).Success)
{
this.GenerateRegexWorkerIfNecessary(cmm, ref regexWorkerGenerated);
statement.Right = new CodeIndexerExpression(this._regexWorkerRefExpr, new CodeExpression[] { expression });
}
else
{
statement.Right = expression;
}
cmm.Statements.Add(statement);
}
}
internal void GenerateProcessMethod(BrowserDefinition bd, CodeTypeDeclaration ctd)
{
this.GenerateProcessMethod(bd, ctd, string.Empty);
}
//generate part of the xxxProcess method for assigning capability values
private void GenerateSetCapabilitiesCode(BrowserDefinition bd, CodeMemberMethod cmm, ref bool regexWorkerGenerated) {
//GEN: browserCaps[aaa] = "bbb";
//GEN: browserCaps[xxx] = "yyy";
NameValueCollection nvc = bd.Capabilities;
CodeAssignStatement assign;
AddComment("Capabilities: set capabilities", cmm);
foreach (string s in nvc.Keys) {
string capsString = nvc[s];
//GEN: dictionary["xxx"] = regexWorker["xxx"];
assign = new CodeAssignStatement();
assign.Left = new CodeIndexerExpression(
_dictionaryRefExpr,
new CodeExpression[] { new CodePrimitiveExpression(s) } );
CodePrimitiveExpression capabilityExpr = new CodePrimitiveExpression(capsString);
if (RegexWorker.RefPat.Match(capsString).Success) {
GenerateRegexWorkerIfNecessary(cmm, ref regexWorkerGenerated);
assign.Right = new CodeIndexerExpression(
_regexWorkerRefExpr,
new CodeExpression[] {capabilityExpr});
}
else {
assign.Right = capabilityExpr;
}
cmm.Statements.Add(assign);
}
}
//generate part of the xxxProcess method for running and storing the capture regexes
private void GenerateCapturesCode(BrowserDefinition bd, CodeMemberMethod cmm, ref bool regexWorkerGenerated) {
if ((bd.CaptureHeaderChecks.Count == 0) && (bd.CaptureCapabilityChecks.Count == 0)) {
return;
}
if(bd.CaptureHeaderChecks.Count > 0) {
AddComment("Capture: header values", cmm);
for(int i = 0; i < bd.CaptureHeaderChecks.Count; i++) {
string matchedString = ((CheckPair)bd.CaptureHeaderChecks[i]).MatchString;
if (matchedString.Equals(".*")) {
continue;
}
GenerateRegexWorkerIfNecessary(cmm, ref regexWorkerGenerated);
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(_regexWorkerRefExpr, _processRegexMethod);
if (((CheckPair)bd.CaptureHeaderChecks[i]).Header.Equals("User-Agent")) {
_headers.Add(String.Empty);
cmie.Parameters.Add(new CodeCastExpression(typeof(string),
new CodeIndexerExpression(new CodeVariableReferenceExpression(browserCapsVariable), new CodeExpression[] {
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(String)), "Empty") })));
}
else {
string header = ((CheckPair)bd.CaptureHeaderChecks[i]).Header;
_headers.Add(header);
//GEN: regexWorker.ProcessRegex((string)headers["xxx"], "xxxRegexString");
cmie.Parameters.Add(
new CodeCastExpression(typeof(string),
new CodeIndexerExpression(
_headersRefExpr,
new CodeExpression[] { new CodePrimitiveExpression(header) }
)
)
);
}
cmie.Parameters.Add(new CodePrimitiveExpression(matchedString));
cmm.Statements.Add(cmie);
}
}
if (bd.CaptureCapabilityChecks.Count > 0) {
AddComment("Capture: capability values", cmm);
for(int i = 0; i < bd.CaptureCapabilityChecks.Count; i++) {
string matchedString = ((CheckPair)bd.CaptureCapabilityChecks[i]).MatchString;
if (matchedString.Equals(".*")) {
continue;
}
GenerateRegexWorkerIfNecessary(cmm, ref regexWorkerGenerated);
//GEN: regexWorker.ProcessRegex((string)dictionary["xxxCapability"], "xxxRegexString");
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(_regexWorkerRefExpr, _processRegexMethod);
cmie.Parameters.Add(
new CodeCastExpression(typeof(string),
new CodeIndexerExpression(
_dictionaryRefExpr,
new CodeExpression[] { new CodePrimitiveExpression(((CheckPair)bd.CaptureCapabilityChecks[i]).Header) }
)
)
);
cmie.Parameters.Add(new CodePrimitiveExpression(matchedString));
cmm.Statements.Add(cmie);
}
}
}
//generate part of the xxxProcess method for handling determining if the requesting
//browser meets the regexes for this browser
private void GenerateIdentificationCode(BrowserDefinition bd, CodeMemberMethod cmm, ref bool regexWorkerGenerated) {
//GEN: IDictionary dictionary;
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(IDictionary), _dictionaryRefName));
//GEN: dictionary = browserCaps.Capabilities;
CodeAssignStatement assign = new CodeAssignStatement(
_dictionaryRefExpr,
new CodePropertyReferenceExpression(_browserCapsRefExpr, "Capabilities")
);
cmm.Statements.Add(assign);
bool disableOptimizedKey = false;
CodeVariableReferenceExpression result = null;
CodeVariableReferenceExpression headerValue = null;
if(bd.IdHeaderChecks.Count > 0) {
AddComment("Identification: check header matches", cmm);
for (int i = 0; i < bd.IdHeaderChecks.Count; i++) {
string matchedString = ((CheckPair)bd.IdHeaderChecks[i]).MatchString;
// Skip matching ".*"
if (matchedString.Equals(".*")) {
continue;
}
if (headerValue == null) {
headerValue = GenerateVarReference(cmm, typeof(string), "headerValue");
}
CodeAssignStatement valueAssignment = new CodeAssignStatement();
cmm.Statements.Add(valueAssignment);
valueAssignment.Left = headerValue;
if (((CheckPair)bd.IdHeaderChecks[i]).Header.Equals("User-Agent")) {
_headers.Add(String.Empty);
// GEN: headerValue = ((string)(browserCaps[String.Empty]));
valueAssignment.Right = new CodeCastExpression(typeof(string),
new CodeIndexerExpression(
new CodeVariableReferenceExpression(browserCapsVariable),
new CodeExpression[] {
new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(typeof(String)), "Empty") }));
}
else {
string header = ((CheckPair)bd.IdHeaderChecks[i]).Header;
_headers.Add(header);
//GEN: headerValue = ((String)headers["xxx"]);
valueAssignment.Right = new CodeCastExpression(typeof(string),
new CodeIndexerExpression(
_headersRefExpr,
new CodeExpression[] { new CodePrimitiveExpression(header) }
)
);
disableOptimizedKey = true;
}
// Don't need to use Regex if matching . only.
if (matchedString.Equals(".")) {
// Simply return if the header exists.
ReturnIfHeaderValueEmpty(cmm, headerValue);
continue;
}
if (result == null) {
result = GenerateVarReference(cmm, typeof(bool), _resultVarName);
}
GenerateRegexWorkerIfNecessary(cmm, ref regexWorkerGenerated);
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(_regexWorkerRefExpr, _processRegexMethod);
cmie.Parameters.Add(headerValue);
cmie.Parameters.Add(new CodePrimitiveExpression(matchedString));
//GEN: result = regexWorker.ProcessRegex(headerValue, {matchedString});
assign = new CodeAssignStatement();
assign.Left = result;
assign.Right = cmie;
cmm.Statements.Add(assign);
//GEN: if(result == false) {
//GEN: return false;
//GEN: }
CodeConditionStatement istatement = new CodeConditionStatement();
if(((CheckPair)bd.IdHeaderChecks[i]).NonMatch) {
istatement.Condition = new CodeBinaryOperatorExpression(result, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(true));
}
else {
istatement.Condition = new CodeBinaryOperatorExpression(result, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false));
}
istatement.TrueStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false)));
cmm.Statements.Add(istatement);
}
}
if (bd.IdCapabilityChecks.Count > 0) {
AddComment("Identification: check capability matches", cmm);
for (int i = 0; i < bd.IdCapabilityChecks.Count; i++) {
string matchedString = ((CheckPair)bd.IdCapabilityChecks[i]).MatchString;
// Skip matching ".*"
if (matchedString.Equals(".*")) {
continue;
}
if (headerValue == null) {
headerValue = GenerateVarReference(cmm, typeof(string), "headerValue");
}
CodeAssignStatement valueAssignment = new CodeAssignStatement();
cmm.Statements.Add(valueAssignment);
valueAssignment.Left = headerValue;
valueAssignment.Right = (new CodeCastExpression(typeof(string),
new CodeIndexerExpression(
_dictionaryRefExpr,
new CodeExpression[] {
new CodePrimitiveExpression(((CheckPair)bd.IdCapabilityChecks[i]).Header)
}
)
));
// Don't need to use Regex if matching . only.
if (matchedString.Equals(".")) {
continue;
}
if (result == null) {
result = GenerateVarReference(cmm, typeof(bool), _resultVarName);
}
GenerateRegexWorkerIfNecessary(cmm, ref regexWorkerGenerated);
//GEN: result = regexWorker.ProcessRegex((string)dictionary["xxxCapability"], "xxxRegexString");
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(_regexWorkerRefExpr, _processRegexMethod);
cmie.Parameters.Add(headerValue);
cmie.Parameters.Add(new CodePrimitiveExpression(matchedString));
assign = new CodeAssignStatement();
assign.Left = result;
assign.Right = cmie;
cmm.Statements.Add(assign);
//GEN: if(result == false) {
//GEN: return false;
//GEN: }
CodeConditionStatement istatement = new CodeConditionStatement();
if (((CheckPair)bd.IdCapabilityChecks[i]).NonMatch) {
istatement.Condition = new CodeBinaryOperatorExpression(result, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(true));
}
else {
istatement.Condition = new CodeBinaryOperatorExpression(result, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false));
}
istatement.TrueStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false)));
cmm.Statements.Add(istatement);
}
}
//GEN: browserCaps.DisableOptimizedCacheKey();
if (disableOptimizedKey) {
CodeMethodInvokeExpression cme = new CodeMethodInvokeExpression(_browserCapsRefExpr, _disableOptimizedCacheKeyMethodName);
cmm.Statements.Add(cme);
}
}
internal override void HandleUnRecognizedParentElement(BrowserDefinition bd, bool isDefault)
{
// Use the valid type name so we can find the corresponding parent node.
String parentName = bd.ParentName;
int hashKey = bd.GetType().GetHashCode() ^ parentName.GetHashCode();
// Add the refID in front of the list so they gets to be called first.
if (isDefault) {
AddStringToHashtable(_defaultBrowserOverrides, hashKey, bd.Name, bd.IsRefID);
} else {
AddStringToHashtable(_browserOverrides, hashKey, bd.Name, bd.IsRefID);
}
}
internal void MergeWithDefinition(BrowserDefinition definition) {
Debug.Assert(definition.IsRefID);
// Copy the capabilities
foreach (String key in definition.Capabilities.Keys) {
this._capabilities[key] = definition.Capabilities[key];
}
// Copy the adapter definition
foreach (String key in definition.Adapters.Keys) {
this._adapters[key] = definition.Adapters[key];
}
this._htmlTextWriterString = definition.HtmlTextWriterString;
}
internal override void HandleUnRecognizedParentElement(BrowserDefinition bd, bool isDefault)
{
string parentName = bd.ParentName;
int key = bd.GetType().GetHashCode() ^ parentName.GetHashCode();
if (isDefault)
{
AddStringToHashtable(this._defaultBrowserOverrides, key, bd.Name, bd.IsRefID);
}
else
{
AddStringToHashtable(this._browserOverrides, key, bd.Name, bd.IsRefID);
}
}
private void GenerateCapturesCode(BrowserDefinition bd, CodeMemberMethod cmm, ref bool regexWorkerGenerated)
{
if ((bd.CaptureHeaderChecks.Count != 0) || (bd.CaptureCapabilityChecks.Count != 0))
{
if (bd.CaptureHeaderChecks.Count > 0)
{
this.AddComment("Capture: header values", cmm);
for (int i = 0; i < bd.CaptureHeaderChecks.Count; i++)
{
string matchString = ((CheckPair) bd.CaptureHeaderChecks[i]).MatchString;
if (!matchString.Equals(".*"))
{
this.GenerateRegexWorkerIfNecessary(cmm, ref regexWorkerGenerated);
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(this._regexWorkerRefExpr, "ProcessRegex", new CodeExpression[0]);
if (((CheckPair) bd.CaptureHeaderChecks[i]).Header.Equals("User-Agent"))
{
this._headers.Add(string.Empty);
expression.Parameters.Add(new CodeCastExpression(typeof(string), new CodeIndexerExpression(new CodeVariableReferenceExpression("browserCaps"), new CodeExpression[] { new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(string)), "Empty") })));
}
else
{
string header = ((CheckPair) bd.CaptureHeaderChecks[i]).Header;
this._headers.Add(header);
expression.Parameters.Add(new CodeCastExpression(typeof(string), new CodeIndexerExpression(this._headersRefExpr, new CodeExpression[] { new CodePrimitiveExpression(header) })));
}
expression.Parameters.Add(new CodePrimitiveExpression(matchString));
cmm.Statements.Add(expression);
}
}
}
if (bd.CaptureCapabilityChecks.Count > 0)
{
this.AddComment("Capture: capability values", cmm);
for (int j = 0; j < bd.CaptureCapabilityChecks.Count; j++)
{
string str3 = ((CheckPair) bd.CaptureCapabilityChecks[j]).MatchString;
if (!str3.Equals(".*"))
{
this.GenerateRegexWorkerIfNecessary(cmm, ref regexWorkerGenerated);
CodeMethodInvokeExpression expression2 = new CodeMethodInvokeExpression(this._regexWorkerRefExpr, "ProcessRegex", new CodeExpression[0]);
expression2.Parameters.Add(new CodeCastExpression(typeof(string), new CodeIndexerExpression(this._dictionaryRefExpr, new CodeExpression[] { new CodePrimitiveExpression(((CheckPair) bd.CaptureCapabilityChecks[j]).Header) })));
expression2.Parameters.Add(new CodePrimitiveExpression(str3));
cmm.Statements.Add(expression2);
}
}
}
}
}
//generate part of the xxxProcess method for setting specific adapters for this browser
internal void GenerateSetAdaptersCode(BrowserDefinition bd, CodeMemberMethod cmm) {
//GEN: browserCaps.Adapters[xxxControl] = yyyAdapter;
foreach (DictionaryEntry entry in bd.Adapters) {
string controlString = (string)entry.Key;
string adapterString = (string)entry.Value;
CodePropertyReferenceExpression cpre = new CodePropertyReferenceExpression(_browserCapsRefExpr, "Adapters");
CodeIndexerExpression indexerExpression = new CodeIndexerExpression(
cpre,
new CodeExpression[] { new CodePrimitiveExpression(controlString) }
);
CodeAssignStatement assignAdapter = new CodeAssignStatement();
assignAdapter.Left = indexerExpression;
assignAdapter.Right = new CodePrimitiveExpression(adapterString);
cmm.Statements.Add(assignAdapter);
}
//GEN: browser.HtmlTextWriter = xxxHtmlTextWriter;
if(bd.HtmlTextWriterString != null) {
CodeAssignStatement assignHtmlTextWriter = new CodeAssignStatement();
assignHtmlTextWriter.Left = new CodePropertyReferenceExpression(_browserCapsRefExpr, "HtmlTextWriter");
assignHtmlTextWriter.Right = new CodePrimitiveExpression(bd.HtmlTextWriterString);
cmm.Statements.Add(assignHtmlTextWriter);
}
return;
}
private void GenerateIdentificationCode(BrowserDefinition bd, CodeMemberMethod cmm, ref bool regexWorkerGenerated)
{
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(IDictionary), "dictionary"));
CodeAssignStatement statement = new CodeAssignStatement(this._dictionaryRefExpr, new CodePropertyReferenceExpression(this._browserCapsRefExpr, "Capabilities"));
cmm.Statements.Add(statement);
bool flag = false;
CodeVariableReferenceExpression left = null;
CodeVariableReferenceExpression varExpr = null;
if (bd.IdHeaderChecks.Count > 0)
{
this.AddComment("Identification: check header matches", cmm);
for (int i = 0; i < bd.IdHeaderChecks.Count; i++)
{
string matchString = ((CheckPair) bd.IdHeaderChecks[i]).MatchString;
if (!matchString.Equals(".*"))
{
if (varExpr == null)
{
varExpr = this.GenerateVarReference(cmm, typeof(string), "headerValue");
}
CodeAssignStatement statement2 = new CodeAssignStatement();
cmm.Statements.Add(statement2);
statement2.Left = varExpr;
if (((CheckPair) bd.IdHeaderChecks[i]).Header.Equals("User-Agent"))
{
this._headers.Add(string.Empty);
statement2.Right = new CodeCastExpression(typeof(string), new CodeIndexerExpression(new CodeVariableReferenceExpression("browserCaps"), new CodeExpression[] { new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(string)), "Empty") }));
}
else
{
string header = ((CheckPair) bd.IdHeaderChecks[i]).Header;
this._headers.Add(header);
statement2.Right = new CodeCastExpression(typeof(string), new CodeIndexerExpression(this._headersRefExpr, new CodeExpression[] { new CodePrimitiveExpression(header) }));
flag = true;
}
if (matchString.Equals("."))
{
this.ReturnIfHeaderValueEmpty(cmm, varExpr);
}
else
{
if (left == null)
{
left = this.GenerateVarReference(cmm, typeof(bool), "result");
}
this.GenerateRegexWorkerIfNecessary(cmm, ref regexWorkerGenerated);
CodeMethodInvokeExpression expression3 = new CodeMethodInvokeExpression(this._regexWorkerRefExpr, "ProcessRegex", new CodeExpression[0]);
expression3.Parameters.Add(varExpr);
expression3.Parameters.Add(new CodePrimitiveExpression(matchString));
statement = new CodeAssignStatement {
Left = left,
Right = expression3
};
cmm.Statements.Add(statement);
CodeConditionStatement statement3 = new CodeConditionStatement();
if (((CheckPair) bd.IdHeaderChecks[i]).NonMatch)
{
statement3.Condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(true));
}
else
{
statement3.Condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false));
}
statement3.TrueStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false)));
cmm.Statements.Add(statement3);
}
}
}
}
if (bd.IdCapabilityChecks.Count > 0)
{
this.AddComment("Identification: check capability matches", cmm);
for (int j = 0; j < bd.IdCapabilityChecks.Count; j++)
{
string str3 = ((CheckPair) bd.IdCapabilityChecks[j]).MatchString;
if (!str3.Equals(".*"))
{
if (varExpr == null)
{
varExpr = this.GenerateVarReference(cmm, typeof(string), "headerValue");
}
CodeAssignStatement statement4 = new CodeAssignStatement();
cmm.Statements.Add(statement4);
statement4.Left = varExpr;
statement4.Right = new CodeCastExpression(typeof(string), new CodeIndexerExpression(this._dictionaryRefExpr, new CodeExpression[] { new CodePrimitiveExpression(((CheckPair) bd.IdCapabilityChecks[j]).Header) }));
if (!str3.Equals("."))
{
if (left == null)
{
left = this.GenerateVarReference(cmm, typeof(bool), "result");
}
this.GenerateRegexWorkerIfNecessary(cmm, ref regexWorkerGenerated);
CodeMethodInvokeExpression expression4 = new CodeMethodInvokeExpression(this._regexWorkerRefExpr, "ProcessRegex", new CodeExpression[0]);
expression4.Parameters.Add(varExpr);
expression4.Parameters.Add(new CodePrimitiveExpression(str3));
statement = new CodeAssignStatement {
Left = left,
Right = expression4
};
cmm.Statements.Add(statement);
CodeConditionStatement statement5 = new CodeConditionStatement();
if (((CheckPair) bd.IdCapabilityChecks[j]).NonMatch)
{
statement5.Condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(true));
}
else
{
statement5.Condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false));
}
statement5.TrueStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false)));
cmm.Statements.Add(statement5);
}
}
}
}
if (flag)
{
CodeMethodInvokeExpression expression5 = new CodeMethodInvokeExpression(this._browserCapsRefExpr, "DisableOptimizedCacheKey", new CodeExpression[0]);
cmm.Statements.Add(expression5);
}
}
internal CodeStatementCollection GenerateTrackedSingleProcessCall(CodeStatementCollection stmts, BrowserDefinition bd, CodeMemberMethod cmm, string prefix) {
//GEN: if (xProcess(headers, browserCaps)) {
// }
// else {
// ...
// }
CodeMethodInvokeExpression xProcess = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), prefix + bd.Name + "Process");
xProcess.Parameters.Add(new CodeVariableReferenceExpression(_headersRefName));
xProcess.Parameters.Add(new CodeVariableReferenceExpression(browserCapsVariable));
CodeConditionStatement conditionStmt = new CodeConditionStatement();
conditionStmt.Condition = xProcess;
stmts.Add(conditionStmt);
return conditionStmt.FalseStatements;
}
internal void GenerateProcessMethod(BrowserDefinition bd, CodeTypeDeclaration ctd, string prefix)
{
CodeMemberMethod cmm = new CodeMemberMethod {
Name = prefix + bd.Name + "Process",
ReturnType = new CodeTypeReference(typeof(bool)),
Attributes = MemberAttributes.Private
};
CodeParameterDeclarationExpression expression = new CodeParameterDeclarationExpression(typeof(NameValueCollection), "headers");
cmm.Parameters.Add(expression);
expression = new CodeParameterDeclarationExpression(typeof(HttpBrowserCapabilities), "browserCaps");
cmm.Parameters.Add(expression);
bool regexWorkerGenerated = false;
this.GenerateIdentificationCode(bd, cmm, ref regexWorkerGenerated);
this.GenerateCapturesCode(bd, cmm, ref regexWorkerGenerated);
this.GenerateSetCapabilitiesCode(bd, cmm, ref regexWorkerGenerated);
this.GenerateSetAdaptersCode(bd, cmm);
if (bd.IsDeviceNode)
{
CodeMethodInvokeExpression expression2 = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("browserCaps"), "AddBrowser", new CodeExpression[0]);
expression2.Parameters.Add(new CodePrimitiveExpression(bd.ID));
cmm.Statements.Add(expression2);
}
foreach (BrowserDefinition definition in bd.RefGateways)
{
this.AddComment("ref gateways, parent=" + bd.ID, cmm);
this.GenerateSingleProcessCall(definition, cmm);
}
if (this.GenerateOverrides && (prefix.Length == 0))
{
string methodName = prefix + bd.Name + "ProcessGateways";
this.GenerateChildProcessMethod(methodName, ctd, false);
this.GenerateChildProcessInvokeExpression(methodName, cmm, false);
}
foreach (BrowserDefinition definition2 in bd.Gateways)
{
this.AddComment("gateway, parent=" + bd.ID, cmm);
this.GenerateSingleProcessCall(definition2, cmm);
}
if (this.GenerateOverrides)
{
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(typeof(bool), "ignoreApplicationBrowsers", new CodePrimitiveExpression(bd.Browsers.Count != 0));
cmm.Statements.Add(statement);
}
if (bd.Browsers.Count > 0)
{
CodeStatementCollection stmts = cmm.Statements;
this.AddComment("browser, parent=" + bd.ID, cmm);
foreach (BrowserDefinition definition3 in bd.Browsers)
{
stmts = this.GenerateTrackedSingleProcessCall(stmts, definition3, cmm, prefix);
}
if (this.GenerateOverrides)
{
CodeAssignStatement statement2 = new CodeAssignStatement {
Left = new CodeVariableReferenceExpression("ignoreApplicationBrowsers"),
Right = new CodePrimitiveExpression(false)
};
stmts.Add(statement2);
}
}
foreach (BrowserDefinition definition4 in bd.RefBrowsers)
{
this.AddComment("ref browsers, parent=" + bd.ID, cmm);
if (definition4.IsDefaultBrowser)
{
this.GenerateSingleProcessCall(definition4, cmm, "Default");
}
else
{
this.GenerateSingleProcessCall(definition4, cmm);
}
}
if (this.GenerateOverrides)
{
string str2 = prefix + bd.Name + "ProcessBrowsers";
this.GenerateChildProcessMethod(str2, ctd, true);
this.GenerateChildProcessInvokeExpression(str2, cmm, true);
}
CodeMethodReturnStatement statement3 = new CodeMethodReturnStatement(new CodePrimitiveExpression(true));
cmm.Statements.Add(statement3);
ctd.Members.Add(cmm);
}
//generate code to call the xxxProcess for a given browser
//and store the result in a local variable
internal void GenerateSingleProcessCall(BrowserDefinition bd, CodeMemberMethod cmm, string prefix) {
//GEN: xProcess(headers, browserCaps);
CodeMethodInvokeExpression xProcess = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), prefix + bd.Name + "Process");
xProcess.Parameters.Add(new CodeVariableReferenceExpression(_headersRefName));
xProcess.Parameters.Add(new CodeVariableReferenceExpression(browserCapsVariable));
cmm.Statements.Add(xProcess);
}
internal void GenerateSetAdaptersCode(BrowserDefinition bd, CodeMemberMethod cmm)
{
foreach (DictionaryEntry entry in bd.Adapters)
{
string key = (string) entry.Key;
string str2 = (string) entry.Value;
CodePropertyReferenceExpression targetObject = new CodePropertyReferenceExpression(this._browserCapsRefExpr, "Adapters");
CodeIndexerExpression expression2 = new CodeIndexerExpression(targetObject, new CodeExpression[] { new CodePrimitiveExpression(key) });
CodeAssignStatement statement = new CodeAssignStatement {
Left = expression2,
Right = new CodePrimitiveExpression(str2)
};
cmm.Statements.Add(statement);
}
if (bd.HtmlTextWriterString != null)
{
CodeAssignStatement statement2 = new CodeAssignStatement {
Left = new CodePropertyReferenceExpression(this._browserCapsRefExpr, "HtmlTextWriter"),
Right = new CodePrimitiveExpression(bd.HtmlTextWriterString)
};
cmm.Statements.Add(statement2);
}
}
internal virtual void ProcessBrowserNode(XmlNode node, BrowserTree browserTree) {
BrowserDefinition browserInfo = null;
if (node.Name == "gateway") {
browserInfo = new GatewayDefinition(node);
}
else if (node.Name == "browser") {
browserInfo = new BrowserDefinition(node);
}
else {
Debug.Assert(node.Name == "defaultBrowser");
browserInfo = new BrowserDefinition(node, true);
}
BrowserDefinition oldNode = (BrowserDefinition)browserTree[browserInfo.Name];
if (oldNode != null) {
if (browserInfo.IsRefID) {
oldNode.MergeWithDefinition(browserInfo);
}
else {
throw new ConfigurationErrorsException(SR.GetString(SR.Duplicate_browser_id, browserInfo.ID), node);
}
}
else {
browserTree[browserInfo.Name] = browserInfo;
}
}
internal void GenerateSingleProcessCall(BrowserDefinition bd, CodeMemberMethod cmm)
{
this.GenerateSingleProcessCall(bd, cmm, string.Empty);
}
internal void AddBrowserToCollectionRecursive(BrowserDefinition bd, int depth) {
if (_browserDefinitionCollection == null) {
_browserDefinitionCollection = new BrowserDefinitionCollection();
}
bd.Depth = depth;
bd.IsDeviceNode = true;
_browserDefinitionCollection.Add(bd);
foreach(BrowserDefinition childBrowser in bd.Browsers) {
AddBrowserToCollectionRecursive(childBrowser, depth + 1);
}
}
internal CodeStatementCollection GenerateTrackedSingleProcessCall(CodeStatementCollection stmts, BrowserDefinition bd, CodeMemberMethod cmm)
{
return this.GenerateTrackedSingleProcessCall(stmts, bd, cmm, string.Empty);
}
internal virtual void HandleUnRecognizedParentElement(BrowserDefinition bd, bool isDefault) {
throw new ConfigurationErrorsException(SR.GetString(SR.Browser_parentID_Not_Found, bd.ParentID), bd.XmlNode);
}
internal virtual void HandleUnRecognizedParentElement(BrowserDefinition bd, bool isDefault)
{
throw new ConfigurationErrorsException(System.Web.SR.GetString("Browser_parentID_Not_Found", new object[] { bd.ParentID }), bd.XmlNode);
}
//generate the xxxProcess method for an individual BrowserDefinition
internal void GenerateProcessMethod(BrowserDefinition bd, CodeTypeDeclaration ctd, string prefix) {
//GEN: internal bool XxxProcess(NameValueCollection headers, HttpBrowserCapabilities browserCaps)
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = prefix + bd.Name + "Process";
cmm.ReturnType = new CodeTypeReference(typeof(bool));
cmm.Attributes = MemberAttributes.Private;
CodeParameterDeclarationExpression cpde = new CodeParameterDeclarationExpression(typeof(NameValueCollection), _headersRefName);
cmm.Parameters.Add(cpde);
cpde = new CodeParameterDeclarationExpression(typeof(HttpBrowserCapabilities), browserCapsVariable);
cmm.Parameters.Add(cpde);
bool regexWorkerGenerated = false;
GenerateIdentificationCode(bd, cmm, ref regexWorkerGenerated);
GenerateCapturesCode(bd, cmm, ref regexWorkerGenerated);
GenerateSetCapabilitiesCode(bd, cmm, ref regexWorkerGenerated);
GenerateSetAdaptersCode(bd, cmm);
// Only add the browser node to the browser collection if it represents a device.
if (bd.IsDeviceNode) {
Debug.Assert(!(bd is GatewayDefinition));
//GEN: browserCaps.AddBrowser("xxx");
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(browserCapsVariable), "AddBrowser");
cmie.Parameters.Add(new CodePrimitiveExpression(bd.ID));
cmm.Statements.Add(cmie);
}
// Generate ref gateway elements
foreach (BrowserDefinition b in bd.RefGateways) {
AddComment("ref gateways, parent=" + bd.ID, cmm);
GenerateSingleProcessCall(b, cmm);
}
if ((GenerateOverrides) && (prefix.Length == 0)) {
//Gen: protected virtual void XxxProcessGateways(NameValueCollection headers, HttpBrowserCapabilities browserCaps) ;
string methodName = prefix + bd.Name + "ProcessGateways";
GenerateChildProcessMethod(methodName, ctd, false);
//Gen: XxxProcessGateways(headers, browserCaps) ;
GenerateChildProcessInvokeExpression(methodName, cmm, false);
}
foreach(BrowserDefinition b in bd.Gateways) {
AddComment("gateway, parent=" + bd.ID, cmm);
GenerateSingleProcessCall(b, cmm);
}
if (GenerateOverrides) {
//GEN: bool ignoreApplicationBrowsers = true | false; //bd.Browsers.Count != 0
CodeVariableDeclarationStatement cvds = new CodeVariableDeclarationStatement(typeof(bool),
IgnoreApplicationBrowserVariableName, new CodePrimitiveExpression(bd.Browsers.Count != 0));
cmm.Statements.Add(cvds);
}
if (bd.Browsers.Count > 0) {
CodeStatementCollection statements = cmm.Statements;
AddComment("browser, parent=" + bd.ID, cmm);
foreach (BrowserDefinition b in bd.Browsers) {
statements = GenerateTrackedSingleProcessCall(statements, b, cmm, prefix);
}
if (GenerateOverrides) {
//GEN: ignoreApplicationBrowsers = false;
CodeAssignStatement codeAssignStmt = new CodeAssignStatement();
codeAssignStmt.Left = new CodeVariableReferenceExpression(IgnoreApplicationBrowserVariableName);
codeAssignStmt.Right = new CodePrimitiveExpression(false);
statements.Add(codeAssignStmt);
}
}
// Generate ref browser
foreach (BrowserDefinition b in bd.RefBrowsers) {
AddComment("ref browsers, parent=" + bd.ID, cmm);
if (b.IsDefaultBrowser) {
GenerateSingleProcessCall(b, cmm, "Default");
}
else {
GenerateSingleProcessCall(b, cmm);
}
}
if (GenerateOverrides) {
//Gen: protected virtual void XxxProcessBrowsers(bool ignoreApplicationBrowsers, NameValueCollection headers, HttpBrowserCapabilities browserCaps) ;
string methodName = prefix + bd.Name + "ProcessBrowsers";
GenerateChildProcessMethod(methodName, ctd, true);
//Gen: XxxProcessBrowsers(ignoreApplicationBrowsers, headers, browserCaps);
GenerateChildProcessInvokeExpression(methodName, cmm, true);
}
//GEN: return true;
CodeMethodReturnStatement cmrs = new CodeMethodReturnStatement(new CodePrimitiveExpression(true));
cmm.Statements.Add(cmrs);
ctd.Members.Add(cmm);
}
internal virtual void ProcessBrowserNode(XmlNode node, System.Web.Configuration.BrowserTree browserTree)
{
BrowserDefinition definition = null;
if (node.Name == "gateway")
{
definition = new GatewayDefinition(node);
}
else if (node.Name == "browser")
{
definition = new BrowserDefinition(node);
}
else
{
definition = new BrowserDefinition(node, true);
}
BrowserDefinition definition2 = (BrowserDefinition) browserTree[definition.Name];
if (definition2 != null)
{
if (!definition.IsRefID)
{
throw new ConfigurationErrorsException(System.Web.SR.GetString("Duplicate_browser_id", new object[] { definition.ID }), node);
}
definition2.MergeWithDefinition(definition);
}
else
{
browserTree[definition.Name] = definition;
}
}
internal void MergeWithDefinition(BrowserDefinition definition)
{
foreach (string str in definition.Capabilities.Keys)
{
this._capabilities[str] = definition.Capabilities[str];
}
foreach (string str2 in definition.Adapters.Keys)
{
this._adapters[str2] = definition.Adapters[str2];
}
this._htmlTextWriterString = definition.HtmlTextWriterString;
}
