public ScopeBase(ScopeInfo scopeInfo, object[] values) { Info = scopeInfo; Values = values; if (Values == null) Values = new object[scopeInfo.ValuesCount]; }
public SlotBinding(SlotInfo slot, AstNode fromNode, ScopeInfo fromScope) : base(slot.Name, BindingTargetType.Slot) { Slot = slot; FromNode = fromNode; FromScope = fromScope; SlotIndex = slot.Index; StaticScopeIndex = Slot.ScopeInfo.StaticIndex; SetupAccessorMethods(); }
public AppDataMap(bool languageCaseSensitive, AstNode programRoot = null) { LanguageCaseSensitive = languageCaseSensitive; ProgramRoot = programRoot?? new AstNode(); var mainScopeInfo = new ScopeInfo(ProgramRoot, LanguageCaseSensitive); StaticScopeInfos.Add(mainScopeInfo); mainScopeInfo.StaticIndex = 0; MainModule = new ModuleInfo("main", "main", mainScopeInfo); Modules.Add(MainModule); }
public BindingRequest(ScriptThread thread, AstNode fromNode, string symbol, BindingRequestFlags flags) { Thread = thread; FromNode = fromNode; FromModule = thread.App.DataMap.GetModule(fromNode.ModuleNode); Symbol = symbol; Flags = flags; FromScopeInfo = thread.CurrentScope.Info; IgnoreCase = !thread.Runtime.Language.Grammar.CaseSensitive; }
protected override object DoEvaluate(ScriptThread thread) { thread.CurrentNode = this; //standard prolog lock (LockObject) { if (DependentScopeInfo == null) { var langCaseSensitive = thread.App.Language.Grammar.CaseSensitive; DependentScopeInfo = new ScopeInfo(this, langCaseSensitive); } // In the first evaluation the parameter list will add parameter's SlotInfo objects to Scope.ScopeInfo thread.PushScope(DependentScopeInfo, null); Parameters.Evaluate(thread); thread.PopScope(); //Set Evaluate method and invoke it later this.Evaluate = EvaluateAfter; } var result = Evaluate(thread); thread.CurrentNode = Parent; //standard epilog return result; }
public object Call(ScriptThread thread, object[] parameters) { var astNode = new AstNode(); // TODO: figure it out var newScopeInfo = new ScopeInfo(astNode, thread.App.Language.Grammar.CaseSensitive); thread.PushScope(newScopeInfo, parameters); try { var expression = parameters != null && parameters.Length > 0 ? parameters[0] as PassiveExpression : null; return Function(expression); } finally { thread.PopScope(); } }
public override void Init(AstContext context, ParseTreeNode parseNode) { base.Init(context, parseNode); foreach (var node in parseNode.ChildNodes) { if (node.AstNode is IdentifierNode) { Name = (node.AstNode as IdentifierNode).Symbol; } else if (node.AstNode is Block) { Block = (node.AstNode as Block); Block.Parent = this; } else if (node.Term is KeyTerm && node.Term.Name == "$ENTRY") { IsPublic = true; } } ScopeInfo = new ScopeInfo(this, context.Language.Grammar.CaseSensitive); AsString = (IsPublic ? "public " : "private ") + Name; }
public override bool CheckInvocation(TexlBinding binding, TexlNode[] args, DType[] argTypes, IErrorContainer errors, out DType returnType, out Dictionary <TexlNode, DType> nodeToCoercedTypeMap) { Contracts.AssertValue(args); Contracts.AssertValue(argTypes); Contracts.Assert(args.Length == argTypes.Length); Contracts.AssertValue(errors); nodeToCoercedTypeMap = null; int viewCount = 0; bool fArgsValid = base.CheckInvocation(args, argTypes, errors, out returnType, out nodeToCoercedTypeMap); var dataSourceVisitor = new ViewFilterDataSourceVisitor(binding); // Ensure that all the args starting at index 1 are booleans or view for (int i = 1; i < args.Length; i++) { if (argTypes[i].Kind == DKind.ViewValue) { if (++viewCount > 1) { // Only one view expected errors.EnsureError(DocumentErrorSeverity.Severe, args[i], TexlStrings.ErrOnlyOneViewExpected); fArgsValid = false; continue; } // Use the visitor to get the datasource info and if a view was already used anywhere in the node tree. args[0].Accept(dataSourceVisitor); var dataSourceInfo = dataSourceVisitor.cdsDataSourceInfo; if (dataSourceVisitor.ContainsViewFilter) { // Only one view expected errors.EnsureError(DocumentErrorSeverity.Severe, args[i], TexlStrings.ErrOnlyOneViewExpected); fArgsValid = false; continue; } if (dataSourceInfo != null) { // Verify the view belongs to the same datasource var viewInfo = argTypes[i].ViewInfo.VerifyValue(); if (viewInfo.RelatedEntityName != dataSourceInfo.Name) { errors.EnsureError(DocumentErrorSeverity.Severe, args[i], TexlStrings.ErrViewFromCurrentTableExpected, dataSourceInfo.Name); fArgsValid = false; } } else { errors.EnsureError(DocumentErrorSeverity.Severe, args[i], TexlStrings.ErrBooleanExpected); fArgsValid = false; } continue; } else if (DType.Boolean.Accepts(argTypes[i])) { continue; } else if (!argTypes[i].CoercesTo(DType.Boolean)) { errors.EnsureError(DocumentErrorSeverity.Severe, args[i], TexlStrings.ErrBooleanExpected); fArgsValid = false; continue; } } // The first Texl function arg determines the cursor type, the scope type for the lambda params, and the return type. DType typeScope; fArgsValid &= ScopeInfo.CheckInput(args[0], argTypes[0], errors, out typeScope); Contracts.Assert(typeScope.IsRecord); returnType = typeScope.ToTable(); return(fArgsValid); }
public ScopeInfo(ITypeSymbol type) { this.Type = type; this.usedTypeArguments = new HashSet <string>(ScopeInfo.AllTypeArguments(type).Select(i => i.Name)); }
public ScopeInfo InsertOrUpdateScopeInfo(ScopeInfo scopeInfo) { bool alreadyOpened = connection.State == ConnectionState.Open; bool exist; try { using (var command = connection.CreateCommand()) { if (transaction != null) { command.Transaction = transaction; } if (!alreadyOpened) { connection.Open(); } command.CommandText = $@"Select count(*) from {scopeTableName.Quoted().ToString()} where sync_scope_id = @sync_scope_id"; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_id"; p.Value = scopeInfo.Id.ToString(); p.DbType = DbType.String; command.Parameters.Add(p); exist = (long)command.ExecuteScalar() > 0; } string stmtText = exist ? $"Update {scopeTableName.Quoted().ToString()} set sync_scope_name=@sync_scope_name, scope_timestamp={MySqlObjectNames.TimestampValue}, scope_is_local=@scope_is_local, scope_last_sync=@scope_last_sync, scope_last_sync_timestamp=@scope_last_sync_timestamp, scope_last_sync_duration=@scope_last_sync_duration where sync_scope_id=@sync_scope_id" : $"Insert into {scopeTableName.Quoted().ToString()} (sync_scope_name, scope_timestamp, scope_is_local, scope_last_sync, sync_scope_id, scope_last_sync_timestamp, scope_last_sync_duration) values (@sync_scope_name, {MySqlObjectNames.TimestampValue}, @scope_is_local, @scope_last_sync, @sync_scope_id, @scope_last_sync_timestamp, @scope_last_sync_duration)"; using (var command = connection.CreateCommand()) { if (transaction != null) { command.Transaction = transaction; } command.CommandText = stmtText; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = scopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_is_local"; p.Value = scopeInfo.IsLocal; p.DbType = DbType.Boolean; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync"; p.Value = scopeInfo.LastSync.HasValue ? (object)scopeInfo.LastSync.Value : DBNull.Value; p.DbType = DbType.DateTime; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync_timestamp"; p.Value = scopeInfo.LastSyncTimestamp; p.DbType = DbType.Int64; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync_duration"; p.Value = scopeInfo.LastSyncDuration; p.DbType = DbType.Int64; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_id"; p.Value = scopeInfo.Id.ToString(); p.DbType = DbType.String; command.Parameters.Add(p); using (DbDataReader reader = command.ExecuteReader()) { while (reader.Read()) { scopeInfo.Name = reader["sync_scope_name"] as String; scopeInfo.Id = new Guid((string)reader["sync_scope_id"]); scopeInfo.Timestamp = MySqlManager.ParseTimestamp(reader["scope_timestamp"]); scopeInfo.IsLocal = (bool)reader["scope_is_local"]; scopeInfo.LastSyncDuration = reader["scope_last_sync_duration"] != DBNull.Value ? (long)reader["scope_last_sync_duration"] : 0L; scopeInfo.LastSyncTimestamp = reader["scope_last_sync_timestamp"] != DBNull.Value ? (long)reader["scope_last_sync_timestamp"] : 0L; scopeInfo.LastSync = reader["scope_last_sync"] != DBNull.Value ? (DateTime?)reader["scope_last_sync"] : null; } } return(scopeInfo); } } catch (Exception ex) { Debug.WriteLine($"Error during CreateTableScope : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } } }
public List <ScopeInfo> GetAllScopes(string scopeName) { var command = connection.CreateCommand(); if (transaction != null) { command.Transaction = transaction; } bool alreadyOpened = connection.State == ConnectionState.Open; List <ScopeInfo> scopes = new List <ScopeInfo>(); try { if (!alreadyOpened) { connection.Open(); } command.CommandText = @"SELECT sync_scope_id , sync_scope_name , scope_timestamp , scope_is_local , scope_last_sync FROM scope_info WHERE sync_scope_name = @sync_scope_name"; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = scopeName; p.DbType = DbType.String; command.Parameters.Add(p); using (DbDataReader reader = command.ExecuteReader()) { // read only the first one while (reader.Read()) { ScopeInfo scopeInfo = new ScopeInfo(); scopeInfo.Name = reader["sync_scope_name"] as String; scopeInfo.Id = (Guid)reader["sync_scope_id"]; scopeInfo.LastTimestamp = DbManager.ParseTimestamp(reader["scope_timestamp"]); scopeInfo.LastSync = reader["scope_last_sync"] != DBNull.Value ? (DateTime?)reader["scope_last_sync"] : null; scopeInfo.IsLocal = reader.GetBoolean(reader.GetOrdinal("scope_is_local")); scopes.Add(scopeInfo); } } return(scopes); } catch (Exception ex) { Debug.WriteLine($"Error during GetAllScopes : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } if (command != null) { command.Dispose(); } } }
public ScopeBase(ScopeInfo scopeInfo) : this(scopeInfo, null) { }
protected override object DoEvaluate(Irony.Interpreter.ScriptThread thread) { object retval = null; thread.CurrentNode = this; //standard prolog IEnumerable<object> o = null; string functionName = function.ChildNodes[0].FindTokenAndGetText(); switch (functionName.ToLowerInvariant()) { case "count": o = Left as IEnumerable<object>; if (o != null) retval = o.Count(); else retval = -1; break; case "range": o = Left as IEnumerable<object>; if (o != null) { // by default return the first int iFrom = GetIndex(thread, Arguments[0], o, 0); int iTo = GetIndex(thread, Arguments[1], o, iFrom); if (iFrom < 0) iFrom = 0; if (iTo >= o.Count()) iTo = o.Count(); List<object> tretval = new List<object>(); for (int i = iFrom; i <= iTo; i++) { tretval.Add(o.ElementAt(i)); } retval = tretval; } else retval = null; break; case "where": o = Left as IEnumerable<object>; if (o != null) { List<object> tretvalWhere = new List<object>(); foreach (var item in o) { // todo: bonghi: needs to check the context is set here. var scpInfo = new ScopeInfo(this, false); object[] oIfc = new object[] { item }; thread.PushScope(scpInfo, oIfc); try { object oCondition = Arguments[0].Evaluate(thread); if ((bool)oCondition) { tretvalWhere.Add(item); } } catch (Exception) { // if problems just ignore so that statements that don't compute (say for missing properties) are still ok. } thread.PopScope(); } retval = tretvalWhere; } else retval = null; break; default: throw new Exception("Not implemented: " + functionName); } thread.CurrentNode = Parent; //standard epilog return retval; }
protected override void OnTranslate(ShaderTranslationContext sc, VariableDeclarationSyntax syntax, ScopeInfo scope) { string typeName = syntax.Type.ToString(); ShaderType type = ShaderType.TranslateType(sc, typeName); ScopeInfo tScope = sc.Source.OpenScope(ScopeType.Typed, type); tScope.TypeInfo = type; tScope.IsLocal = syntax.Parent is LocalDeclarationStatementSyntax; tScope.Items = syntax.Variables; if (syntax.Parent is FieldDeclarationSyntax fieldSyntax) { tScope.TranslatedModifiers = sc.Language.TranslateModifiers(fieldSyntax.Modifiers); } sc.Complete(syntax.Type); }
public async Task <ScopeInfo> InsertOrUpdateClientScopeInfoAsync(ScopeInfo scopeInfo) { var command = connection.CreateCommand(); if (transaction != null) { command.Transaction = transaction; } bool alreadyOpened = connection.State == ConnectionState.Open; try { if (!alreadyOpened) { await connection.OpenAsync().ConfigureAwait(false); } command.CommandText = $@"Select count(*) from {scopeTableName.Unquoted().ToString()} where sync_scope_id = @sync_scope_id"; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_id"; p.Value = scopeInfo.Id.ToString(); p.DbType = DbType.String; command.Parameters.Add(p); var exist = ((long)await command.ExecuteScalarAsync().ConfigureAwait(false)) > 0; string stmtText = exist ? $"Update {scopeTableName.Unquoted().ToString()} set sync_scope_name=@sync_scope_name, sync_scope_schema=@sync_scope_schema, sync_scope_setup=@sync_scope_setup, sync_scope_version=@sync_scope_version, scope_last_sync=@scope_last_sync, scope_last_server_sync_timestamp=@scope_last_server_sync_timestamp, scope_last_sync_timestamp=@scope_last_sync_timestamp, scope_last_sync_duration=@scope_last_sync_duration where sync_scope_id=@sync_scope_id" : $"Insert into {scopeTableName.Unquoted().ToString()} (sync_scope_name, sync_scope_schema, sync_scope_setup, sync_scope_version, scope_last_sync, scope_last_sync_duration, scope_last_server_sync_timestamp, scope_last_sync_timestamp, sync_scope_id) values (@sync_scope_name, @sync_scope_schema, @sync_scope_setup, @sync_scope_version, @scope_last_sync, @scope_last_sync_duration, @scope_last_server_sync_timestamp, @scope_last_sync_timestamp, @sync_scope_id)"; command = connection.CreateCommand(); command.CommandText = stmtText; p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = scopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_schema"; p.Value = scopeInfo.Schema == null ? DBNull.Value : (object)JsonConvert.SerializeObject(scopeInfo.Schema); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_setup"; p.Value = scopeInfo.Setup == null ? DBNull.Value : (object)JsonConvert.SerializeObject(scopeInfo.Setup); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_version"; p.Value = string.IsNullOrEmpty(scopeInfo.Version) ? DBNull.Value : (object)scopeInfo.Version; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync"; p.Value = scopeInfo.LastSync.HasValue ? (object)scopeInfo.LastSync.Value : DBNull.Value; p.DbType = DbType.DateTime; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_server_sync_timestamp"; p.Value = scopeInfo.LastServerSyncTimestamp; p.DbType = DbType.Int64; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync_timestamp"; p.Value = scopeInfo.LastSyncTimestamp; p.DbType = DbType.Int64; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync_duration"; p.Value = scopeInfo.LastSyncDuration; p.DbType = DbType.Int64; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_id"; p.Value = scopeInfo.Id.ToString(); p.DbType = DbType.String; command.Parameters.Add(p); using (DbDataReader reader = await command.ExecuteReaderAsync().ConfigureAwait(false)) { if (reader.HasRows) { while (reader.Read()) { scopeInfo.Name = reader["sync_scope_name"] as string; scopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); scopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); scopeInfo.Version = reader["sync_scope_version"] as string; scopeInfo.Id = reader.GetGuid(reader.GetOrdinal("sync_scope_id")); scopeInfo.LastSync = reader["scope_last_sync"] != DBNull.Value ? (DateTime?)reader.GetDateTime(reader.GetOrdinal("scope_last_sync")) : null; scopeInfo.LastSyncTimestamp = reader["scope_last_sync_timestamp"] != DBNull.Value ? reader.GetInt64(reader.GetOrdinal("scope_last_sync_timestamp")) : 0L; scopeInfo.LastServerSyncTimestamp = reader["scope_last_server_sync_timestamp"] != DBNull.Value ? reader.GetInt64(reader.GetOrdinal("scope_last_server_sync_timestamp")) : 0L; scopeInfo.LastSyncDuration = reader["scope_last_sync_duration"] != DBNull.Value ? reader.GetInt64(reader.GetOrdinal("scope_last_sync_duration")) : 0L; } } } return(scopeInfo); } catch (Exception ex) { Debug.WriteLine($"Error during InsertOrUpdateClientScopeInfoAsync : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } if (command != null) { command.Dispose(); } } }
public async Task <(SyncContext, BatchInfo, ChangesStatistics)> GetChangeBatchAsync(SyncContext ctx, ScopeInfo scopeInfo) => await this.LocalProvider.GetChangeBatchAsync(ctx, scopeInfo);
public async Task <SyncContext> EnsureDatabaseAsync(SyncContext ctx, ScopeInfo scopeInfo) => await this.LocalProvider.EnsureDatabaseAsync(ctx, scopeInfo);
public async Task <(SyncContext, ChangesStatistics)> ApplyChangesAsync(SyncContext ctx, ScopeInfo fromScope, BatchInfo changes) => await this.LocalProvider.ApplyChangesAsync(ctx, fromScope, changes);
private static ScopeViewModel ToModel(ScopeInfo info) { return(SimpleMapper.From <ScopeInfo, ScopeViewModel>(info)); }
protected override void OnTranslate(ShaderTranslationContext sc, AssignmentExpressionSyntax syntax, ScopeInfo scope) { if (scope.Type == ScopeType.ExpandedInitializer) { sc.Source.Append($"{scope.Identifier}."); sc.Source.OpenScope(ScopeType.Variable); } // TODO check if the assignment uses a valid operator. Does the language support operand assignments (e.g *= += or /=) sc.Runner.Translate(sc, syntax.Left); if (sc.IsCompleted(syntax.Right)) // Property translation may have replaced the assignment with a set-method call. { return; } sc.Source.Append($" {syntax.OperatorToken} "); sc.Runner.Translate(sc, syntax.Right); }
public override void ExecuteBatchCommand(DbCommand cmd, DmView applyTable, DmTable failedRows, ScopeInfo scope) { if (applyTable.Count <= 0) { return; } // Insert data in bulk table BulkInsertTemporyTable(BulkInsertTemporyTableText(applyTable)); ((OracleParameterCollection)cmd.Parameters)["sync_scope_id"].Value = scope.Id; ((OracleParameterCollection)cmd.Parameters)["sync_min_timestamp"].Value = scope.LastTimestamp; bool alreadyOpened = this._connection.State == ConnectionState.Open; try { if (!alreadyOpened) { this._connection.Open(); } if (this._transaction != null) { cmd.Transaction = this._transaction; } using (DbDataReader dataReader = cmd.ExecuteReader()) { failedRows.Fill(dataReader); } } catch (DbException ex) { Debug.WriteLine(ex.Message); throw; } finally { if (!alreadyOpened && this._connection.State != ConnectionState.Closed) { this._connection.Close(); } } }
public List <ScopeInfo> GetAllScopes(string scopeName) { var command = connection.CreateCommand(); if (transaction != null) { command.Transaction = transaction; } bool alreadyOpened = connection.State == ConnectionState.Open; List <ScopeInfo> scopes = new List <ScopeInfo>(); try { if (!alreadyOpened) { connection.Open(); } command.CommandText = $@"SELECT [sync_scope_id] , [sync_scope_name] , [scope_timestamp] , [scope_is_local] , [scope_last_sync] , [scope_last_sync_timestamp] , [scope_last_sync_duration] FROM {scopeTableName.QuotedObjectName} WHERE [sync_scope_name] = @sync_scope_name"; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = scopeName; p.DbType = DbType.String; command.Parameters.Add(p); using (DbDataReader reader = command.ExecuteReader()) { // read only the first one while (reader.Read()) { ScopeInfo scopeInfo = new ScopeInfo(); scopeInfo.Name = reader["sync_scope_name"] as String; scopeInfo.Id = (Guid)reader["sync_scope_id"]; scopeInfo.Timestamp = SqlManager.ParseTimestamp(reader["scope_timestamp"]); scopeInfo.LastSync = reader["scope_last_sync"] != DBNull.Value ? (DateTime?)reader["scope_last_sync"] : null; scopeInfo.LastSyncTimestamp = reader["scope_last_sync_timestamp"] != DBNull.Value ? (long)reader["scope_last_sync_timestamp"] : 0; scopeInfo.LastSyncDuration = reader["scope_last_sync_duration"] != DBNull.Value ? (long)reader["scope_last_sync_duration"] : 0; scopeInfo.IsLocal = (bool)reader["scope_is_local"]; scopes.Add(scopeInfo); } } return(scopes); } catch (Exception ex) { Debug.WriteLine($"Error during GetAllScopes : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } if (command != null) { command.Dispose(); } } }
protected override void OnTranslate(ShaderTranslationContext sc, PropertyDeclarationSyntax syntax, ScopeInfo scope) { ScopeInfo classScope = scope.FindOfType(ScopeType.Class); ScopeInfo pScope = sc.Source.OpenScope(ScopeType.Property); pScope.Identifier = syntax.Identifier.ValueText; sc.Complete(syntax.Type); pScope.TypeInfo = ShaderType.TranslateType(sc, syntax.Type.ToString()); }
protected override void OnTranslate(ShaderTranslationContext sc, MemberAccessExpressionSyntax syntax, ScopeInfo scope) { switch (syntax.Expression) { case IdentifierNameSyntax idSyntax: // Is this a static class identifier? // Static classes are abstract and sealed at IL level. Type targetType = ShaderType.Resolve(sc, idSyntax.Identifier.ValueText); if (targetType != null && targetType.IsClass && targetType.IsAbstract && targetType.IsSealed) { // Is the member a constant value? If so, we can take it's value directly. FieldInfo fInfo = targetType.GetField(syntax.Name.Identifier.ValueText); if (fInfo != null && (fInfo.Attributes & FieldAttributes.Literal) == FieldAttributes.Literal) { object val = fInfo.GetValue(null); if (val != null) { sc.Source.Append(val.ToString()); sc.CompleteChildren(syntax); return; } } } else { ScopeInfo cScope = scope.FindOfType(ScopeType.Class); if (cScope == sc.Source.RootScope) { FieldInfo fInfo = cScope.TypeInfo.OriginalType.GetField(idSyntax.Identifier.ValueText); if (fInfo != null && sc.ConstantBuffers.Values.Any(x => x.TypeInfo == fInfo.FieldType)) { if (!sc.Language.InstancedConstantBuffers) { sc.CompleteSelfAndChildren(syntax.Expression); sc.Runner.Translate(sc, syntax.Name); return; } } } } break; case ThisExpressionSyntax thisSyntax: case BaseExpressionSyntax baseSyntax: ScopeInfo pScope = scope.FindOfType(ScopeType.Class); if (pScope.TypeInfo.OriginalType == sc.ShaderType) { sc.Complete(syntax.Expression); // Are we translating a shader intrinsic method/function? if (syntax.Name is IdentifierNameSyntax idSyntax && syntax.Parent is InvocationExpressionSyntax) { string translatedIntrinsic = ShaderType.GetIntrinsicTranslation(sc, idSyntax.Identifier.ValueText); sc.Source.Append(translatedIntrinsic); sc.Complete(syntax.Name); } return; } break; } sc.Runner.Translate(sc, syntax.Expression); sc.Source.Append(syntax.OperatorToken); sc.Runner.Translate(sc, syntax.Name); }
/// <summary> /// Executing a batch command /// </summary> /// <param name="cmd">the DbCommand already prepared</param> /// <param name="applyTable">the table rows to apply</param> /// <param name="failedRows">the failed rows dmTable to store failed rows</param> /// <param name="scope">the current scope</param> public override void ExecuteBatchCommand(DbCommand cmd, DmTable applyTable, DmTable failedRows, ScopeInfo scope) { if (applyTable.Rows.Count <= 0) { return; } var lstMutableColumns = applyTable.Columns.Where(c => !c.ReadOnly).ToList(); List <SqlDataRecord> records = new List <SqlDataRecord>(applyTable.Rows.Count); SqlMetaData[] metadatas = new SqlMetaData[lstMutableColumns.Count]; for (int i = 0; i < lstMutableColumns.Count; i++) { var column = lstMutableColumns[i]; SqlMetaData metadata = GetSqlMetadaFromType(column); metadatas[i] = metadata; } try { foreach (var dmRow in applyTable.Rows) { SqlDataRecord record = new SqlDataRecord(metadatas); int sqlMetadataIndex = 0; for (int i = 0; i < dmRow.ItemArray.Length; i++) { // check if it's readonly if (applyTable.Columns[i].ReadOnly) { continue; } // Get the default value // Since we have the readonly values in ItemArray, get the value from original column dynamic defaultValue = applyTable.Columns[i].DefaultValue; dynamic rowValue = dmRow[i]; var columnType = applyTable.Columns[i].DataType; // metadatas don't have readonly values, so get from sqlMetadataIndex var sqlMetadataType = metadatas[sqlMetadataIndex].SqlDbType; if (rowValue != null) { switch (sqlMetadataType) { case SqlDbType.BigInt: if (columnType != typeof(long)) { if (Int64.TryParse(rowValue.ToString(), out Int64 v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to Int64", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.Bit: if (columnType != typeof(bool)) { if (Boolean.TryParse(rowValue.ToString(), out Boolean v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to Boolean", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.Date: case SqlDbType.DateTime: case SqlDbType.DateTime2: case SqlDbType.SmallDateTime: if (columnType != typeof(DateTime)) { if (DateTime.TryParse(rowValue.ToString(), out DateTime v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to DateTime", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.DateTimeOffset: if (columnType != typeof(DateTimeOffset)) { if (DateTimeOffset.TryParse(rowValue.ToString(), out DateTimeOffset dt)) { rowValue = dt; } else { throw new SyncException($"Can't convert value {rowValue} to DateTimeOffset", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.Decimal: if (columnType != typeof(Decimal)) { if (Decimal.TryParse(rowValue.ToString(), out decimal v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to Decimal", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.Float: if (columnType != typeof(Double)) { if (Double.TryParse(rowValue.ToString(), out Double v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to Double", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.Real: if (columnType != typeof(float)) { if (float.TryParse(rowValue.ToString(), out float v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to Double", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.Image: case SqlDbType.Binary: case SqlDbType.VarBinary: if (columnType != typeof(Byte[])) { rowValue = BitConverter.GetBytes(rowValue); } break; case SqlDbType.Variant: break; case SqlDbType.Int: if (columnType != typeof(Int32)) { if (Int32.TryParse(rowValue.ToString(), out int v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to Int32", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.Money: case SqlDbType.SmallMoney: if (columnType != typeof(Decimal)) { if (Decimal.TryParse(rowValue.ToString(), out Decimal v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to Decimal", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.NChar: case SqlDbType.NText: case SqlDbType.VarChar: case SqlDbType.Xml: case SqlDbType.NVarChar: case SqlDbType.Text: case SqlDbType.Char: if (columnType != typeof(string)) { rowValue = rowValue.ToString(); } break; case SqlDbType.SmallInt: if (columnType != typeof(Int16)) { if (Int16.TryParse(rowValue.ToString(), out Int16 v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to Int16", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.Time: if (columnType != typeof(TimeSpan)) { if (TimeSpan.TryParse(rowValue.ToString(), out TimeSpan v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to TimeSpan", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.Timestamp: break; case SqlDbType.TinyInt: if (columnType != typeof(Byte)) { if (Byte.TryParse(rowValue.ToString(), out byte v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to Byte", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; case SqlDbType.Udt: throw new SyncException($"Can't use UDT as SQL Type", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); case SqlDbType.UniqueIdentifier: if (columnType != typeof(Guid)) { if (Guid.TryParse(rowValue.ToString(), out Guid v)) { rowValue = v; } else { throw new SyncException($"Can't convert value {rowValue} to Guid", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } } break; } } if (applyTable.Columns[i].AllowDBNull && rowValue == null) { rowValue = DBNull.Value; } else if (rowValue == null) { rowValue = defaultValue; } record.SetValue(sqlMetadataIndex, rowValue); sqlMetadataIndex++; } records.Add(record); } } catch (Exception ex) { throw new SyncException($"Can't create a SqlRecord based on the rows we have: {ex.Message}", Enumerations.SyncStage.ApplyingChanges, SyncExceptionType.NotSupported); } ((SqlParameterCollection)cmd.Parameters)["@changeTable"].TypeName = string.Empty; ((SqlParameterCollection)cmd.Parameters)["@changeTable"].Value = records; ((SqlParameterCollection)cmd.Parameters)["@sync_scope_id"].Value = scope.Id; ((SqlParameterCollection)cmd.Parameters)["@sync_min_timestamp"].Value = scope.LastTimestamp; bool alreadyOpened = this.connection.State == ConnectionState.Open; try { if (!alreadyOpened) { this.connection.Open(); } if (this.transaction != null) { cmd.Transaction = this.transaction; } using (DbDataReader dataReader = cmd.ExecuteReader()) { failedRows.Fill(dataReader); } } catch (DbException ex) { Debug.WriteLine(ex.Message); //DbException dbException = dbException1; //Error = CheckZombieTransaction(tvpCommandNameForApplyType, Adapter.TableName, dbException); //this.AddFailedRowsAfterRIFailure(applyTable, failedRows); throw; } finally { if (!alreadyOpened && this.connection.State != ConnectionState.Closed) { this.connection.Close(); } } }
protected override void OnTranslate(ShaderTranslationContext sc, InitializerExpressionSyntax syntax, ScopeInfo scope) { if (syntax.Parent is ArrayCreationExpressionSyntax arrayCreationSyntax || syntax.Parent is EqualsValueClauseSyntax equalsAssignmentSyntax) { ScopeInfo iScope = sc.Source.OpenScope(ScopeType.ArrayInitializer); iScope.Items = syntax.Expressions; } }
public ScopeInfo InsertOrUpdateScopeInfo(ScopeInfo scopeInfo) { var command = connection.CreateCommand(); if (transaction != null) { command.Transaction = transaction; } bool alreadyOpened = connection.State == ConnectionState.Open; try { if (!alreadyOpened) { connection.Open(); } command.CommandText = @" MERGE INTO scope_info base USING ( SELECT :sync_scope_id AS sync_scope_id, :sync_scope_name AS sync_scope_name, :scope_is_local as scope_is_local, to_date(:scope_last_sync, 'DD/MM/YYYY HH24:MI:SS') AS scope_last_sync, to_number(to_char(systimestamp, 'YYYYMMDDHH24MISSFF3')) as scope_timestamp FROM dual ) changes ON (base.sync_scope_id = changes.sync_scope_id) WHEN NOT MATCHED THEN INSERT (sync_scope_name, sync_scope_id, scope_is_local, scope_last_sync, scope_timestamp) VALUES (changes.sync_scope_name, changes.sync_scope_id, changes.scope_is_local, changes.scope_last_sync, changes.scope_timestamp) WHEN MATCHED THEN UPDATE SET sync_scope_name = changes.sync_scope_name, scope_is_local = changes.scope_is_local, scope_last_sync = changes.scope_last_sync, scope_timestamp = changes.scope_timestamp "; var p = command.CreateParameter(); p.ParameterName = "sync_scope_name"; p.Value = scopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "sync_scope_id"; p.Value = scopeInfo.Id.ToString(); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "scope_is_local"; p.Value = scopeInfo.IsLocal ? 1 : 0; p.DbType = DbType.Int32; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "scope_last_sync"; if (scopeInfo.LastSync.HasValue) { p.Value = $"{scopeInfo.LastSync.Value.ToShortDateString()} {scopeInfo.LastSync.Value.ToLongTimeString()}"; } else { p.Value = DBNull.Value; } p.DbType = DbType.String; command.Parameters.Add(p); command.ExecuteNonQuery(); } catch (Exception ex) { Debug.WriteLine($"Error during CreateTableScope : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } if (command != null) { command.Dispose(); } } command = connection.CreateCommand(); if (transaction != null) { command.Transaction = transaction; } alreadyOpened = connection.State == ConnectionState.Open; try { if (!alreadyOpened) { connection.Open(); } command.CommandText = @" SELECT sync_scope_name, sync_scope_id, scope_timestamp, scope_is_local, scope_last_sync FROM SCOPE_INFO WHERE sync_scope_id = :sync_scope_id"; var p = command.CreateParameter(); p.ParameterName = "sync_scope_id"; p.Value = scopeInfo.Id.ToString(); p.DbType = DbType.String; command.Parameters.Add(p); using (DbDataReader reader = command.ExecuteReader()) { while (reader.Read()) { scopeInfo.Name = reader["sync_scope_name"] as String; scopeInfo.Id = Guid.Parse(reader["sync_scope_id"].ToString()); scopeInfo.LastTimestamp = OracleManager.ParseTimestamp(reader["scope_timestamp"]); scopeInfo.IsLocal = Convert.ToInt32(reader["scope_is_local"]) == 1; scopeInfo.LastSync = reader["scope_last_sync"] != DBNull.Value ? (DateTime?)reader["scope_last_sync"] : null; } } return(scopeInfo); } catch (Exception ex) { Debug.WriteLine($"Error during SelectTableScope : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } if (command != null) { command.Dispose(); } } }
public virtual async Task <List <ScopeInfo> > GetAllClientScopesAsync(string scopeName) { var command = connection.CreateCommand(); if (transaction != null) { command.Transaction = transaction; } bool alreadyOpened = connection.State == ConnectionState.Open; var scopes = new List <ScopeInfo>(); try { if (!alreadyOpened) { await connection.OpenAsync().ConfigureAwait(false); } command.CommandText = $@"SELECT [sync_scope_id] , [sync_scope_name] , [sync_scope_schema] , [sync_scope_setup] , [sync_scope_version] , [scope_last_sync] , [scope_last_server_sync_timestamp] , [scope_last_sync_timestamp] , [scope_last_sync_duration] FROM {scopeTableName.Quoted().ToString()} WHERE [sync_scope_name] = @sync_scope_name"; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = scopeName; p.DbType = DbType.String; command.Parameters.Add(p); using (var reader = await command.ExecuteReaderAsync().ConfigureAwait(false)) { if (reader.HasRows) { // read only the first one while (reader.Read()) { var scopeInfo = new ScopeInfo(); scopeInfo.Name = reader["sync_scope_name"] as string; scopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); scopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); scopeInfo.Version = reader["sync_scope_version"] as string; scopeInfo.Id = (Guid)reader["sync_scope_id"]; scopeInfo.LastSync = reader["scope_last_sync"] != DBNull.Value ? (DateTime?)reader["scope_last_sync"] : null; scopeInfo.LastServerSyncTimestamp = reader["scope_last_server_sync_timestamp"] != DBNull.Value ? (long)reader["scope_last_server_sync_timestamp"] : 0; scopeInfo.LastSyncTimestamp = reader["scope_last_sync_timestamp"] != DBNull.Value ? (long)reader["scope_last_sync_timestamp"] : 0; scopeInfo.LastSyncDuration = reader["scope_last_sync_duration"] != DBNull.Value ? (long)reader["scope_last_sync_duration"] : 0; scopes.Add(scopeInfo); } } } return(scopes); } catch (Exception ex) { Debug.WriteLine($"Error during GetAllScopes : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } if (command != null) { command.Dispose(); } } }
protected override void OnTranslate(ShaderTranslationContext sc, ArrowExpressionClauseSyntax syntax, ScopeInfo scope) { if (scope.Type == ScopeType.Method) { sc.Source.OpenScope(ScopeType.Block); if (scope.Method.ReturnType != typeof(void)) { sc.Source.Append("return "); } sc.Source.OpenScope(ScopeType.Variable); } }
public virtual async Task <ScopeInfo> InsertOrUpdateClientScopeInfoAsync(ScopeInfo scopeInfo) { var command = connection.CreateCommand(); if (transaction != null) { command.Transaction = transaction; } bool alreadyOpened = connection.State == ConnectionState.Open; try { if (!alreadyOpened) { await connection.OpenAsync().ConfigureAwait(false); } command.CommandText = $@" MERGE {scopeTableName.Quoted().ToString()} AS [base] USING ( SELECT @sync_scope_id AS sync_scope_id, @sync_scope_name AS sync_scope_name, @sync_scope_schema AS sync_scope_schema, @sync_scope_setup AS sync_scope_setup, @sync_scope_version AS sync_scope_version, @scope_last_sync AS scope_last_sync, @scope_last_sync_timestamp AS scope_last_sync_timestamp, @scope_last_server_sync_timestamp AS scope_last_server_sync_timestamp, @scope_last_sync_duration AS scope_last_sync_duration ) AS [changes] ON [base].[sync_scope_id] = [changes].[sync_scope_id] WHEN NOT MATCHED THEN INSERT ([sync_scope_name], [sync_scope_schema], [sync_scope_setup], [sync_scope_version], [sync_scope_id], [scope_last_sync], [scope_last_sync_timestamp], [scope_last_server_sync_timestamp], [scope_last_sync_duration]) VALUES ([changes].[sync_scope_name], [changes].[sync_scope_schema], [changes].[sync_scope_setup], [changes].[sync_scope_version], [changes].[sync_scope_id], [changes].[scope_last_sync], [changes].[scope_last_sync_timestamp], [changes].[scope_last_server_sync_timestamp], [changes].[scope_last_sync_duration]) WHEN MATCHED THEN UPDATE SET [sync_scope_name] = [changes].[sync_scope_name], [sync_scope_schema] = [changes].[sync_scope_schema], [sync_scope_setup] = [changes].[sync_scope_setup], [sync_scope_version] = [changes].[sync_scope_version], [scope_last_sync] = [changes].[scope_last_sync], [scope_last_sync_timestamp] = [changes].[scope_last_sync_timestamp], [scope_last_server_sync_timestamp] = [changes].[scope_last_server_sync_timestamp], [scope_last_sync_duration] = [changes].[scope_last_sync_duration] OUTPUT INSERTED.[sync_scope_name], INSERTED.[sync_scope_schema], INSERTED.[sync_scope_setup], INSERTED.[sync_scope_version], INSERTED.[sync_scope_id], INSERTED.[scope_last_sync], INSERTED.[scope_last_sync_timestamp], INSERTED.[scope_last_server_sync_timestamp], INSERTED.[scope_last_sync_duration]; "; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = scopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_schema"; p.Value = scopeInfo.Schema == null ? DBNull.Value : (object)JsonConvert.SerializeObject(scopeInfo.Schema); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_setup"; p.Value = scopeInfo.Setup == null ? DBNull.Value : (object)JsonConvert.SerializeObject(scopeInfo.Setup); p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_version"; p.Value = string.IsNullOrEmpty(scopeInfo.Version) ? DBNull.Value : (object)scopeInfo.Version; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_id"; p.Value = scopeInfo.Id; p.DbType = DbType.Guid; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync"; p.Value = scopeInfo.LastSync.HasValue ? (object)scopeInfo.LastSync.Value : DBNull.Value; p.DbType = DbType.DateTime; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync_timestamp"; p.Value = scopeInfo.LastSyncTimestamp; p.DbType = DbType.Int64; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_server_sync_timestamp"; p.Value = scopeInfo.LastServerSyncTimestamp; p.DbType = DbType.Int64; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync_duration"; p.Value = scopeInfo.LastSyncDuration; p.DbType = DbType.Int64; command.Parameters.Add(p); using (var reader = await command.ExecuteReaderAsync().ConfigureAwait(false)) { if (reader.HasRows) { while (reader.Read()) { scopeInfo.Name = reader["sync_scope_name"] as string; scopeInfo.Schema = reader["sync_scope_schema"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSet>((string)reader["sync_scope_schema"]); scopeInfo.Setup = reader["sync_scope_setup"] == DBNull.Value ? null : JsonConvert.DeserializeObject <SyncSetup>((string)reader["sync_scope_setup"]); scopeInfo.Version = reader["sync_scope_Version"] as string; scopeInfo.Id = (Guid)reader["sync_scope_id"]; scopeInfo.LastSync = reader["scope_last_sync"] != DBNull.Value ? (DateTime?)reader["scope_last_sync"] : null; scopeInfo.LastSyncTimestamp = reader["scope_last_sync_timestamp"] != DBNull.Value ? (long)reader["scope_last_sync_timestamp"] : 0; scopeInfo.LastServerSyncTimestamp = reader["scope_last_server_sync_timestamp"] != DBNull.Value ? (long)reader["scope_last_server_sync_timestamp"] : 0; scopeInfo.LastSyncDuration = reader["scope_last_sync_duration"] != DBNull.Value ? (long)reader["scope_last_sync_duration"] : 0; } } } return(scopeInfo); } catch (Exception ex) { Debug.WriteLine($"Error during CreateTableScope : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } if (command != null) { command.Dispose(); } } }
public Task <ScopeInfo> InsertOrUpdateClientScopeInfoAsync(ScopeInfo scopeInfo) => Task.FromResult(scopeInfo);
internal List<CompletionItem> GetCompletionList(CodePoint location, string idents) { ScopeInfo scopeIdentifier = new ScopeInfo(); if (!GetScopeIdentifier(location, ref scopeIdentifier)) return null; // Unknown scope. bool isStatic = false; int identifierType = GetIdentifierType(scopeIdentifier, location, idents, true, ref isStatic); if (ProtoCore.DSASM.Constants.kInvalidIndex == identifierType) return null; // No identifier of given name found in scope. return (GetClassMembers(identifierType, isStatic, scopeIdentifier)); }
public ScopeInfo(ScopeInfo parentScope) { this.Type = parentScope.Type; this.usedTypeArguments = new HashSet <string>(parentScope.usedTypeArguments); }
internal List<MethodSignature> GetMethodSignatures(CodePoint location, string idents) { ScopeInfo scopeIdentifier = new ScopeInfo(); if (!GetScopeIdentifier(location, ref scopeIdentifier)) return null; // Unknown scope. // This identifier list traversal is slightly different from the one for // 'GetCompletionList'. For example, "a.b.c.d.e.foo" where the "foo" // identifier is expected to be a method name, so the logic needs only to // traverse up to "e" to resolve its type, disregarding "foo". // bool isStatic = false; int identifierType = GetIdentifierType(scopeIdentifier, location, idents, false, ref isStatic); // If the "search site" is not within any class body/method. if (ProtoCore.DSASM.Constants.kInvalidIndex == scopeIdentifier.ClassScope) { // If the "search target" is in global scope... if (ProtoCore.DSASM.Constants.kInvalidIndex == identifierType) { // Only get those global methods that belong to the same // block as the search site (methods residing in another // block cannot be accessed within the current block). // // GetMethodSignatures(scopeIdentifier) } // If the "search target" is in a class... else { // While looking up methods of a class in a global scope, // it can at most access methods that are made public. // // GetClassMethods(identifierType, false, AccessSpecifier.kPublic, results); } } // If the "search site" is within a class body/method. else { // If user only types "foo" (instead of "a.b.foo") within a class // body/method, then look for "foo" within the current class, or // in any base classes if it can be accessed from the search site. // if (ProtoCore.DSASM.Constants.kInvalidIndex == identifierType) { } // If user types "a.b.foo", then at most public methods can be // accessed. But if user types "this.foo", then a traversal is // required up the class hierarchy to obtain methods with name "foo". else { } } return null; }
protected override void OnTranslate(ShaderTranslationContext sc, PredefinedTypeSyntax syntax, ScopeInfo scope) { string typeName = syntax.Keyword.ToString(); ShaderType type = ShaderType.TranslateType(sc, typeName); sc.Source.Append(type.Translation); }
private int GetBlockMemberType(ScopeInfo scopeIdentifier, string identifier) { int currentBlock = scopeIdentifier.BlockId; while (currentBlock != ProtoCore.DSASM.Constants.kInvalidIndex) { string[] conditions = { "Name = " + GetDatabaseType(identifier), "CodeBlock = " + currentBlock.ToString(), "ClassScope = " + scopeIdentifier.ClassScope.ToString(), "Procedure = " + scopeIdentifier.FunctionIndex.ToString() }; try { string statement = SelectFromStatement(TableNames.Symbols, conditions); SQLiteCommand command = new SQLiteCommand(statement, connection); SQLiteDataReader reader = command.ExecuteReader(); if (null != reader && (false != reader.HasRows)) { if (reader.Read()) // Read in the only record. { int dataType = reader.GetInt32(5); // "DataType" field. int staticType = reader.GetInt32(6); // "StaticType" field. return GetSymbolType(staticType, dataType); } } } catch (Exception exception) { HandleException(exception); } // Nothing found, go up to the parent block. currentBlock = GetParentBlock(currentBlock); } return ProtoCore.DSASM.Constants.kInvalidIndex; // Invalid type. }
public override void ExecuteBatchCommand(DbCommand cmd, DmTable applyTable, DmTable failedRows, ScopeInfo scope) { throw new NotImplementedException(); }
private List<CompletionItem> GetClassMembers(int classScope, bool isStatic, ScopeInfo scopeIdentifier) { if (ProtoCore.DSASM.Constants.kInvalidIndex == classScope) { string mesg = "'GetClassMembers' called for invalid class scope!"; throw new InvalidOperationException(mesg); } List<int> classesToSearch = GetAllBaseClasses(classScope); bool withinClassHierarchy = false; if (ProtoCore.DSASM.Constants.kInvalidIndex != scopeIdentifier.ClassScope) { // "scopeIdentifier" represents the scope in which AutoComplete list // has been requested, this is referred to as "search site". This line // checks to see if the search site is falling within the class // hierarchy leading up from 'classScope' (i.e. the class out of which // members are to be retrieved). // withinClassHierarchy = classesToSearch.Contains(scopeIdentifier.ClassScope); } // The resulting completion list. List<CompletionItem> results = new List<CompletionItem>(); while (classesToSearch.Count > 0) { int currentClass = classesToSearch[0]; classesToSearch.RemoveAt(0); // If the site is within a class body or class method, then the // result of searching the same class should include even the // private class properties/methods. As the search goes up to // the parent class, then search results should exclude private // properties/methods. If the search site is outside of a class // body, then only public properties/methods should be returned. // AccessSpecifier maxAllowedAccess = AccessSpecifier.kPublic; if (currentClass == classScope) { // Within the current class, allow private access. maxAllowedAccess = AccessSpecifier.kPrivate; } else if (false != withinClassHierarchy) { // Not within the 'classScope', but somewhere along // the class hierarchy, allow access to protected members. maxAllowedAccess = AccessSpecifier.kProtected; } GetClassProperties(currentClass, isStatic, maxAllowedAccess, results); GetClassMethods(currentClass, isStatic, maxAllowedAccess, results); } return results; }
public ScopeInfo InsertOrUpdateScopeInfo(ScopeInfo scopeInfo) { var command = connection.CreateCommand(); if (transaction != null) { command.Transaction = transaction; } bool alreadyOpened = connection.State == ConnectionState.Open; try { if (!alreadyOpened) { connection.Open(); } command.CommandText = $@" MERGE {scopeTableName.QuotedObjectName} AS [base] USING ( SELECT @sync_scope_id AS sync_scope_id, @sync_scope_name AS sync_scope_name, @scope_is_local as scope_is_local, @scope_last_sync AS scope_last_sync, @scope_last_sync_timestamp AS scope_last_sync_timestamp, @scope_last_sync_duration AS scope_last_sync_duration ) AS [changes] ON [base].[sync_scope_id] = [changes].[sync_scope_id] WHEN NOT MATCHED THEN INSERT ([sync_scope_name], [sync_scope_id], [scope_is_local], [scope_last_sync], [scope_last_sync_timestamp], [scope_last_sync_duration]) VALUES ([changes].[sync_scope_name], [changes].[sync_scope_id], [changes].[scope_is_local], [changes].[scope_last_sync], [changes].[scope_last_sync_timestamp], [changes].[scope_last_sync_duration]) WHEN MATCHED THEN UPDATE SET [sync_scope_name] = [changes].[sync_scope_name], [scope_is_local] = [changes].[scope_is_local], [scope_last_sync] = [changes].[scope_last_sync], [scope_last_sync_timestamp] = [changes].[scope_last_sync_timestamp], [scope_last_sync_duration] = [changes].[scope_last_sync_duration] OUTPUT INSERTED.[sync_scope_name], INSERTED.[sync_scope_id], INSERTED.[scope_timestamp], INSERTED.[scope_is_local], INSERTED.[scope_last_sync], INSERTED.[scope_last_sync_timestamp], INSERTED.[scope_last_sync_duration]; "; var p = command.CreateParameter(); p.ParameterName = "@sync_scope_name"; p.Value = scopeInfo.Name; p.DbType = DbType.String; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@sync_scope_id"; p.Value = scopeInfo.Id; p.DbType = DbType.Guid; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_is_local"; p.Value = scopeInfo.IsLocal; p.DbType = DbType.Boolean; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync"; p.Value = scopeInfo.LastSync.HasValue ? (object)scopeInfo.LastSync.Value : DBNull.Value; p.DbType = DbType.DateTime; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync_timestamp"; p.Value = scopeInfo.LastSyncTimestamp; p.DbType = DbType.Int64; command.Parameters.Add(p); p = command.CreateParameter(); p.ParameterName = "@scope_last_sync_duration"; p.Value = scopeInfo.LastSyncDuration; p.DbType = DbType.Int64; command.Parameters.Add(p); using (DbDataReader reader = command.ExecuteReader()) { while (reader.Read()) { scopeInfo.Name = reader["sync_scope_name"] as String; scopeInfo.Id = (Guid)reader["sync_scope_id"]; scopeInfo.Timestamp = SqlManager.ParseTimestamp(reader["scope_timestamp"]); scopeInfo.IsLocal = (bool)reader["scope_is_local"]; scopeInfo.LastSync = reader["scope_last_sync"] != DBNull.Value ? (DateTime?)reader["scope_last_sync"] : null; scopeInfo.LastSyncTimestamp = reader["scope_last_sync_timestamp"] != DBNull.Value ? (long)reader["scope_last_sync_timestamp"] : 0; scopeInfo.LastSyncDuration = reader["scope_last_sync_duration"] != DBNull.Value ? (long)reader["scope_last_sync_duration"] : 0; } } return(scopeInfo); } catch (Exception ex) { Debug.WriteLine($"Error during CreateTableScope : {ex}"); throw; } finally { if (!alreadyOpened && connection.State != ConnectionState.Closed) { connection.Close(); } if (command != null) { command.Dispose(); } } }
internal int GetArrayElementType(ScopeInfo scopeInfo, string[] identList) { if (null == arrayTypeTable) return ((int)PrimitiveType.kInvalidType); string arrayName = identList[0]; foreach (KeyValuePair<ScopedArray, ArrayElementType> arrayType in arrayTypeTable) { if (arrayType.Key.ScopeInfo == scopeInfo) { if (arrayType.Key.ArrayName == arrayName) { ArrayElementType arrayRoot = arrayType.Value; ArrayElementType element = arrayRoot.GetElementFromIndices(identList); if (null != element) return element.Type.UID; } } } return ((int)PrimitiveType.kInvalidType); }
protected override void OnTranslate(ShaderTranslationContext sc, AccessorDeclarationSyntax syntax, ScopeInfo scope) { if (scope.Type == ScopeType.Property) { switch (syntax.Keyword.ValueText) { case "get": sc.Source.Append($"{scope.TypeInfo.Translation} get{scope.Identifier}()"); break; case "set": sc.Source.Append($"void set{scope.Identifier}({scope.TypeInfo.Translation} value)"); break; } ScopeInfo mScope = sc.Source.OpenScope(ScopeType.Method); ScopeInfo classScope = scope.FindOfType(ScopeType.Class); mScope.Method = classScope.TypeInfo.OriginalType.GetMethod($"{syntax.Keyword.ValueText}_{scope.Identifier}"); } }
private Scope _parent; //computed on demand public Scope(ScopeInfo scopeInfo, Scope caller, Scope creator, object[] parameters) : base(scopeInfo) { Caller = caller; Creator = creator; Parameters = parameters; }
protected override void OnTranslate(ShaderTranslationContext sc, VariableDeclaratorSyntax syntax, ScopeInfo scope) { if (scope.Type == ScopeType.Typed) { FieldInfo fInfo = null; MappedField mField = null; MappedConstantBuffer cBufferMap = null; if (scope.Parent.Type == ScopeType.Struct) { fInfo = scope.Parent.TypeInfo.OriginalType.GetField(syntax.Identifier.ValueText); sc.ConstantBuffers.TryGetValue(scope.Parent.TypeInfo.OriginalType.Name, out cBufferMap); } if (fInfo == null) { sc.Fields.TryGetValue(syntax.Identifier.ValueText, out fInfo); } if (fInfo != null) { int fieldIndex = scope.Items.IndexOf(syntax); mField = Pooling.MappedFields.Get(); mField.Initialize(scope.TypeInfo, fInfo); cBufferMap?.AddField(mField); sc.Language.TranslateFieldPrefix(sc, syntax, mField, fieldIndex, cBufferMap); sc.Source.Append($"{scope.TranslatedModifiers} "); sc.Source.Append(scope.TypeInfo.Translation); sc.Source.Append($" {syntax.Identifier.ValueText}"); sc.Language.TranslateFieldPostfix(sc, syntax, mField, fieldIndex, cBufferMap); } else { sc.Source.Append($"{scope.TranslatedModifiers} "); sc.Source.Append(scope.TypeInfo.Translation); sc.Source.Append($" {syntax.Identifier.ValueText}"); } // Handle corner-cases for array initializers. if (scope.TypeInfo != null && syntax.Initializer != null) { if (scope.TypeInfo.WasArrayType) { switch (syntax.Initializer.Value) { case InitializerExpressionSyntax initSyntax: IEnumerable <SyntaxNode> initChildren = initSyntax.ChildNodes(); int arraySize = initChildren.Count(); sc.Source.Append($"[{arraySize}]"); if (mField != null) { mField.ArrayDimensions.Add(arraySize); } // TODO multi-dimensional array support (e.g. [4][2]). // - For multi-dimensional arrays, we can simply take the dimensions directly. // - For jagged arrays, we need to find the largest sub-array and use that as the size for it's respective dimension. break; case ArrayCreationExpressionSyntax arraySyntax: sc.Runner.Translate(sc, arraySyntax.Type); break; } } } bool isForInitializer = (syntax.Parent is VariableDeclarationSyntax varDecSyntax && varDecSyntax.Parent is ForStatementSyntax forSyntax); if (!isForInitializer) { if (syntax.Initializer != null && syntax.Initializer.Value is ObjectCreationExpressionSyntax objSyntax && objSyntax.Initializer != null) { ScopeInfo si = sc.Source.OpenScope(ScopeType.ExpandedInitializer); si.Identifier = syntax.Identifier.ValueText; sc.Source.Append(" = "); // Are we instantiating a new struct value with no args? if (objSyntax.ArgumentList.Arguments.Count == 0 && scope.TypeInfo.OriginalType.IsValueType) { sc.Source.Append($"({scope.TypeInfo.Translation})0;"); // TODO does GLSL allow this? Do we abstract or add a language property to check against? sc.Source.AppendLineBreak(); sc.Complete(objSyntax.ArgumentList); sc.Complete(objSyntax.Type); } else { sc.Source.Append(scope.TypeInfo.Translation); sc.Runner.Translate(sc, objSyntax.ArgumentList); sc.Source.Append(";"); sc.Source.AppendLineBreak(); sc.Runner.Translate(sc, objSyntax.Initializer); sc.Complete(objSyntax.ArgumentList); sc.Complete(objSyntax.Type); } // We no longer need to translate the object creation syntax, but we still want it's initializer. sc.Complete(syntax.Initializer); sc.Runner.Translate(sc, objSyntax.Initializer); } else { ScopeInfo si = sc.Source.OpenScope(ScopeType.Variable); si.Identifier = syntax.Identifier.ValueText; } } }
public void PushClosureScope(ScopeInfo scopeInfo, Scope closureParent, object[] parameters) { CurrentScope = new Scope(scopeInfo, CurrentScope, closureParent, parameters); }
public override bool CheckInvocation(TexlBinding binding, TexlNode[] args, DType[] argTypes, IErrorContainer errors, out DType returnType, out Dictionary <TexlNode, DType> nodeToCoercedTypeMap) { Contracts.AssertValue(args); Contracts.AssertValue(argTypes); Contracts.Assert(args.Length == argTypes.Length); Contracts.AssertValue(errors); Contracts.Assert(MinArity <= args.Length && args.Length <= MaxArity); bool fArgsValid = base.CheckInvocation(args, argTypes, errors, out returnType, out nodeToCoercedTypeMap); // The first arg determines the scope type for the lambda params, and the return type. DType typeScope; fArgsValid &= ScopeInfo.CheckInput(args[0], argTypes[0], errors, out typeScope); Contracts.Assert(typeScope.IsRecord); // The result type has N additional columns, as specified by (args[1],args[2]), (args[3],args[4]), ... etc. returnType = typeScope.ToTable(); int count = args.Length; if ((count & 1) == 0) { errors.EnsureError(DocumentErrorSeverity.Severe, args[0].Parent.CastList().Parent.CastCall(), TexlStrings.ErrBadArityOdd, count); } for (var i = 1; i < count; i += 2) { TexlNode nameArg = args[i]; DType nameArgType = argTypes[i]; // Verify we have a string literal for the column name. Accd to spec, we don't support // arbitrary expressions that evaluate to string values, because these values contribute to // type analysis, so they need to be known upfront (before AddColumns executes). StrLitNode nameNode; if (nameArgType.Kind != DKind.String || (nameNode = nameArg.AsStrLit()) == null) { fArgsValid = false; errors.EnsureError(DocumentErrorSeverity.Severe, nameArg, TexlStrings.ErrExpectedStringLiteralArg_Name, nameArg.ToString()); continue; } // Verify that the name is valid. if (!DName.IsValidDName(nameNode.Value)) { fArgsValid = false; errors.EnsureError(DocumentErrorSeverity.Severe, nameArg, TexlStrings.ErrArgNotAValidIdentifier_Name, nameNode.Value); continue; } DName columnName = new DName(nameNode.Value); string colName; if (DType.TryGetDisplayNameForColumn(typeScope, columnName, out colName)) { columnName = new DName(colName); } // Verify that the name doesn't already exist as either a logical or display name DType columnType; string unused; if (typeScope.TryGetType(columnName, out columnType) || DType.TryGetLogicalNameForColumn(typeScope, columnName, out unused)) { fArgsValid = false; errors.EnsureError(DocumentErrorSeverity.Moderate, nameArg, TexlStrings.ErrColExists_Name, columnName); continue; } if (i + 1 >= count) { break; } columnType = argTypes[i + 1]; // Augment the result type to include the specified column, and verify that it // hasn't been specified already within the same invocation. bool fError = false; returnType = returnType.Add(ref fError, DPath.Root, columnName, columnType); if (fError) { fArgsValid = false; errors.EnsureError(DocumentErrorSeverity.Moderate, nameArg, TexlStrings.ErrColConflict_Name, columnName); continue; } } return(fArgsValid); }
protected override void DfsTraverse(ProtoCore.AST.Node pNode, ref ProtoCore.Type inferedType, bool isBooleanOp = false, ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone) { AssociativeNode node = pNode as AssociativeNode; if ((null == node) || node.skipMe) return; if (node is IdentifierNode) { EmitIdentifierNode(node, ref inferedType, isBooleanOp, graphNode, subPass); } else if (node is IntNode) { EmitIntNode(node, ref inferedType, isBooleanOp, subPass); } else if (node is DoubleNode) { EmitDoubleNode(node, ref inferedType, isBooleanOp, subPass); } else if (node is BooleanNode) { EmitBooleanNode(node, ref inferedType, subPass); } else if (node is CharNode) { EmitCharNode(node, ref inferedType, isBooleanOp, subPass); } else if (node is StringNode) { EmitStringNode(node, ref inferedType, subPass); } else if (node is NullNode) { EmitNullNode(node, ref inferedType, isBooleanOp, subPass); } #if ENABLE_INC_DEC_FIX else if (node is PostFixNode) { EmitPostFixNode(node, ref inferedType); } #endif else if (node is ReturnNode) { EmitReturnNode(node); } else if (node is RangeExprNode) { EmitRangeExprNode(node, ref inferedType, subPass); } else if (node is ForLoopNode) { EmitForLoopNode(node); } else if (node is LanguageBlockNode) { EmitLanguageBlockNode(node, ref inferedType, subPass); } else if (node is ClassDeclNode) { EmitClassDeclNode(node, ref inferedType, subPass); } else if (node is ConstructorDefinitionNode) { EmitConstructorDefinitionNode(node, ref inferedType, subPass); } else if (node is FunctionDefinitionNode) { EmitFunctionDefinitionNode(node, ref inferedType, subPass); } else if (node is FunctionCallNode) { EmitFunctionCallNode(node, ref inferedType, isBooleanOp, graphNode, subPass); } else if (node is ModifierStackNode) { EmitModifierStackNode(node, ref inferedType); } else if (node is ExprListNode) { ScopedArray scopedArray = null; ArrayElementType parentElementType = this.arrayElementType; // The same code is parsed in multiple passes, don't populate array element type table all // the times, we should only do it when all things are parsed. bool generateArrayElementTypes = subPass == ProtoCore.DSASM.AssociativeSubCompilePass.kNone; if (generateArrayElementTypes && (null != CoreCodeGen.arrayTypeTable)) { ScopeInfo scopeInfo = new ScopeInfo() { // For global scope, "localProcedure" will be of null value. BlockId = ((null == localProcedure) ? 0 : localProcedure.runtimeIndex), ClassScope = ((null == localProcedure) ? -1 : localProcedure.classScope), FunctionIndex = ((null == localProcedure) ? -1 : localProcedure.procId) }; node.Name = node.Name == null ? string.Empty : node.Name; if (null != parentElementType || (!string.IsNullOrEmpty(node.Name))) { scopedArray = new ScopedArray(scopeInfo, node.Name); this.arrayElementType = new ArrayElementType(); } } EmitExprListNode(node, ref inferedType, graphNode, subPass); if (generateArrayElementTypes && (null != CoreCodeGen.arrayTypeTable)) { if (null == parentElementType) { CoreCodeGen.arrayTypeTable.InsertRootElementType( scopedArray, this.arrayElementType); this.arrayElementType = null; } else { parentElementType.AppendChild(this.arrayElementType); this.arrayElementType = parentElementType; } } } else if (node is IdentifierListNode) { EmitIdentifierListNode(node, ref inferedType, isBooleanOp, graphNode, subPass); } else if (node is IfStatementNode) { EmitIfStatementNode(node, ref inferedType); } else if (node is InlineConditionalNode) { EmitInlineConditionalNode(node, ref inferedType, graphNode, subPass); } else if (node is UnaryExpressionNode) { EmitUnaryExpressionNode(node, ref inferedType, graphNode); } else if (node is BinaryExpressionNode) { EmitBinaryExpressionNode(node, ref inferedType, isBooleanOp, graphNode, subPass); } else if (node is ImportNode) { EmitImportNode(node, ref inferedType, subPass); } else if (node is ExceptionHandlingNode) { EmitExceptionHandlingNode(node, graphNode, subPass); } else if (node is ThrowNode) { } }
private int GetClassMemberType(ScopeInfo scopeIdentifier, string identifier, bool isStatic) { // The identifier is within a class body, having a name // "this" would have made its type the same as the class. if (identifier == "this") return scopeIdentifier.ClassScope; List<int> classesToSearch = GetAllBaseClasses(scopeIdentifier.ClassScope); while (classesToSearch.Count > 0) { int currentClass = classesToSearch[0]; classesToSearch.RemoveAt(0); string[] conditions = { "Name = " + GetDatabaseType(identifier), "CodeBlock = " + scopeIdentifier.BlockId.ToString(), "ClassScope = " + currentClass.ToString(), "Procedure = " + scopeIdentifier.FunctionIndex.ToString(), "IsStatic = " + GetDatabaseType(isStatic) }; try { string statement = SelectFromStatement(TableNames.Symbols, conditions); SQLiteCommand command = new SQLiteCommand(statement, connection); SQLiteDataReader reader = command.ExecuteReader(); if (null != reader && (false != reader.HasRows)) { if (reader.Read()) // Read in the only record. { int dataType = reader.GetInt32(5); // "DataType" field. int staticType = reader.GetInt32(6); // "StaticType" field. return GetSymbolType(staticType, dataType); } } } catch (Exception exception) { HandleException(exception); } // The procedure ID is only applicable to the current class, as we // proceed to check in base classes, we will not need the procedure // ID as it won't be applicable there (even if another procedure with // the same ID exists in that parent class). So we'll just set it to // an invalid value. The same rule applies to a block (it is possible // to have a block embedded within a class member function, in which // case the block will not be zero). // scopeIdentifier.BlockId = 0; scopeIdentifier.FunctionIndex = ProtoCore.DSASM.Constants.kInvalidIndex; } return ProtoCore.DSASM.Constants.kInvalidIndex; // Invalid type. }
protected override void OnTranslate(ShaderTranslationContext sc, FieldDeclarationSyntax syntax, ScopeInfo scope) { // Does the language allow instanced constant buffers and does the field use a constant buffer struct type? if (sc.ConstantBuffers.ContainsKey(syntax.Declaration.Type.ToString())) { if (!sc.Language.InstancedConstantBuffers) { sc.CompleteSelfAndChildren(syntax); } } else { sc.CompleteSelfAndChildren(syntax.AttributeLists); } }
internal ScopedArray(ScopeInfo scopeInfo, string name) { this.arrayName = name; this.scopeInfo = scopeInfo; }
private int GetIdentifierType(ScopeInfo scopeIdentifier, CodePoint location, string identifier, bool includeLastIdent, ref bool isStatic) { isStatic = false; if (string.IsNullOrEmpty(identifier)) return ProtoCore.DSASM.Constants.kInvalidIndex; // Split the identifier list (e.g. "a.b.c" -> { "a", "b", "c" }) char[] seperator = { '.' }; string[] idents = identifier.Split(seperator, StringSplitOptions.RemoveEmptyEntries); if (null == idents || (idents.Length <= 0)) return ProtoCore.DSASM.Constants.kInvalidIndex; // The caller may choose to drop the last identifier in the list, if // it represents a method name. For example, "a.b.foo", the search // only goes up to determine the type of "b" while disregarding "foo". if (false == includeLastIdent) { List<string> intermediate = idents.ToList(); intermediate.RemoveAt(intermediate.Count - 1); if (intermediate.Count <= 0) return ProtoCore.DSASM.Constants.kInvalidIndex; idents = idents.ToArray(); } // First we need to find out the type of the "root // variable". For example, "a" in the case of "a.b.c". // string rootIdentifier = idents[0]; int rootType = ProtoCore.DSASM.Constants.kInvalidIndex; if (ProtoCore.DSASM.Constants.kInvalidIndex != scopeIdentifier.ClassScope) { // If this symbol is in a language block within a class definition... if (scopeIdentifier.BlockId != 0) rootType = GetBlockMemberType(scopeIdentifier, rootIdentifier); // This identifier is found within a class definition region. if (ProtoCore.DSASM.Constants.kInvalidIndex == rootType) rootType = GetClassMemberType(scopeIdentifier, rootIdentifier, isStatic); } else { // For identifiers found outside of the class definition region... rootType = GetBlockMemberType(scopeIdentifier, rootIdentifier); } // It seems like the identifier does not correspond to a valid variable // name given the scope it resides in. Check to see if it represents the // name of an existing class. if (ProtoCore.DSASM.Constants.kInvalidIndex == rootType) { bool isImported = false; rootType = GetClassScopeFromName(rootIdentifier, ref isImported); if (ProtoCore.DSASM.Constants.kInvalidIndex == rootType) return ProtoCore.DSASM.Constants.kInvalidIndex; // We have found a class with name matching "rootIdentifier", // which means the subsequent identifier(s) is a static member. isStatic = true; } int finalType = ProtoCore.DSASM.Constants.kInvalidIndex; for (int index = 1; index < idents.Length; ++index) { string ident = idents[index]; finalType = GetClassMemberType(scopeIdentifier, ident, isStatic); if (ProtoCore.DSASM.Constants.kInvalidIndex == finalType) return ProtoCore.DSASM.Constants.kInvalidIndex; isStatic = false; // Can't be static after the root level. } return finalType; }
public void PushScope(ScopeInfo scopeInfo, object[] parameters) { CurrentScope = new Scope(scopeInfo, CurrentScope, CurrentScope, parameters); }
private MethodSignature GetMethodSignature(ScopeInfo methodScope, string methodName) { // @TODO(Ben): Remove these comments. // // 0 "CodeBlock INTEGER", // 1 "ClassScope INTEGER", // 2 "Procedure INTEGER", // 3 "Name NCHAR(255)", // 4 "AccessSpec INTEGER", // 5 "DataType INTEGER", // 6 "StaticType INTEGER", // 7 "IsArgument BOOLEAN", // 8 "IsArray BOOLEAN", // 9 "IsStatic BOOLEAN", // 10 "IsTemporary BOOLEAN" // // 11 "Id INTEGER PRIMARY KEY", // 12 "IsIndexable BOOLEAN", // 13 "Name NCHAR(255)", // 14 "Rank INTEGER" string[] conditions = { "CodeBlock = " + methodScope.BlockId.ToString(), "ClassScope = " + methodScope.ClassScope.ToString(), "Procedure = " + methodScope.FunctionIndex.ToString() }; string[] joints = { "s.StaticType = t.Id" }; MethodSignature signature = new MethodSignature(methodName); try { string leftTable = TableNames.Symbols + " s"; string rightTable = TableNames.DataTypes + " t"; string statement = SelectJoinStatement(leftTable, rightTable, joints, conditions); SQLiteCommand command = new SQLiteCommand(statement, connection); SQLiteDataReader reader = command.ExecuteReader(); if (null != reader && (false != reader.HasRows)) { while (reader.Read()) { // "s.Name", "t.Name" and no default argument. signature.AddArgument(reader.GetString(3), reader.GetString(13), null); } } } catch (Exception exception) { HandleException(exception); } return null; }
/// <summary> /// Returns all of the script IDs for the class /// </summary> /// <param name="javascriptClass">The text handler that has the class's javascript</param> /// <param name="subProcess">The process that must have the given script loaded</param> /// <returns></returns> public ScopeInfo GetScopeInfoForClass(ITextHandler javascriptClass, SubProcess subProcess) { DateTime javascriptLastModified = javascriptClass.FileContainer.LastModified; ScopeInfo toReturn = null; using (TimedLock.Lock(ScopeInfoCache)) ScopeInfoCache.TryGetValue(javascriptClass.FileContainer.FileId, out toReturn); if (null != toReturn) if (toReturn.JavascriptLastModified == javascriptLastModified) { using (TimedLock.Lock(PrecompiledScriptDataByID)) foreach (int scriptID in toReturn.ScriptsAndIDsToBuildScope) subProcess.LoadCompiled( Thread.CurrentThread.ManagedThreadId, PrecompiledScriptDataByID[scriptID], scriptID); return toReturn; } string javascript = javascriptClass.ReadAll(); string fileType = null; List<int> scriptIDsToBuildScope = new List<int>(); ISession ownerSession = FileHandlerFactoryLocator.SessionManagerHandler.CreateSession(); try { ownerSession.Login(javascriptClass.FileContainer.Owner); IWebConnection ownerWebConnection = new BlockingShellWebConnection( FileHandlerFactoryLocator.WebServer, ownerSession, javascriptClass.FileContainer.FullPath, null, null, new CookiesFromBrowser(), CallingFrom.Web, WebMethod.GET); IEnumerable<ScriptAndMD5> dependantScriptsAndMD5s = FileHandlerFactoryLocator.WebServer.WebComponentResolver.DetermineDependantScripts( GetRequiredScriptURLs(javascriptClass, out fileType), ownerWebConnection); // Load static methods that are passed into the Javascript environment as-is Dictionary<string, MethodInfo> functionsInScope = SubProcessFactory.GetFunctionsForFileType(fileType); // Load all dependant scripts foreach (ScriptAndMD5 dependantScript in dependantScriptsAndMD5s) { int scriptID = GetScriptID( dependantScript.ScriptName + "___" + ownerSession.User.Identity, dependantScript.MD5, dependantScript.Script, subProcess); scriptIDsToBuildScope.Add(scriptID); } // Construct Javascript to shell to the "base" webHandler Set<Type> webHandlerTypes = new Set<Type>(FileHandlerFactoryLocator.WebHandlerPlugins); if (null != fileType) webHandlerTypes.Add(FileHandlerFactoryLocator.WebHandlerClasses[fileType]); string baseWrapper = GetJavascriptWrapperForBase("base", webHandlerTypes); scriptIDsToBuildScope.Add( GetScriptID( javascriptClass.FileContainer.FullPath + "___" + "serversideBaseWrapper", StringParser.GenerateMD5String(baseWrapper), baseWrapper, subProcess)); // Get the ID for the actual javascript scriptIDsToBuildScope.Add( GetScriptID( javascriptClass.FileContainer.FullPath, StringParser.GenerateMD5String(javascript), javascript, subProcess)); // Add a little shunt to return information about the options scriptIDsToBuildScope.Add( GetScriptID( "____scopeshunt", "xxx", "\nif (this.options) options; else null;", subProcess)); toReturn = new ScopeInfo( javascriptLastModified, functionsInScope, scriptIDsToBuildScope); using (TimedLock.Lock(ScopeInfoCache)) ScopeInfoCache[javascriptClass.FileContainer.FileId] = toReturn; return toReturn; } finally { FileHandlerFactoryLocator.SessionManagerHandler.EndSession(ownerSession.SessionId); } }
private void GetMethodSignatures(ScopeInfo scopeIdentifier, bool isStatic, string name, AccessSpecifier maxAllowedAccess, List<MethodSignature> results) { // Searching for a named method(s) in a given class (goes way up in hierarchy). if (ProtoCore.DSASM.Constants.kInvalidIndex != scopeIdentifier.ClassScope) { List<int> classesToSearch = GetAllBaseClasses(scopeIdentifier.ClassScope); while (classesToSearch.Count > 0) { int currentClass = classesToSearch[0]; classesToSearch.RemoveAt(0); // 0 "CodeBlock INTEGER", // 1 "ClassScope INTEGER", // 2 "Procedure INTEGER", // 3 "Name NCHAR(255)", // 4 "AccessSpec INTEGER", // 5 "ReturnType INTEGER", // 6 "IsExternal BOOLEAN", // 7 "IsStatic BOOLEAN", // 8 "IsConstructor BOOLEAN" // // 9 "Id INTEGER PRIMARY KEY", // 10 "IsIndexable BOOLEAN", // 11 "Name NCHAR(255)", // 12 "Rank INTEGER" string[] conditions = { "CodeBlock = 0", "ClassScope = " + currentClass.ToString(), "Name = " + GetDatabaseType(name), "AccessSpec <= " + ((int)maxAllowedAccess).ToString(), "IsStatic = " + GetDatabaseType(isStatic) }; string[] joints = { "p.ReturnType = t.Id" }; try { string leftTable = TableNames.Procedures + " p"; string rightTable = TableNames.DataTypes + " t"; string statement = SelectJoinStatement( leftTable, rightTable, joints, conditions); SQLiteCommand command = new SQLiteCommand(statement, connection); SQLiteDataReader reader = command.ExecuteReader(); if (null != reader && (false != reader.HasRows)) { while (reader.Read()) { ScopeInfo methodScope = new ScopeInfo() { BlockId = 0, ClassScope = currentClass, FunctionIndex = reader.GetInt32(2) // "p.Procedure" field. }; MethodSignature signature = GetMethodSignature(methodScope, name); if (null == signature) continue; signature.ReturnType = reader.GetString(11); // "t.Name" field. signature.IsProperty = false; signature.IsExternal = reader.GetBoolean(6); // "IsExternal" field. signature.IsStatic = reader.GetBoolean(7); // "IsStatic" field. signature.Access = ((AccessSpecifier)reader.GetInt32(4)); // "AccessSpec" field. if (reader.GetBoolean(8)) // "IsConstructor" field. signature.IsConstructor = true; else signature.IsMethod = true; results.Add(signature); } } } catch (Exception exception) { HandleException(exception); } // While the search moves up the class hierarchy, access will // turn from "private" to "protected". If the 'maxAllowedAccess' // was "public" to begin with, then it stays as "public". // if (maxAllowedAccess == AccessSpecifier.kPrivate) maxAllowedAccess = AccessSpecifier.kProtected; } } else { // Looking for a global method in scope with the given name. } }
private bool GetScopeIdentifier(CodePoint location, ref ScopeInfo scopeIdentifier) { string[] conditions = { "StartLine <= " + location.LineNo.ToString(), "EndLine >= " + location.LineNo.ToString() }; Dictionary<ScopeInfo, CodeRange> scopeIdentifiers = null; try { string statement = SelectFromStatement(TableNames.ScopeRanges, conditions); SQLiteCommand command = new SQLiteCommand(statement, connection); SQLiteDataReader reader = command.ExecuteReader(); if (null == reader || (false == reader.HasRows)) return false; // No record was found matching. while (reader.Read()) { int startLine = reader.GetInt32(1); int startColumn = reader.GetInt32(2); int endLine = reader.GetInt32(3); int endColumn = reader.GetInt32(4); bool withinRange = true; if (location.LineNo == startLine && (location.CharNo < startColumn)) withinRange = false; else if (location.LineNo == endLine && (location.CharNo >= endColumn)) withinRange = false; if (false == withinRange) continue; if (null == scopeIdentifiers) scopeIdentifiers = new Dictionary<ScopeInfo, CodeRange>(); string path = GetScriptPath(reader.GetInt32(0)); ScopeInfo scope = new ScopeInfo() { BlockId = reader.GetInt32(5), ClassScope = reader.GetInt32(6), FunctionIndex = reader.GetInt32(7) }; CodeRange range = MakeCodeRange(startLine, startColumn, endLine, endColumn, path); scopeIdentifiers.Add(scope, range); } } catch (Exception exception) { HandleException(exception); return false; } if (null == scopeIdentifiers || (scopeIdentifiers.Count <= 0)) return false; // Attempt to find the inner-most scope by seeing // if one scope completely contains another scope. // bool foundInnerMostScope = false; CodeRange innerMostScope = new CodeRange(); foreach (var identifier in scopeIdentifiers) { if (false == foundInnerMostScope) { innerMostScope = identifier.Value; scopeIdentifier = identifier.Key; foundInnerMostScope = true; continue; } if (innerMostScope.InsideRange(identifier.Value)) { innerMostScope = identifier.Value; scopeIdentifier = identifier.Key; } } return foundInnerMostScope; }
internal void AddScopeIdentifier(int blockId, int classId, int procId, int startLine, int startColumn, int endLine, int endColumn, string scriptPath) { // Generated methods, built-in functions, class getters/setters // have no valid source location information, skip processing them. if (startLine < 0 || (startColumn < 0) || endLine < 0 || (endColumn < 0)) return; if (null == scopeIdentifiers) scopeIdentifiers = new Dictionary<ScopeInfo, CodeRange>(); ScopeInfo scope = new ScopeInfo() { BlockId = blockId, ClassScope = classId, FunctionIndex = procId }; if (scopeIdentifiers.ContainsKey(scope)) throw new InvalidOperationException("No two scopes should be identical!"); scopeIdentifiers[scope] = SymbolDatabaseProxy.MakeCodeRange( startLine, startColumn, endLine, endColumn, scriptPath); }