Merge from branch giga

StgSharp.Model/Step/Analyser/ExpSyntaxAnalyzer.Common.cs

@@ -44,14 +44,16 @@ using System.Xml.Schema;
 
 using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     internal partial class StepExpSyntaxAnalyzer
     {
 
         private static Regex _entityTypeCheckPattern = GetEntityTypeCheckPattern();
 
-        [GeneratedRegex( @"^[A-Z_]+$", RegexOptions.Singleline )]
+        private StepDependencyDetector _dependencyDetector = new StepDependencyDetector();
+
+        [GeneratedRegex( @"^[A-Z0-9_]+$", RegexOptions.Singleline )]
         private static partial Regex GetEntityTypeCheckPattern();
 
         private bool IsSeparatorMatch( Token leftSeparator, Token rightSeparator )
@@ -147,10 +149,16 @@ namespace StgSharp.Modeling.Step
                     goto case 1;
                 case 1:
                     _cache.PopOperand( out _, out ExpSyntaxNode? statement );
-                    _cache.StatementsInDepth.Push( statement );
-                    if( t.Value == ";" ) {
-                        StepEntityInitStatements.Enqueue( statement );
+                    if( t.Value == ";" )
+                    {
+                        StepEntityDefineSequence sequence = new StepEntityDefineSequence(
+                            statement, _dependencyDetector.ExportAllDependencies() );
+                        StepEntityInitStatements.Enqueue( sequence );
+                    } else
+                    {
+                        _cache.StatementsInDepth.Push( statement );
                     }
+
                     return true;
                 default:
                     ExpInvalidSyntaxException.ThrowNoOperator( t );
@@ -213,6 +221,12 @@ namespace StgSharp.Modeling.Step
         {
             switch( t.Value )
             {
+                case "$":
+                    _cache.PushOperand( StepEntityInstanceNode.RegisterNull( t ) );
+                    return true;
+                case "*":
+                    _cache.PushOperand( StepEntityInstanceNode.RegisterRuntimeInference( t ) );
+                    return true;
                 case ExpKeyword.E:
                     _cache.PushOperand( new ExpRealNumberNode( t, MathF.E, true ) );
                     return true;
@@ -246,8 +260,15 @@ namespace StgSharp.Modeling.Step
 
         private bool TryParseFunction( Token t )
         {
-            if( _entityTypeCheckPattern.IsMatch( t.Value ) ) {
+            if( _entityTypeCheckPattern.IsMatch( t.Value ) )
+            {
+                if( _cache.PeekOperator().Flag == TokenFlag.Member )
+                {
+                    Token op = _cache.PopOperator();
+                    ConvertAndPushOneOperator( op );
+                }
                 _cache.PushOperator( t );
+                return true;
             }
             return false;
         }
@@ -256,7 +277,11 @@ namespace StgSharp.Modeling.Step
         {
             if( t.Value[ 0 ] == '#' )
             {
-                _cache.PushOperand( StepEntityInstanceNode.Register( t ) );
+                StepEntityInstanceNode node = StepEntityInstanceNode.Register( t );
+                if( t.Column != 0 ) {
+                    _dependencyDetector.AddDependency( node );
+                }
+                _cache.PushOperand( node );
                 return true;
             }
             return false;

StgSharp.Model/Step/Analyser/ExpSyntaxAnalyzer.ErrorProcess.cs

@@ -34,7 +34,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     internal partial class StepExpSyntaxAnalyzer
     {

StgSharp.Model/Step/Analyser/ExpSyntaxAnalyzer.OperatorParser.cs

@@ -28,7 +28,6 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step.SyntaxNode;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
@@ -40,7 +39,7 @@ using System.Threading.Tasks;
 
 using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     internal partial class StepExpSyntaxAnalyzer
     {
@@ -92,7 +91,7 @@ namespace StgSharp.Modeling.Step
                     _cache.PopOperand( out _, out ExpSyntaxNode? p );
                     StepEntityInitCaller caller = StepEntityInitCaller.CreateCaller( op.Value );
                     node = ExpFunctionCallingNode.CallFunction( op, caller, p );
-                    _cache.PushOperand( node );
+                    _cache.StatementsInDepth.Push( node );
                     return node;
                 default:
                     throw new NotImplementedException();
@@ -101,43 +100,27 @@ namespace StgSharp.Modeling.Step
 
         private bool TryGenerateBinaryNode( Token t, out ExpSyntaxNode node )
         {
+            /*
             ExpSyntaxNode right = GetNextOperandCache();
             ExpSyntaxNode left = GetNextOperandCache();
+            /**/
             switch( t.Value )
             {
-                case ExpKeyword.Add:
-                    node = ExpBinaryOperatorNode.Add( t, left, right );
-                    return true;
-                case ExpKeyword.Sub:
-                    node = ExpBinaryOperatorNode.Sub( t, left, right );
-                    return true;
-                case ExpKeyword.Mul:
-                    node = ExpBinaryOperatorNode.Mul( t, left, right );
-                    return true;
-                case ExpKeyword.Div:
-                    node = ExpBinaryOperatorNode.Div( t, left, right );
-                    return true;
-                case ExpKeyword.Equal:
-                    node = ExpBinaryOperatorNode.EqualTo( t, left, right );
-                    return true;
-                case ExpKeyword.NotEqual:
-                    node = ExpBinaryOperatorNode.NotEqualTo( t, left, right );
-                    return true;
-                case ExpKeyword.GreaterThan:
-                    node = ExpBinaryOperatorNode.GreaterThan( t, left, right );
-                    return true;
-                case ExpKeyword.LessThan:
-                    node = ExpBinaryOperatorNode.LessThan( t, left, right );
-                    return true;
-                case ExpKeyword.Assignment:
+                case "=":
+                    ExpSyntaxNode right = GetNextOperandCache();
+                    ExpSyntaxNode left;
+                    if( right is ExpTupleNode tuple )
+                    {
+                        right = StepComplexEntityNode.FromTuple( tuple );
+                        left = GetNextOperandCache();
+                    } else
+                    {
+                        left = right;
+                        right = _cache.StatementsInDepth.Pop();
+                    }
+
                     node = ExpBinaryOperatorNode.Assign( t, left, right );
                     return true;
-                case ExpKeyword.InstanceEqual:
-                    node = ExpBinaryOperatorNode.CompareInstanceEqual( t, left, right );
-                    return true;
-                case ExpKeyword.InstanceNotEqual:
-                    node = ExpBinaryOperatorNode.CompareInstanceNotEqual( t, left, right );
-                    return true;
                 default:
                     node = ExpSyntaxNode.Empty;
                     return false;

StgSharp.Model/Step/Analyser/ExpSyntaxAnalyzer.PrefixReverseAnalysing.cs

@@ -40,7 +40,7 @@ using System.Threading.Tasks;
 
 using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     internal partial class StepExpSyntaxAnalyzer
     {
@@ -57,15 +57,19 @@ namespace StgSharp.Modeling.Step
                     _cache.StatementsInDepth.Push( statement );
                 } else
                 {
-                    ExpInvalidSyntaxException.ThrowNoOperator( rightSeparator );
+                    _cache.StatementsInDepth.Push( ExpSyntaxNode.Empty );
                 }
             } else
             {
-                while( _cache.TryPopOperator( out op ) ) {
-                    ConvertAndPushOneOperator( op );
+                while( _cache.TryPopOperator( out op ) )
+                {
+                    ExpSyntaxNode node = ConvertAndPushOneOperator( op );
+                }
+                if( _cache.OperandAheadOfDepth == 1 )
+                {
+                    _cache.PopOperand( out _, out root );
+                    _cache.StatementsInDepth.Push( root );
                 }
-                _cache.PopOperand( out _, out root );
-                _cache.StatementsInDepth.Push( root );
             }
 
             root = _cache.PackAllStatements();
@@ -73,6 +77,7 @@ namespace StgSharp.Modeling.Step
             if( IsSeparatorMatch( _cache.PeekOperator(), rightSeparator ) )
             {
                 _cache.PopOperator();
+                root = ExpTupleNode.Pack( root );
                 _cache.PushOperand( root );
             } else
             {

StgSharp.Model/Step/Analyser/ExpSyntaxAnalyzer.cs

@@ -45,7 +45,7 @@ using System.Threading.Tasks;
 
 using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     internal partial class StepExpSyntaxAnalyzer : ISyntaxAnalyzer
     {
@@ -62,24 +62,10 @@ namespace StgSharp.Modeling.Step
         public StepExpSyntaxAnalyzer()
         {
             _cache = new CompileStack<ExpSyntaxNode, IExpElementSource>();
+            _context = new ExpressStepUtil();
         }
 
-        public StepExpSyntaxAnalyzer( ExpSchema context, IExpElementSource local )
-        {
-            _cache = new CompileStack<ExpSyntaxNode, IExpElementSource>();
-            ArgumentNullException.ThrowIfNull( context );
-            if( context is not ExpSchema_Builtin )
-            {
-                _context = context;
-            } else
-            {
-                throw new InvalidCastException( "Not a valid Schema type" );
-            }
-            _local = local;
-        }
-
-        public ConcurrentQueue<ExpSyntaxNode> StepEntityInitStatements { get; } = new ConcurrentQueue<ExpSyntaxNode>(
-            );
+        public ConcurrentQueue<StepEntityDefineSequence> StepEntityInitStatements { get; } = new();
 
         /// <summary>
         ///   Append a token to top of cache. This method will automatically convert token to node
@@ -114,6 +100,9 @@ namespace StgSharp.Modeling.Step
                 case TokenFlag.Member:
                     TryAppendMember( expToken );
                     break;
+                case TokenFlag.Enum:
+                    TryAppendEnum( expToken );
+                    break;
                 default:
                     break;
             }

StgSharp.Model/Step/Analyser/StepDataSectionsTranmitter.cs

@@ -38,44 +38,44 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     public class StepDataSectionTransmitter : IScriptSourceProvider
     {
 
         private const string EndDataText = "ENDSEC;";
 
-        private bool _isEmpty;
+        //private bool _isEmpty;
         private ConcurrentQueue<string> _cache = new ConcurrentQueue<string>();
         private int _line = 0;
 
-        public bool IsEmpty => _isEmpty;
+        public StepDataSectionTransmitter() { }
+
+        public StepDataSectionTransmitter( int begins )
+        {
+            Begin = begins;
+            _line = Begin;
+        }
+
+        public bool IsEmpty => _cache.IsEmpty && !IsWriting;
 
         public bool IsWriting { get; private set; } = true;
 
+        public int Begin { get; internal set; }
+
         public int Location => _line;
 
         public void EndWriting()
         {
-            _cache.Enqueue( EndDataText );
             IsWriting = false;
         }
 
         public string ReadLine()
         {
-            _cache.TryDequeue( out string? line );
-            while( !IsEmpty )
+            if( _cache.TryDequeue( out string? line ) )
             {
-                if( _cache.TryDequeue( out line ) )
-                {
-                    if( line == EndDataText )
-                    {
-                        _isEmpty = true;
-                        return string.Empty;
-                    }
-                    _line++;
-                    return line;
-                }
+                _line++;
+                return line;
             }
             return string.Empty;
         }
@@ -89,10 +89,17 @@ namespace StgSharp.Modeling.Step
 
         public void WriteLine( string line )
         {
-            if( line == EndDataText ) {
+            if( line == "DATA;" ) {
+                return;
+            }
+            if( line == EndDataText )
+            {
                 EndWriting();
+                return;
+            }
+            if( IsWriting ) {
+                _cache.Enqueue( line );
             }
-            _cache.Enqueue( line );
         }
 
         IScriptSourceProvider IScriptSourceProvider.Slice( int location, int count )

StgSharp.Model/Step/Analyser/StepDataTokenReader.cs

@@ -28,7 +28,7 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Modeling.Step;
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
@@ -41,14 +41,14 @@ using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
-    public class StepDataTokenReader : IScriptTokenReader
+    public partial class StepDataTokenReader : IScriptTokenReader
     {
 
         private ExpTokenReader _reader;
 
-        private HashSet<string> token1Hash = [
+        private HashSet<string> tokenHash = [
             "T","F","UNSPECIFIED"
             ];
         private Queue<Token> _cache = new Queue<Token>();
@@ -63,7 +63,13 @@ namespace StgSharp.Modeling.Step
 
         public bool IsEmpty
         {
-            get => _reader.IsEmpty && _transmitter.IsWriting;
+            get
+            {
+                if( _reader.IsEmpty ) {
+                    return !_transmitter.IsWriting;
+                }
+                return false;
+            }
         }
 
         public Token ReadToken()
@@ -76,40 +82,93 @@ namespace StgSharp.Modeling.Step
             return _reader.TryReadToken( out t );
         }
 
-        private class TokenPreReader : ExpTokenReaderPreProcessor
+        private partial class TokenPreReader : ExpTokenReaderPreProcessor
         {
 
-            private static Regex NextEnumPattern = GetNextEnumPattern();
+            private static Regex
+                _nextHashtagSymbolPattern = GetEntityTagSymbolPattern(),
+                _nextEnumPattern = GetNextEnumPattern(),
+                _stringPattern = GetStringPattern();
 
             public override bool Process( string codeLine, int line, ref int current, out Token t )
             {
                 ReadOnlySpan<char> chars = codeLine.AsSpan( current );
                 char c = chars[ 0 ];
-                if( c != '.' )
+                Match match;
+                switch( c )
                 {
-                    t = Token.Empty;
-                    return false;
-                }
-                Match match = NextEnumPattern.Match( codeLine, current );
-                if( match.Success )
-                {
-                    int begin = match.Groups[ "begin" ].Index;
-                    int end = match.Groups[ "end" ].Length;
-                    int rest = match.Groups[ "rets" ].Length;
-                    current = rest;
-                    t = new Token( match.Groups[ "begin" ].Value, line, begin, TokenFlag.Enum );
-                    return true;
-                } else
-                {
-                    t = Token.Empty;
-                    return false;
+                    case '#':
+                        match = _nextHashtagSymbolPattern.Match( codeLine, current );
+                        if( match.Success )
+                        {
+                            int begin = match.Groups[ "token" ].Index;
+                            int end = match.Groups[ "end" ].Index;
+                            int rest = match.Groups[ "rest" ].Index;
+                            current = rest;
+                            t = new(
+                                ExpressCompile.PoolString( chars[ 0..( end - begin ) ] ), line,
+                                begin, TokenFlag.Member );
+                            return true;
+                        }
+                        break;
+                    case '.':
+                        match = _nextEnumPattern.Match( codeLine, current );
+                        if( match.Success )
+                        {
+                            int begin = match.Groups[ "token" ].Index;
+                            int end = match.Groups[ "end" ].Index;
+                            int rest = match.Groups[ "rest" ].Index;
+                            current = rest;
+                            t = new Token(
+                                match.Groups[ "token" ].Value, line, begin, TokenFlag.Enum );
+                            return true;
+                        }
+                        break;
+                    case '$':
+                        t = new Token( "$", line, current, TokenFlag.Member );
+                        current++;
+                        return true;
+                    case '*':
+                        t = new Token( "*", line, current, TokenFlag.Member );
+                        current++;
+                        return true;
+                    case '\'':
+                        match = _stringPattern.Match( codeLine, current );
+                        if( match.Success )
+                        {
+                            int begin = match.Groups[ "token" ].Index;
+                            int end = match.Groups[ "end" ].Index;
+                            int rest = match.Groups[ "rest" ].Index;
+                            current = rest;
+                            string value = chars.Slice( 1, ( end - begin - 1 ) ).ToString();
+                            if( string.IsNullOrWhiteSpace( value ) ) {
+                                value = string.Empty;
+                            }
+                            t = new Token( value, line, begin, TokenFlag.String );
+                            return true;
+                        }
+                        break;
+                    default:
+                        break;
                 }
+                t = Token.Empty;
+                return false;
             }
 
             [GeneratedRegex(
-                    @"(?<begin>\.[A-Za-z_]+\.)(?<end>\s*)(?<rest>\S*)",
+                    @"(?<token>#[0-9A-Za-z]+)(?<end>\s*?)(?<rest>\S|$)",
                     RegexOptions.Singleline )]
-            private static extern Regex GetNextEnumPattern();
+            private static partial Regex GetEntityTagSymbolPattern();
+
+            [GeneratedRegex(
+                    @"(?<token>\.[A-Za-z_]+\.)(?<end>\s*)(?<rest>\S*)",
+                    RegexOptions.Singleline )]
+            private static partial Regex GetNextEnumPattern();
+
+            [GeneratedRegex(
+                    @"(?<token>')(?>\\\\|''|(?!')[^'])*(?<end>')\s*?(?<rest>\S|$)",
+                    RegexOptions.Singleline )]
+            private static partial Regex GetStringPattern();
 
         }
 

StgSharp.Model/Step/ExpressStepUntil.cs

@@ -1,101 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="ExpressStepUntil.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the ¡°Software¡±), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Modeling.Step;
-using StgSharp.Modeling.Step;
-using StgSharp.Script;
-using StgSharp.Script.Express;
-
-using System;
-using System.Collections.Frozen;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-
-namespace StgSharp.Modeling.Step
-{
-    public class ExpressStepUntil : ExpSchema
-    {
-
-        private FrozenDictionary<string, ExpTypeSource> entitiesDefine;
-
-        public ExpressStepUntil()
-        {
-            Span<KeyValuePair<string, ExpTypeSource>> source = [
-                new KeyValuePair<string, ExpTypeSource>( StepItemTypeExtensions.AdvancedFaceText,
-                                                          ),
-                ];
-            Dictionary<string, ExpTypeSource> tIndex = new Dictionary<string, ExpTypeSource>();
-        }
-
-        internal StepModel Current { get; set; }
-
-        public override void LoadFromSource( ExpSchemaSource source )
-        {
-            return;
-        }
-
-        public override bool TryGetConst( string name, out ExpElementInstance c )
-        {
-            c = null!;
-            return false;
-        }
-
-        public override bool TryGetEntity( string name, out ExpEntitySource e )
-        {
-            throw new NotImplementedException();
-        }
-
-        public override bool TryGetFunction( string name, out ExpFunctionSource f )
-        {
-            throw new NotImplementedException();
-        }
-
-        public override bool TryGetProcedure( string name, out ExpProcedureSource p )
-        {
-            throw new NotImplementedException();
-        }
-
-        public override bool TryGetRule( string name, out ExpRuleSource r )
-        {
-            throw new NotImplementedException();
-        }
-
-        public override bool TryGetSchemaInclude( string name, out ExpSchema include )
-        {
-            throw new NotImplementedException();
-        }
-
-        public override bool TryGetType( string name, out ExpTypeSource t )
-        {
-            throw new NotImplementedException();
-        }
-
-    }
-}

StgSharp.Model/Step/ExpressStepUtil.cs

@@ -28,7 +28,9 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Modeling.Step;
+using CommunityToolkit.HighPerformance.Buffers;
+
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
@@ -37,7 +39,7 @@ using System.Collections.Frozen;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     public class ExpressStepUtil : ExpSchema
     {
@@ -58,6 +60,7 @@ namespace StgSharp.Modeling.Step
         public const string LineText = "LINE";
         public const string OrientedEdgeText = "ORIENTED_EDGE";
         public const string PlaneText = "PLANE";
+        public const string RepresentationItemText = "REPRESENTATION_ITEM";
         public const string VectorText = "VECTOR";
         public const string VertexPointText = "VERTEX_POINT";
 
@@ -79,15 +82,22 @@ namespace StgSharp.Modeling.Step
                 LineText,
                 OrientedEdgeText,
                 PlaneText,
+                RepresentationItemText,
                 VectorText,
                 VertexPointText,
                 ];
 
-        private FrozenDictionary<string, ExpTypeSource> entitiesDefine;
+        private FrozenDictionary<string, ExpEntitySource> entitiesDefine;
+        private StringPool _entityNamePool = new StringPool();
 
         public ExpressStepUtil()
         {
-            Dictionary<string, ExpTypeSource> tIndex = new Dictionary<string, ExpTypeSource>();
+            IEnumerable<KeyValuePair<string, ExpEntitySource>> defineSource = [];
+            entitiesDefine = new Dictionary<string, ExpEntitySource>( defineSource )
+                .ToFrozenDictionary();
+            foreach( string item in names ) {
+                _entityNamePool.Add( item );
+            }
         }
 
         internal StepModel Current { get; set; }
@@ -105,13 +115,13 @@ namespace StgSharp.Modeling.Step
 
         public override bool TryGetEntity( string name, out ExpEntitySource e )
         {
-            e = null!;
-            return false;
+            return entitiesDefine.TryGetValue( name, out e! );
         }
 
         public override bool TryGetFunction( string name, out ExpFunctionSource f )
         {
-            throw new NotImplementedException();
+            f = null!;
+            return false;
         }
 
         public override bool TryGetProcedure( string name, out ExpProcedureSource p )

StgSharp.Model/Step/FileStructure/IStepObject.cs

@@ -1,71 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="IStepObject.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Geometries;
-using StgSharp.Math;
-using StgSharp.PipeLine;
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace StgSharp.Modeling.STEP
-{
-    public abstract class IStepObject : StepExpressionBase, IGeometry
-    {
-
-        public abstract Point this[ int index ]
-        {
-            get;
-            set;
-        }
-
-        public abstract Vec4[] VertexStream
-        {
-            get;
-        }
-
-        public abstract CoordinationBase Coordination
-        {
-            get;
-        }
-
-        public abstract int VertexCount
-        {
-            get;
-        }
-
-        public abstract ReadOnlySpan<int> VertexIndices
-        {
-            get;
-        }
-
-    }
-}

StgSharp.Model/Step/FileStructure/StepExpression.cs

@@ -1,135 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepExpression.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp;
-
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Text.RegularExpressions;
-
-namespace StgSharp.Modeling.STEP
-{
-    public abstract class StepExpressionBase 
-    {
-        public abstract List<StepExpressionBase> ParameterList { get; set; }
-
-        public int ID { get; internal set; }
-    }
-
-    public abstract class StepExpressionParameter : StepExpressionBase
-    {
-        public abstract object Value { get; set; }
-    }
-
-    public class StepObjectConstructor
-    {
-
-        private static Regex regex = new Regex(
-            @"(?<param1>.+?(\)|'\s?\)|'))\s?(?<sepcomma>,)\s?(?<other>(.|\(|\(\s?').+)",
-            RegexOptions.Compiled );
-
-        private readonly int _id;
-        private readonly List<string> _paramList;
-        private string _caller;
-
-        public StepObjectConstructor( int id, string caller, string parameters )
-        {
-            _caller = caller;
-            _paramList = new List<string>();
-            SplitParameter( parameters );
-        }
-
-        public string this[ int paramIndex ]
-        {
-            get => _paramList[ paramIndex ];
-        }
-
-        public ReadOnlyCollection<string> ParamList
-        {
-            get => _paramList.AsReadOnly();
-        }
-
-        public static string TempCallerName
-        {
-            get => "TEMPCALLER";
-        }
-
-        public string Caller
-        {
-            get => _caller;
-            internal set => _caller = value;
-        }
-
-        public static StepObjectConstructor CreateTempExpression( int id )
-        {
-            return new StepObjectConstructor( id, "TEMPCALLER", string.Empty );
-        }
-
-        private void SplitParameter( string parameters )
-        {
-            if( string.IsNullOrEmpty( parameters ) || string.IsNullOrWhiteSpace(
-                parameters ) ) {
-                return;
-            }
-            Match match = regex.Match( parameters );
-            while( match.Success ) {
-                _paramList.Add( match.Groups[ "param1" ].Value );
-                parameters = match.Groups[ "other" ].Value;
-                match = regex.Match( parameters );
-            }
-            _paramList.Add( parameters );
-        }
-
-    }
-
-    public record class StepCodeLine
-    {
-        public StepCodeLine( int id, string codeLine )
-        {
-            ID = id;
-            CodeLine = codeLine;
-        }
-
-        public　int ID
-        {
-            get;
-            set;
-        }
-
-        public string CodeLine
-        {
-            get;
-            set;
-        }
-    }
-}

StgSharp.Model/Step/FileStructure/StepHeader.cs

@@ -1,227 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="STEPHeader.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace StgSharp.Modeling.STEP
-{
-    /// <summary>
-    /// C# implementation of HEADER part in STEP file.
-    /// </summary>
-    public struct StepInfo
-    {
-
-        private STEPFileDescriptor _header;
-        private STEPFileName _name;
-        private STEPSchema _schema;
-
-        public (int mainLevel, int? subLevel) Level
-        {
-            get => _header.Level;
-            internal set => _header.Level = value;
-        }
-
-        public DateTime TimeStamp
-        {
-            get => _name.TimeStamp;
-            internal set => _name.TimeStamp = value;
-        }
-
-        public STEPFileDescriptor Descriptor
-        {
-            get => _header;
-            internal set => _header = value;
-        }
-
-        public STEPFileName FileName
-        {
-            get => _name;
-            internal set => _name = value;
-        }
-
-        public STEPSchema Schema
-        {
-            get => _schema;
-            internal set => _schema = value;
-        }
-
-        public string Description
-        {
-            get => _header.Description;
-            internal set => _header.Description = value;
-        }
-
-        public string Name
-        {
-            get => _name.Name;
-            internal set => _name.Name = value;
-        }
-
-        public string Author
-        {
-            get => _name.Author;
-            internal set => _name.Author = value;
-        }
-
-        public string Organization
-        {
-            get => _name.Organization;
-            internal set => _name.Organization = value;
-        }
-
-        public string OriginatingSystem
-        {
-            get => _name.OriginatingSystem;
-            internal set => _name.OriginatingSystem = value;
-        }
-
-        public string Authorization
-        {
-            get => _name.Authorization;
-            internal set => _name.Authorization = value;
-        }
-
-        public string PreprocessorVersion
-        {
-            get => _name.PreprocessorVersion;
-            internal set => _name.PreprocessorVersion = value;
-        }
-
-        public string Version
-        {
-            get => _name.Version;
-            internal set => _name.Version = value;
-        }
-
-        public string SchemaString
-        {
-            get => _schema.Data;
-            internal set => _schema.Data = value;
-        }
-
-    }
-
-    /// <summary>
-    /// C# implementation of FILE_NAME part in header of STEP file.
-    /// </summary>
-    public struct STEPFileName
-    {
-
-        public DateTime TimeStamp
-        {
-            get;
-            internal set;
-        }
-
-        public string Name
-        {
-            get;
-            internal set;
-        }
-
-        public string Author
-        {
-            get;
-            internal set;
-        }
-
-        public string Description
-        {
-            get;
-            internal set;
-        }
-
-        public string PreprocessorVersion
-        {
-            get;
-            internal set;
-        }
-
-        public string Version
-        {
-            get;
-            internal set;
-        }
-
-        public string Organization
-        {
-            get;
-            internal set;
-        }
-
-        public string OriginatingSystem
-        {
-            get;
-            internal set;
-        }
-
-        public string Authorization
-        {
-            get;
-            internal set;
-        }
-
-    }
-
-    public struct STEPSchema
-    {
-
-        private List<string> _schema;
-
-        public string Data
-        {
-            get;
-            internal set;
-        }
-
-    }
-
-    /// <summary>
-    /// C# implementation of FILE_NAME part in header of STEP file.
-    /// </summary>
-    public struct STEPFileDescriptor
-    {
-
-        public (int mainLevel,int? subLevel) Level
-        {
-            get;
-            internal set;
-        }
-
-        public string Description
-        {
-            get;
-            internal set;
-        }
-
-    }
-}

StgSharp.Model/Step/FileStructure/StepModel.cs

@@ -1,64 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepModel.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.PipeLine;
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Text;
-
-namespace StgSharp.Modeling.STEP
-{
-    public class StepModel
-    {
-
-        private BlueprintScheduler _builder;
-        private Dictionary<int, IStepObject> _node 
-            = new Dictionary<int, IStepObject>();
-        private StepInfo _header;
-
-        internal StepModel(
-                         StepInfo header,
-                         Dictionary<int, IStepObject> nodeSource )
-        {
-            _header = header;
-            _node = nodeSource;
-            _builder = new BlueprintScheduler();
-        }
-
-        public void BuildGeometry() { }
-
-        public void OrganizeNode()
-        {
-            foreach( KeyValuePair<int, IStepObject> node in _node ) { }
-        }
-
-    }
-}

StgSharp.Model/Step/IStepEntity.cs

@@ -1,36 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="IStepEntity.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the ¡°Software¡±), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Script.Express;
-
-namespace StgSharp.Modeling.STEP
-{
-    public interface IStepEntity<TSelf> : IExpMarshalType<TSelf> where TSelf: IStepEntity<TSelf> { }
-}

StgSharp.Model/Step/Items/StepAdvancedFace.cs

@@ -28,47 +28,46 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Script;
+using StgSharp.Model.Step;
 
+using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System.Linq;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepAdvancedFace : StepFaceSurface
+    public class StepAdvancedFace : StepFaceSurface, IExpConvertableFrom<StepAdvancedFace>
     {
 
-        private StepAdvancedFace() : base( string.Empty ) { }
-
-        public StepAdvancedFace( string name ) : base( name ) { }
+        public StepAdvancedFace( StepModel model ) : base( model ) { }
 
         public override StepItemType ItemType => StepItemType.AdvancedFace;
 
-        internal static StepAdvancedFace CreateFromSyntaxList(
-                                         StepBinder binder,
-                                         ExpNode syntaxList )
+        public void FromInstance( StepAdvancedFace entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            StepAdvancedFace face = new StepAdvancedFace();
-            enumerator.AssertEnumeratorCount( 4 );
-            face.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
+            base.FromInstance( entity );
+        }
 
-            object boundsList = enumerator.Values[ 1 ].GetValueList();
+        internal static StepAdvancedFace FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        {
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            StepAdvancedFace face = new StepAdvancedFace( binder );
+            enumerator.AssertEnumeratorCount( 4 );
+            face.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+
+            ExpNodePresidentEnumerator boundsList = enumerator[ 1 ].TupleToPresidentEnumerator();
             face.Bounds.Clear();
             face.Bounds
                 .AddRange(
-                    Enumerable.Range( 0, enumerator.Values.Count )
-                              .Select( _ => ( StepFaceBound )null ) );
-            for( int i = 0; i < enumerator.Values.Count; i++ )
+                    Enumerable.Range( 0, enumerator.Count ).Select( _ => ( StepFaceBound )null ) );
+            for( int i = 0; i < boundsList.Count; i++ )
             {
                 int j = i; // capture to avoid rebinding
-                binder.BindValue(
-                    enumerator.Values[ j ], v => face.Bounds[ j ] = v.AsType<StepFaceBound>() );
+                face.Bounds[ j ] = binder[ boundsList[ j ] ] as StepFaceBound;
             }
-            binder.BindValue(
-                enumerator.Values[ 2 ], v => face.FaceGeometry = v.AsType<StepSurface>() );
-            face.SameSense = ( enumerator.Values[ 3 ] as ExpBoolNode )!.Value;
+            face.FaceGeometry = binder[ enumerator[ 2 ] ] as StepSurface;
+            face.SameSense = ( enumerator[ 3 ] as ExpBoolNode )!.Value;
 
             return face;
         }

StgSharp.Model/Step/Items/StepAxis2Placement.cs

@@ -28,45 +28,35 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
-using StgSharp.Script.Express;
 
 using System;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepAxis2Placement : StepPlacement
+    public class StepAxis2Placement : StepPlacement
     {
 
-        private StepCartesianPoint _location;
         private StepDirection _refDirection;
 
-        protected StepAxis2Placement( string name ) : base( name ) { }
-
-        public StepCartesianPoint Location
-        {
-            get { return _location; }
-            set
-            {
-                ArgumentNullException.ThrowIfNull( value );
-
-                _location = value;
-            }
-        }
+        protected StepAxis2Placement( StepModel model ) : base( model ) { }
 
         public StepDirection RefDirection
         {
             get { return _refDirection; }
             set
             {
-                if( value == null ) {
-                    throw new ArgumentNullException();
-                }
-
+                ArgumentNullException.ThrowIfNull( value );
                 _refDirection = value;
             }
         }
 
+        public override bool IsConvertableTo( string entityName )
+        {
+            return base.IsConvertableTo( entityName ) || entityName == "StepAxis2Placement";
+        }
+
     }
 }
 

StgSharp.Model/Step/Items/StepAxis2Placement2D.cs

@@ -28,24 +28,25 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Script;
+using StgSharp.Model.Step;
 
+using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepAxis2Placement2D : StepAxis2Placement
+    public class StepAxis2Placement2D : StepAxis2Placement, IExpConvertableFrom<StepAxis2Placement2D>
     {
 
-        private StepAxis2Placement2D() : base( string.Empty ) { }
+        private StepAxis2Placement2D( StepModel model ) : base( model ) { }
 
         public StepAxis2Placement2D(
-               string label,
+               StepModel model,
                StepCartesianPoint location,
                StepDirection direction )
-            : base( label )
+            : base( model )
         {
             Location = location;
             RefDirection = direction;
@@ -53,25 +54,24 @@ namespace StgSharp.Modeling.Items
 
         public override StepItemType ItemType => StepItemType.AxisPlacement2D;
 
-        internal static StepAxis2Placement2D CreateFromSyntaxList(
-                                             StepBinder binder,
-                                             ExpNode syntaxList )
+        public void FromInstance( StepAxis2Placement2D entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            StepAxis2Placement2D axis = new StepAxis2Placement2D();
-            enumerator.AssertEnumeratorCount( 3 );
-            axis.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => axis.Location = v.AsType<StepCartesianPoint>() );
-            binder.BindValue(
-                enumerator.Values[ 2 ], v => axis.RefDirection = v.AsType<StepDirection>() );
-            return axis;
+            base.FromInstance( entity );
+            Location = entity.Location;
+            RefDirection = entity.RefDirection;
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        internal static StepAxis2Placement2D FromSyntax(
+                                             StepModel binder,
+                                             ExpSyntaxNode syntaxList )
         {
-            yield return Location;
-            yield return RefDirection;
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            StepAxis2Placement2D axis = new StepAxis2Placement2D( binder );
+            enumerator.AssertEnumeratorCount( 3 );
+            axis.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            axis.Location = binder[ enumerator[ 1 ] ] as StepCartesianPoint;
+            axis.RefDirection = binder[ enumerator[ 2 ] ] as StepDirection;
+            return axis;
         }
 
     }

StgSharp.Model/Step/Items/StepAxis2Placement3D.cs

@@ -28,27 +28,28 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepAxis2Placement3D : StepAxis2Placement
+    public class StepAxis2Placement3D : StepAxis2Placement, IExpConvertableFrom<StepAxis2Placement3D>
     {
 
         private StepDirection _axis;
 
-        private StepAxis2Placement3D() : base( string.Empty ) { }
+        private StepAxis2Placement3D( StepModel model ) : base( model ) { }
 
         public StepAxis2Placement3D(
-               string name,
+               StepModel model,
                StepCartesianPoint location,
                StepDirection axis,
                StepDirection refDirection )
-            : base( name )
+            : base( model )
         {
             Location = location;
             Axis = axis;
@@ -60,37 +61,35 @@ namespace StgSharp.Modeling.Items
             get { return _axis; }
             set
             {
-                if( value == null ) {
-                    throw new ArgumentNullException();
-                }
-
+                ArgumentNullException.ThrowIfNull( value );
                 _axis = value;
             }
         }
 
         public override StepItemType ItemType => StepItemType.AxisPlacement3D;
 
-        internal static StepAxis2Placement3D CreateFromSyntaxList(
-                                             StepBinder binder,
-                                             ExpNode syntaxList )
+        public override bool IsConvertableTo( string entityTypeName )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            StepAxis2Placement3D axis = new StepAxis2Placement3D();
+            throw new NotImplementedException();
+        }
+
+        internal static StepAxis2Placement3D FromSyntax(
+                                             StepModel binder,
+                                             ExpSyntaxNode syntaxList )
+        {
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            StepAxis2Placement3D axis = new StepAxis2Placement3D( binder );
             enumerator.AssertEnumeratorCount( 4 );
-            axis.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => axis.Location = v.AsType<StepCartesianPoint>() );
-            binder.BindValue( syntaxList.Values[ 2 ], v => axis.Axis = v.AsType<StepDirection>() );
-            binder.BindValue(
-                enumerator.Values[ 3 ], v => axis.RefDirection = v.AsType<StepDirection>() );
+            axis.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            axis.Location = binder[ enumerator[ 1 ] ] as StepCartesianPoint;
+            axis.Axis = binder[ enumerator[ 2 ] ] as StepDirection;
+            axis.RefDirection = binder[ enumerator[ 3 ] ] as StepDirection;
             return axis;
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        void IExpConvertableFrom<StepAxis2Placement3D>.FromInstance( StepAxis2Placement3D entity )
         {
-            yield return Location;
-            yield return Axis;
-            yield return RefDirection;
+            throw new NotImplementedException();
         }
 
     }

StgSharp.Model/Step/Items/StepBSplineCurve.cs

@@ -28,6 +28,7 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
@@ -36,7 +37,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
     public enum StepBSplineCurveForm
     {
@@ -50,81 +51,89 @@ namespace StgSharp.Modeling.Items
 
     }
 
-;
-
-    public abstract class StepBSplineCurve : StepBoundedCurve
+    public static class StepExpEnumValue
     {
 
-        private const string CIRCULAR_ARC = "CIRCULAR_ARC";
-        private const string ELLIPTIC_ARC = "ELLIPTIC_ARC";
-        private const string HYPERBOLIC_ARC = "HYPERBOLIC_ARC";
-        private const string PARABOLIC_ARC = "PARABOLIC_ARC";
+        internal const string CIRCULAR_ARC = "CIRCULAR_ARC";
+        internal const string ELLIPTIC_ARC = "ELLIPTIC_ARC";
+        internal const string HYPERBOLIC_ARC = "HYPERBOLIC_ARC";
+        internal const string PARABOLIC_ARC = "PARABOLIC_ARC";
+        internal const string POLYLINE_FORM = "POLYLINE_FORM";
+        internal const string UNSPECIFIED = "UNSPECIFIED";
 
-        private const string POLYLINE_FORM = "POLYLINE_FORM";
-        private const string UNSPECIFIED = "UNSPECIFIED";
+        internal static HashSet<string> AllPossibleValue { get; } = [
+                CIRCULAR_ARC,
+                ELLIPTIC_ARC,
+                HYPERBOLIC_ARC,
+                PARABOLIC_ARC,
+                POLYLINE_FORM,
+                UNSPECIFIED,
+            ];
 
-        public StepBSplineCurve( string name, IEnumerable<StepCartesianPoint> controlPoints )
-            : base( name )
+    }
+
+    public class StepBSplineCurve : StepBoundedCurve, IExpConvertableFrom<StepBSplineCurve>
+    {
+
+        public StepBSplineCurve( StepModel model, params StepCartesianPoint[] controlPoints )
+            : this( model, ( IEnumerable<StepCartesianPoint> )controlPoints ) { }
+
+        public StepBSplineCurve( StepModel model, IEnumerable<StepCartesianPoint> controlPoints )
+            : base( model )
         {
             ControlPointsList.AddRange( controlPoints );
         }
 
-        public StepBSplineCurve( string name, params StepCartesianPoint[] controlPoints )
-            : this( name, ( IEnumerable<StepCartesianPoint> )controlPoints ) { }
-
         public bool ClosedCurve { get; set; }
 
         public bool SelfIntersect { get; set; }
 
         public int Degree { get; set; }
 
-        public List<StepCartesianPoint> ControlPointsList { get; } = new List<StepCartesianPoint>();
+        public List<StepCartesianPoint> ControlPointsList { get; private set; } 
+            = new List<StepCartesianPoint>();
 
         public StepBSplineCurveForm CurveForm { get; set; } = StepBSplineCurveForm.Unspecified;
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        public void FromInstance( StepBSplineCurve entity )
         {
-            return ControlPointsList;
+            base.FromInstance( entity );
+            this.Degree = entity.Degree;
+            this.ClosedCurve = entity.ClosedCurve;
+            this.ControlPointsList = entity.ControlPointsList;
+            this.SelfIntersect = entity.SelfIntersect;
+        }
+
+        public override bool IsConvertableTo( string entityName )
+        {
+            return base.IsConvertableTo( entityName ) || entityName == "StepBSplineCurve";
         }
 
         protected static string GetCurveFormString( StepBSplineCurveForm form )
         {
-            switch( form )
+            return form switch
             {
-                case StepBSplineCurveForm.Polyline:
-                    return POLYLINE_FORM;
-                case StepBSplineCurveForm.CircularArc:
-                    return CIRCULAR_ARC;
-                case StepBSplineCurveForm.EllipticalArc:
-                    return ELLIPTIC_ARC;
-                case StepBSplineCurveForm.ParabolicArc:
-                    return PARABOLIC_ARC;
-                case StepBSplineCurveForm.HyperbolicArc:
-                    return HYPERBOLIC_ARC;
-                case StepBSplineCurveForm.Unspecified:
-                    return UNSPECIFIED;
-            }
-
-            throw new NotImplementedException();
+                StepBSplineCurveForm.Polyline => StepExpEnumValue.POLYLINE_FORM,
+                StepBSplineCurveForm.CircularArc => StepExpEnumValue.CIRCULAR_ARC,
+                StepBSplineCurveForm.EllipticalArc => StepExpEnumValue.ELLIPTIC_ARC,
+                StepBSplineCurveForm.ParabolicArc => StepExpEnumValue.PARABOLIC_ARC,
+                StepBSplineCurveForm.HyperbolicArc => StepExpEnumValue.HYPERBOLIC_ARC,
+                StepBSplineCurveForm.Unspecified => StepExpEnumValue.UNSPECIFIED,
+                _ => throw new NotImplementedException(),
+            };
         }
 
         protected static StepBSplineCurveForm ParseCurveForm( string enumerationValue )
         {
-            switch( enumerationValue.ToUpperInvariant() )
+            return enumerationValue.ToUpperInvariant() switch
             {
-                case POLYLINE_FORM:
-                    return StepBSplineCurveForm.Polyline;
-                case CIRCULAR_ARC:
-                    return StepBSplineCurveForm.CircularArc;
-                case ELLIPTIC_ARC:
-                    return StepBSplineCurveForm.EllipticalArc;
-                case PARABOLIC_ARC:
-                    return StepBSplineCurveForm.ParabolicArc;
-                case HYPERBOLIC_ARC:
-                    return StepBSplineCurveForm.HyperbolicArc;
-                default:
-                    return StepBSplineCurveForm.Unspecified;
-            }
+                StepExpEnumValue.POLYLINE_FORM => StepBSplineCurveForm.Polyline,
+                StepExpEnumValue.CIRCULAR_ARC => StepBSplineCurveForm.CircularArc,
+                StepExpEnumValue.ELLIPTIC_ARC => StepBSplineCurveForm.EllipticalArc,
+                StepExpEnumValue.PARABOLIC_ARC => StepBSplineCurveForm.ParabolicArc,
+                StepExpEnumValue.HYPERBOLIC_ARC => StepBSplineCurveForm.HyperbolicArc,
+                _ => StepBSplineCurveForm.Unspecified,
+            };
         }
 
     }

StgSharp.Model/Step/Items/StepBSplineCurveWithKnots.cs

@@ -28,6 +28,7 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
@@ -36,7 +37,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
     public enum StepKnotType
     {
@@ -50,7 +51,7 @@ namespace StgSharp.Modeling.Items
 
 ;
 
-    public class StepBSplineCurveWithKnots : StepBSplineCurve
+    public class StepBSplineCurveWithKnots : StepBSplineCurve, IExpConvertableFrom<StepBSplineCurveWithKnots>
     {
 
         private const string PIECEWISE_BEZIER_KNOTS = "PIECEWISE_BEZIER_KNOTS";
@@ -60,12 +61,14 @@ namespace StgSharp.Modeling.Items
         private const string UNSPECIFIED = "UNSPECIFIED";
 
         public StepBSplineCurveWithKnots(
-               string name,
+               StepModel model,
                IEnumerable<StepCartesianPoint> controlPoints )
-            : base( name, controlPoints ) { }
+            : base( model, controlPoints ) { }
 
-        public StepBSplineCurveWithKnots( string name, params StepCartesianPoint[] controlPoints )
-            : base( name, controlPoints ) { }
+        public StepBSplineCurveWithKnots(
+               StepModel model,
+               params StepCartesianPoint[] controlPoints )
+            : base( model, controlPoints ) { }
 
         public List<int> KnotMultiplicities { get; } = new List<int>();
 
@@ -75,79 +78,79 @@ namespace StgSharp.Modeling.Items
 
         public StepKnotType KnotSpec { get; set; } = StepKnotType.Unspecified;
 
-        internal static StepBSplineCurveWithKnots CreateFromSyntaxList(
-                                                  StepBinder binder,
-                                                  ExpNode syntaxList )
+        public void FromInstance( StepBSplineCurveWithKnots entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
+            base.FromInstance( entity );
+            KnotSpec = entity.KnotSpec;
+            KnotMultiplicities.Clear();
+            KnotMultiplicities.AddRange( entity.KnotMultiplicities );
+            Knots.Clear();
+            Knots.AddRange( entity.Knots );
+        }
+
+        internal static StepBSplineCurveWithKnots FromSyntax(
+                                                  StepModel binder,
+                                                  ExpSyntaxNode syntaxList )
+        {
+            ExpNodePresidentEnumerator enumerator = syntaxList .ToPresidentEnumerator();
             enumerator.AssertEnumeratorCount( 9 );
-            object controlPointsList = enumerator.Values[ 2 ].GetValueList();
+            ExpNodePresidentEnumerator controlPointsList = enumerator[ 2 ].TupleToPresidentEnumerator(
+                );
 
             StepBSplineCurveWithKnots spline = new StepBSplineCurveWithKnots(
-                string.Empty, new StepCartesianPoint[controlPointsList.Values.Count] );
-            spline.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            spline.Degree = ( enumerator.Values[ 1 ] as ExpIntNode )!.Value;
+                binder, new StepCartesianPoint[controlPointsList.Count] );
+            spline.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            spline.Degree = ( enumerator[ 1 ] as ExpIntNode )!.Value;
 
-            for( int i = 0; i < controlPointsList.Values.Count; i++ )
+            for( int i = 0; i < controlPointsList.Count; i++ )
             {
                 int j = i; // capture to avoid rebinding
-                binder.BindValue(
-                    controlPointsList.Values[ j ],
-                    v => spline.ControlPointsList[ j ] = v.AsType<StepCartesianPoint>() );
+                spline.ControlPointsList[ j ] = binder[ controlPointsList[ j ] ]as StepCartesianPoint;
             }
 
-            spline.CurveForm = ParseCurveForm( enumerator.Values[ 3 ].GetEnumerationValue() );
-            spline.ClosedCurve = ( enumerator.Values[ 4 ] as ExpBoolNode )!.Value;
-            spline.SelfIntersect = ( enumerator.Values[ 5 ]as ExpBoolNode )!.Value;
+            spline.CurveForm = ParseCurveForm( enumerator[ 3 ].CodeConvertTemplate );
+            spline.ClosedCurve = ( enumerator[ 4 ] as ExpBoolNode )!.Value;
+            spline.SelfIntersect = ( enumerator[ 5 ]as ExpBoolNode )!.Value;
 
-            object knotMultiplicitiesList = enumerator.Values[ 6 ].GetValueList();
+            ExpNodePresidentEnumerator knotMultiplicitiesList = enumerator[ 6 ].TupleToPresidentEnumerator(
+                );
             spline.KnotMultiplicities.Clear();
-            for( int i = 0; i < knotMultiplicitiesList.Values.Count; i++ ) {
-                spline.KnotMultiplicities
-                      .Add( knotMultiplicitiesList.Values[ i ].GetIntegerValue() );
+            for( int i = 0; i < knotMultiplicitiesList.Count; i++ ) {
+                spline.KnotMultiplicities.Add( ( knotMultiplicitiesList[ i ]as ExpIntNode )!.Value );
             }
 
-            object knotslist = enumerator.Values[ 7 ].GetValueList();
+            ExpNodePresidentEnumerator knotsList = enumerator[ 7 ].TupleToPresidentEnumerator();
             spline.Knots.Clear();
-            for( int i = 0; i < knotslist.Values.Count; i++ ) {
-                spline.Knots.Add( knotslist.Values[ i ].GetRealVavlue() );
+            for( int i = 0; i < knotsList.Count; i++ ) {
+                spline.Knots.Add( ( knotsList[ i ]as ExpRealNumberNode )!.Value );
             }
 
-            spline.KnotSpec = ParseKnotSpec( enumerator.Values[ 8 ].GetEnumerationValue() );
+            spline.KnotSpec = ParseKnotSpec( enumerator[ 8 ].CodeConvertTemplate );
 
             return spline;
         }
 
         private static string GetKnotSpec( StepKnotType spec )
         {
-            switch( spec )
+            return spec switch
             {
-                case StepKnotType.UniformKnots:
-                    return UNIFORM_KNOTS;
-                case StepKnotType.QuasiUniformKnots:
-                    return QUASI_UNIFORM_KNOTS;
-                case StepKnotType.PiecewiseBezierKnots:
-                    return PIECEWISE_BEZIER_KNOTS;
-                case StepKnotType.Unspecified:
-                    return UNSPECIFIED;
-            }
-
-            throw new NotImplementedException();
+                StepKnotType.UniformKnots => UNIFORM_KNOTS,
+                StepKnotType.QuasiUniformKnots => QUASI_UNIFORM_KNOTS,
+                StepKnotType.PiecewiseBezierKnots => PIECEWISE_BEZIER_KNOTS,
+                StepKnotType.Unspecified => UNSPECIFIED,
+                _ => throw new NotImplementedException(),
+            };
         }
 
         private static StepKnotType ParseKnotSpec( string enumerationValue )
         {
-            switch( enumerationValue.ToUpperInvariant() )
+            return enumerationValue.ToUpperInvariant() switch
             {
-                case UNIFORM_KNOTS:
-                    return StepKnotType.UniformKnots;
-                case QUASI_UNIFORM_KNOTS:
-                    return StepKnotType.QuasiUniformKnots;
-                case PIECEWISE_BEZIER_KNOTS:
-                    return StepKnotType.PiecewiseBezierKnots;
-                default:
-                    return StepKnotType.Unspecified;
-            }
+                UNIFORM_KNOTS => StepKnotType.UniformKnots,
+                QUASI_UNIFORM_KNOTS => StepKnotType.QuasiUniformKnots,
+                PIECEWISE_BEZIER_KNOTS => StepKnotType.PiecewiseBezierKnots,
+                _ => StepKnotType.Unspecified,
+            };
         }
 
     }

StgSharp.Model/Step/Items/StepBoundedCurve.cs

@@ -28,15 +28,31 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepBoundedCurve : StepCurve
+    public class StepBoundedCurve : StepCurve, IExpConvertableFrom<StepBoundedCurve>
     {
 
-        protected StepBoundedCurve( string name ) : base( name ) { }
+        public StepBoundedCurve( StepModel model ) : base( model ) { }
+
+        public void FromInstance( StepBoundedCurve entity )
+        {
+            base.FromInstance( entity );
+        }
+
+        public override bool IsConvertableTo( string entityName )
+        {
+            return base.IsConvertableTo( entityName ) || entityName == "StepBoundedCurve";
+        }
+
+        internal static StepBoundedCurve FromSyntax( StepModel binder, ExpSyntaxNode syntax )
+        {
+            return new StepBoundedCurve( binder );
+        }
 
     }
 }

StgSharp.Model/Step/Items/StepCartesianPoint.cs

@@ -28,27 +28,32 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepCartesianPoint : StepTriple
+    public class StepCartesianPoint : StepTriple, IExpConvertableFrom<StepCartesianPoint>
     {
 
-        private StepCartesianPoint() { }
+        private StepCartesianPoint( StepModel model ) : base( model ) { }
 
-        public StepCartesianPoint( string label, float x, float y, float z )
-            : base( label, x, y, z ) { }
+        public StepCartesianPoint( StepModel model, float x, float y, float z )
+            : base( model, x, y, z ) { }
 
         public override StepItemType ItemType => StepItemType.CartesianPoint;
 
         protected override int MinimumValueCount => 1;
 
-        internal static StepCartesianPoint CreateFromSyntaxList( ExpNode syntaxList )
+        public void FromInstance( StepCartesianPoint entity )
         {
-            return ( StepCartesianPoint )AssignTo( new StepCartesianPoint(), syntaxList );
+            base.FromInstance( entity );
+        }
+
+        internal static StepCartesianPoint FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        {
+            return AssignTo( new StepCartesianPoint( binder ), syntaxList );
         }
 
     }

StgSharp.Model/Step/Items/StepCircle.cs

@@ -28,23 +28,24 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepCircle : StepConic
+    public class StepCircle : StepConic, IExpConvertableFrom<StepCircle>
     {
 
         private StepAxis2Placement _position;
 
-        private StepCircle() : base( string.Empty ) { }
+        public StepCircle( StepModel model ) : base( model ) { }
 
-        public StepCircle( string label, StepAxis2Placement position, float radius )
-            : base( label )
+        public StepCircle( StepModel model, StepAxis2Placement position, float radius )
+            : base( model )
         {
             Position = position;
             Radius = radius;
@@ -67,21 +68,21 @@ namespace StgSharp.Modeling.Items
 
         public override StepItemType ItemType => StepItemType.Circle;
 
-        internal static StepCircle CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
+        public void FromInstance( StepCircle entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            StepCircle circle = new StepCircle();
-            enumerator.AssertEnumeratorCount( 3 );
-            circle.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => circle.Position = v.AsType<StepAxis2Placement>() );
-            circle.Radius = ( enumerator.Values[ 2 ]as ExpRealNumberNode )!.Value;
-            return circle;
+            base.FromInstance( entity );
+            this._position = entity.Position;
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        internal static StepCircle FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
         {
-            yield return Position;
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            StepCircle circle = new StepCircle( binder );
+            enumerator.AssertEnumeratorCount( 3 );
+            circle.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            circle.Position = binder[ enumerator[ 1 ] ] as StepAxis2Placement;
+            circle.Radius = ( enumerator[ 2 ]as ExpRealNumberNode )!.Value;
+            return circle;
         }
 
     }

StgSharp.Model/Step/Items/StepConic.cs

@@ -28,15 +28,28 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepConic : StepCurve
+    public class StepConic : StepCurve, IExpConvertableFrom<StepConic>
     {
 
-        protected StepConic( string name ) : base( name ) { }
+        public StepConic( StepModel model ) : base( model ) { }
+
+        public override StepItemType ItemType => StepItemType.Conic;
+
+        public override bool IsConvertableTo( string entityTypeName )
+        {
+            return base.IsConvertableTo( entityTypeName ) || entityTypeName == "StepConic";
+        }
+
+        void IExpConvertableFrom<StepConic>.FromInstance( StepConic entity )
+        {
+            base.FromInstance( entity );
+        }
 
     }
 }

StgSharp.Model/Step/Items/StepCurve.cs

@@ -28,15 +28,28 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepCurve : StepGeometricRepresentationItem
+    public class StepCurve : StepGeometricRepresentationItem, IExpConvertableFrom<StepCurve>
     {
 
-        protected StepCurve( string name ) : base( name ) { }
+        public StepCurve( StepModel model ) : base( model ) { }
+
+        public override StepItemType ItemType => StepItemType.Curve;
+
+        public void FromInstance( StepCurve entity )
+        {
+            base.FromInstance( entity );
+        }
+
+        public override bool IsConvertableTo( string entityName )
+        {
+            return base.IsConvertableTo( entityName ) || entityName == "StepCurve";
+        }
 
     }
 }

StgSharp.Model/Step/Items/StepCylindricalSurface.cs

@@ -28,21 +28,25 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Script;
+using StgSharp.Model.Step;
 
+using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepCylindricalSurface : StepElementarySurface
+    public class StepCylindricalSurface : StepElementarySurface, IExpConvertableFrom<StepCylindricalSurface>
     {
 
-        private StepCylindricalSurface() : base() { }
+        public StepCylindricalSurface( StepModel model ) : base( model ) { }
 
-        public StepCylindricalSurface( string name, StepAxis2Placement3D position, float radius )
-            : base( name, position )
+        public StepCylindricalSurface(
+               StepModel model,
+               StepAxis2Placement3D position,
+               float radius )
+            : base( model, position )
         {
             Radius = radius;
         }
@@ -51,17 +55,22 @@ namespace StgSharp.Modeling.Items
 
         public override StepItemType ItemType => StepItemType.CylindricalSurface;
 
-        internal static StepRepresentationItem CreateFromSyntaxList(
-                                               StepBinder binder,
-                                               ExpNode syntaxList )
+        public void FromInstance( StepCylindricalSurface entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
+            base.FromInstance( entity );
+            Radius = entity.Radius;
+        }
+
+        internal static StepRepresentationItem FromSyntax(
+                                               StepModel binder,
+                                               ExpSyntaxNode syntaxList )
+        {
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
             enumerator.AssertEnumeratorCount( 3 );
-            StepCylindricalSurface surface = new StepCylindricalSurface();
-            surface.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => surface.Position = v.AsType<StepAxis2Placement3D>() );
-            surface.Radius = ( enumerator.Values[ 2 ]as ExpRealNumberNode )!.Value;
+            StepCylindricalSurface surface = new StepCylindricalSurface( binder );
+            surface.Name = ( enumerator[ 0 ] as ExpStringNode )!.Value;
+            surface.Position = binder[ enumerator[ 1 ] ]as StepAxis2Placement3D;
+            surface.Radius = ( enumerator[ 2 ]as ExpRealNumberNode )!.Value;
             return surface;
         }
 

StgSharp.Model/Step/Items/StepDirection.cs

@@ -28,26 +28,32 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepDirection : StepTriple
+    public class StepDirection : StepTriple, IExpConvertableFrom<StepDirection>
     {
 
-        private StepDirection() { }
+        private StepDirection( StepModel model ) : base( model ) { }
 
-        public StepDirection( string name, float x, float y, float z ) : base( name, x, y, z ) { }
+        public StepDirection( StepModel model, float x, float y, float z )
+            : base( model, x, y, z ) { }
 
         public override StepItemType ItemType => StepItemType.Direction;
 
         protected override int MinimumValueCount => 2;
 
-        internal static StepDirection CreateFromSyntaxList( ExpNode syntaxList )
+        public void FromInstance( StepDirection entity )
         {
-            return ( StepDirection )AssignTo( new StepDirection(), syntaxList );
+            base.FromInstance( entity );
+        }
+
+        internal static StepDirection FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        {
+            return AssignTo( new StepDirection( binder ), syntaxList );
         }
 
     }

StgSharp.Model/Step/Items/StepEdge.cs

@@ -28,21 +28,22 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Script;
+using StgSharp.Model.Step;
 
+using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepEdge : StepTopologicalRepresentationItem
+    public class StepEdge : StepTopologicalRepresentationItem, IExpConvertableFrom<StepEdge>
     {
 
-        protected StepEdge() : base( string.Empty ) { }
+        protected StepEdge( StepModel model ) : base( model ) { }
 
-        protected StepEdge( string name, StepVertex edgeStart, StepVertex edgeEnd )
-            : base( name )
+        protected StepEdge( StepModel model, StepVertex edgeStart, StepVertex edgeEnd )
+            : base( model )
         {
             EdgeStart = edgeStart;
             EdgeEnd = edgeEnd;
@@ -52,15 +53,16 @@ namespace StgSharp.Modeling.Items
 
         public StepVertex EdgeEnd { get; set; }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        public void FromInstance( StepEdge entity )
         {
-            if( EdgeStart != null ) {
-                yield return EdgeStart;
-            }
+            base.FromInstance( entity );
+            EdgeStart = entity.EdgeStart;
+            EdgeEnd = entity.EdgeEnd;
+        }
 
-            if( EdgeEnd != null ) {
-                yield return EdgeEnd;
-            }
+        public override bool IsConvertableTo( string entityName )
+        {
+            return base.IsConvertableTo( entityName ) || entityName == "StepEdge";
         }
 
     }

StgSharp.Model/Step/Items/StepEdgeCurve.cs

@@ -28,28 +28,29 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepEdgeCurve : StepEdge
+    public class StepEdgeCurve : StepEdge, IExpConvertableFrom<StepEdgeCurve>
     {
 
         private StepCurve _edgeGeometry;
 
-        private StepEdgeCurve() : base() { }
+        private StepEdgeCurve( StepModel model ) : base( model ) { }
 
         public StepEdgeCurve(
-               string name,
+               StepModel model,
                StepVertex edgeStart,
                StepVertex edgeEnd,
                StepCurve edgeGeometry,
                bool isSameSense )
-            : base( name, edgeStart, edgeEnd )
+            : base( model, edgeStart, edgeEnd )
         {
             EdgeGeometry = edgeGeometry;
             IsSameSense = isSameSense;
@@ -62,39 +63,30 @@ namespace StgSharp.Modeling.Items
             get { return _edgeGeometry; }
             set
             {
-                if( value == null ) {
-                    throw new ArgumentNullException();
-                }
-
+                ArgumentNullException.ThrowIfNull( value );
                 _edgeGeometry = value;
             }
         }
 
         public override StepItemType ItemType => StepItemType.EdgeCurve;
 
-        internal static StepEdgeCurve CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
+        public void FromInstance( StepEdgeCurve entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            StepEdgeCurve edgeCurve = new StepEdgeCurve();
-            enumerator.AssertEnumeratorCount( 5 );
-            edgeCurve.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => edgeCurve.EdgeStart = v.AsType<StepVertex>() );
-            binder.BindValue(
-                enumerator.Values[ 2 ], v => edgeCurve.EdgeEnd = v.AsType<StepVertex>() );
-            binder.BindValue(
-                enumerator.Values[ 3 ], v => edgeCurve.EdgeGeometry = v.AsType<StepCurve>() );
-            edgeCurve.IsSameSense = ( enumerator.Values[ 4 ]as ExpBoolNode )!.Value;
-            return edgeCurve;
+            base.FromInstance( entity );
+            EdgeGeometry = entity.EdgeGeometry;
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        internal static StepEdgeCurve FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
         {
-            foreach( StepRepresentationItem item in base.GetReferencedItems() ) {
-                yield return item;
-            }
-
-            yield return EdgeGeometry;
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            StepEdgeCurve edgeCurve = new StepEdgeCurve( binder );
+            enumerator.AssertEnumeratorCount( 5 );
+            edgeCurve.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            edgeCurve.EdgeStart = binder[ enumerator[ 1 ] ] as StepVertex;
+            edgeCurve.EdgeEnd = binder[ enumerator[ 2 ] ] as StepVertex;
+            edgeCurve.EdgeGeometry = binder[ enumerator[ 3 ] ] as StepCurve;
+            edgeCurve.IsSameSense = ( enumerator[ 4 ]as ExpBoolNode )!.Value;
+            return edgeCurve;
         }
 
     }

StgSharp.Model/Step/Items/StepEdgeLoop.cs

@@ -28,54 +28,53 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 using System.Linq;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepEdgeLoop : StepLoop
+    public class StepEdgeLoop : StepLoop, IExpConvertableFrom<StepEdgeCurve>
     {
 
-        public StepEdgeLoop( string name, IEnumerable<StepOrientedEdge> edgeList )
-            : base( name )
+        public StepEdgeLoop( StepModel model, params StepOrientedEdge[] edgeList )
+            : this( model, ( IEnumerable<StepOrientedEdge> )edgeList ) { }
+
+        public StepEdgeLoop( StepModel model, IEnumerable<StepOrientedEdge> edgeList )
+            : base( model )
         {
             EdgeList = new List<StepOrientedEdge>( edgeList );
         }
 
-        public StepEdgeLoop( string name, params StepOrientedEdge[] edgeList )
-            : this( name, ( IEnumerable<StepOrientedEdge> )edgeList ) { }
-
         public List<StepOrientedEdge> EdgeList { get; private set; }
 
         public override StepItemType ItemType => StepItemType.EdgeLoop;
 
-        internal static StepEdgeLoop CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
+        public void FromInstance( StepEdgeCurve entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
+            base.FromInstance( entity );
+        }
+
+        internal static StepEdgeLoop FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        {
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
             enumerator.AssertEnumeratorCount( 2 );
-            object edgeSyntaxList = enumerator.Values[ 1 ].GetValueList();
+            ExpNodePresidentEnumerator edgeSyntaxList = enumerator[ 1 ].TupleToPresidentEnumerator();
             StepEdgeLoop edgeLoop = new StepEdgeLoop(
-                string.Empty, new StepOrientedEdge[edgeSyntaxList.Values.Count] );
-            edgeLoop.Name = enumerator.Values[ 0 ].GetStringValue();
-            for( int i = 0; i < edgeSyntaxList.Values.Count; i++ )
+                binder, new StepOrientedEdge[edgeSyntaxList.Count] );
+            edgeLoop.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            for( int i = 0; i < edgeSyntaxList.Count; i++ )
             {
                 int j = i; // capture to avoid rebinding
-                binder.BindValue(
-                    edgeSyntaxList.Values[ j ],
-                    v => edgeLoop.EdgeList[ j ] = v.AsType<StepOrientedEdge>() );
+                edgeLoop.EdgeList[ j ] = binder[ edgeSyntaxList[ j ] ] as StepOrientedEdge;
             }
 
             return edgeLoop;
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
-        {
-            return EdgeList;
-        }
-
     }
 }
 

StgSharp.Model/Step/Items/StepElementarySurface.cs

@@ -28,23 +28,24 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepElementarySurface : StepSurface
+    public class StepElementarySurface : StepSurface, IExpConvertableFrom<StepElementarySurface>
     {
 
         private StepAxis2Placement3D _position;
 
-        protected StepElementarySurface() : base( string.Empty ) { }
+        public StepElementarySurface( StepModel model ) : base( model ) { }
 
-        public StepElementarySurface( string name, StepAxis2Placement3D position )
-            : base( name )
+        public StepElementarySurface( StepModel model, StepAxis2Placement3D position )
+            : base( model )
         {
             Position = position;
         }
@@ -54,17 +55,15 @@ namespace StgSharp.Modeling.Items
             get { return _position; }
             set
             {
-                if( value == null ) {
-                    throw new ArgumentNullException();
-                }
-
+                ArgumentNullException.ThrowIfNull( value );
                 _position = value;
             }
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        public void FromInstance( StepElementarySurface entity )
         {
-            yield return Position;
+            base.FromInstance( entity );
+            _position = entity.Position;
         }
 
     }

StgSharp.Model/Step/Items/StepEllipse.cs

@@ -28,45 +28,45 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepEllipse : StepConic
+    public class StepEllipse : StepConic, IExpConvertableFrom<StepEllipse>
     {
 
         private StepAxis2Placement _position;
 
-        private StepEllipse() : base( string.Empty ) { }
+        private StepEllipse( StepModel model ) : base( model ) { }
 
         public StepEllipse(
+               StepModel model,
                string name,
                StepAxis2Placement position,
-               double semiAxis1,
-               double semiAxis2 )
-            : base( name )
+               float semiAxis1,
+               float semiAxis2 )
+            : base( model )
         {
             Position = position;
             SemiAxis1 = semiAxis1;
             SemiAxis2 = semiAxis2;
         }
 
-        public double SemiAxis1 { get; set; }
+        public float SemiAxis1 { get; set; }
 
-        public double SemiAxis2 { get; set; }
+        public float SemiAxis2 { get; set; }
 
         public StepAxis2Placement Position
         {
             get { return _position; }
             set
             {
-                if( value == null ) {
-                    throw new ArgumentNullException();
-                }
+                ArgumentNullException.ThrowIfNull( value );
 
                 _position = value;
             }
@@ -74,22 +74,23 @@ namespace StgSharp.Modeling.Items
 
         public override StepItemType ItemType => StepItemType.Ellipse;
 
-        internal static StepEllipse CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
+        public void FromInstance( StepEllipse entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            StepEllipse ellipse = new StepEllipse();
-            enumerator.AssertEnumeratorCount( 4 );
-            ellipse.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => ellipse.Position = v.AsType<StepAxis2Placement>() );
-            ellipse.SemiAxis1 = ( enumerator.Values[ 2 ] as ExpRealNumberNode )!.Value;
-            ellipse.SemiAxis2 = ( enumerator.Values[ 3 ] as ExpRealNumberNode )!.Value;
-            return ellipse;
+            base.FromInstance( entity );
+            SemiAxis1 = entity.SemiAxis1;
+            SemiAxis2 = entity.SemiAxis2;
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        internal static StepEllipse FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
         {
-            yield return Position;
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            StepEllipse ellipse = new StepEllipse( binder );
+            enumerator.AssertEnumeratorCount( 4 );
+            ellipse.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            ellipse.Position = binder[ ( enumerator[ 1 ] as StepEntityInstanceNode )!.Id ]as StepAxis2Placement2D;
+            ellipse.SemiAxis1 = ( enumerator[ 2 ] as ExpRealNumberNode )!.Value;
+            ellipse.SemiAxis2 = ( enumerator[ 3 ] as ExpRealNumberNode )!.Value;
+            return ellipse;
         }
 
     }

StgSharp.Model/Step/Items/StepFace.cs

@@ -28,20 +28,34 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 using System.Linq;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepFace : StepTopologicalRepresentationItem
+    public class StepFace : StepTopologicalRepresentationItem, IExpConvertableFrom<StepFace>
     {
 
-        public StepFace( string name ) : base( name ) { }
+        public StepFace( StepModel model ) : base( model ) { }
 
-        public List<StepFaceBound> Bounds { get; } = new List<StepFaceBound>();
+        public List<StepFaceBound> Bounds { get; private set; } = new List<StepFaceBound>();
+
+        public override StepItemType ItemType => StepItemType.Face;
+
+        public void FromInstance( StepFace entity )
+        {
+            base.FromInstance( entity );
+            Bounds = entity.Bounds;
+        }
+
+        public override bool IsConvertableTo( string entityName )
+        {
+            return base.IsConvertableTo( entityName ) || entityName == "StepFace";
+        }
 
     }
 }

StgSharp.Model/Step/Items/StepFaceBound.cs

@@ -28,21 +28,22 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Script;
+using StgSharp.Model.Step;
 
+using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepFaceBound : StepTopologicalRepresentationItem
+    public class StepFaceBound : StepTopologicalRepresentationItem, IExpConvertableFrom<StepFaceBound>
     {
 
-        protected StepFaceBound() : base( string.Empty ) { }
+        public StepFaceBound( StepModel model ) : base( model ) { }
 
-        public StepFaceBound( string name, StepLoop bound, bool orientation )
-            : base( name )
+        public StepFaceBound( StepModel model, StepLoop bound, bool orientation )
+            : base( model )
         {
             Bound = bound;
             Orientation = orientation;
@@ -54,20 +55,22 @@ namespace StgSharp.Modeling.Items
 
         public StepLoop Bound { get; set; }
 
-        internal static StepFaceBound CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
+        public void FromInstance( StepFaceBound entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            enumerator.AssertEnumeratorCount( 3 );
-            StepFaceBound faceBound = new StepFaceBound();
-            faceBound.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue( enumerator.Values[ 1 ], v => faceBound.Bound = v.AsType<StepLoop>() );
-            faceBound.Orientation = ( enumerator.Values[ 2 ]as ExpBoolNode )!.Value;
-            return faceBound;
+            base.FromInstance( entity );
+            Bound = entity.Bound;
+            Orientation = entity.Orientation;
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        internal static StepFaceBound FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
         {
-            yield return Bound;
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            enumerator.AssertEnumeratorCount( 3 );
+            StepFaceBound faceBound = new StepFaceBound( binder );
+            faceBound.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            faceBound.Bound = binder[ enumerator[ 1 ] ] as StepLoop;
+            faceBound.Orientation = ( enumerator[ 2 ]as ExpBoolNode )!.Value;
+            return faceBound;
         }
 
     }

StgSharp.Model/Step/Items/StepFaceOuterBound.cs

@@ -28,33 +28,37 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepFaceOuterBound : StepFaceBound
+    public class StepFaceOuterBound : StepFaceBound, IExpConvertableFrom<StepFaceOuterBound>
     {
 
-        private StepFaceOuterBound() : base() { }
+        private StepFaceOuterBound( StepModel model ) : base( model ) { }
 
-        public StepFaceOuterBound( string name, StepLoop bound, bool orientation )
-            : base( name, bound, orientation ) { }
+        public StepFaceOuterBound( StepModel model, StepLoop bound, bool orientation )
+            : base( model, bound, orientation ) { }
 
         public override StepItemType ItemType => StepItemType.FaceOuterBound;
 
-        internal static new StepFaceOuterBound CreateFromSyntaxList(
-                                               StepBinder binder,
-                                               ExpNode syntaxList )
+        public void FromInstance( StepFaceOuterBound entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
+            base.FromInstance( entity );
+        }
+
+        internal static new StepFaceOuterBound FromSyntax(
+                                               StepModel binder,
+                                               ExpSyntaxNode syntaxList )
+        {
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
             enumerator.AssertEnumeratorCount( 3 );
-            StepFaceOuterBound faceOuterBound = new StepFaceOuterBound();
-            faceOuterBound.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => faceOuterBound.Bound = v.AsType<StepLoop>() );
-            faceOuterBound.Orientation = ( enumerator.Values[ 2 ]as ExpBoolNode )!.Value;
+            StepFaceOuterBound faceOuterBound = new StepFaceOuterBound( binder );
+            faceOuterBound.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            faceOuterBound.Bound = binder[ enumerator[ 1 ] ] as StepLoop;
+            faceOuterBound.Orientation = ( enumerator[ 2 ]as ExpBoolNode )!.Value;
             return faceOuterBound;
         }
 

StgSharp.Model/Step/Items/StepFaceSurface.cs

@@ -28,23 +28,31 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Script;
+using StgSharp.Model.Step;
 
+using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepFaceSurface : StepFace
+    public class StepFaceSurface : StepFace, IExpConvertableFrom<StepFaceSurface>
     {
 
-        public StepFaceSurface( string name ) : base( name ) { }
+        public StepFaceSurface( StepModel model ) : base( model ) { }
 
         public bool SameSense { get; set; }
 
         public StepSurface FaceGeometry { get; set; }
 
+        public void FromInstance( StepFaceSurface entity )
+        {
+            base.FromInstance( entity );
+            SameSense = entity.SameSense;
+            FaceGeometry = entity.FaceGeometry;
+        }
+
     }
 }
 

StgSharp.Model/Step/Items/StepGeometricRepresentationItem.cs

@@ -28,15 +28,27 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepGeometricRepresentationItem : StepRepresentationItem
+    public class StepGeometricRepresentationItem : StepRepresentationItem, IExpConvertableFrom<StepGeometricRepresentationItem>
     {
 
-        protected StepGeometricRepresentationItem( string name ) : base( name ) { }
+        public StepGeometricRepresentationItem( StepModel model ) : base( model ) { }
+
+        public void FromInstance( StepGeometricRepresentationItem entity )
+        {
+            base.FromInstance( entity );
+        }
+
+        public override bool IsConvertableTo( string entityName )
+        {
+            return base.IsConvertableTo( entityName ) ||
+                   entityName is "StepGeometricRepresentationItem";
+        }
 
     }
 }

StgSharp.Model/Step/Items/StepItemType.cs

@@ -1,131 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepItemType.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the ¡°Software¡±), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Script;
-using StgSharp.Script.Express;
-
-using System;
-
-namespace StgSharp.Modeling.Items
-{
-    public enum StepItemType
-    {
-
-        AdvancedFace,
-        AxisPlacement2D,
-        AxisPlacement3D,
-        BSplineCurveWithKnots,
-        CartesianPoint,
-        Circle,
-        CylindricalSurface,
-        Direction,
-        EdgeCurve,
-        EdgeLoop,
-        Ellipse,
-        FaceBound,
-        FaceOuterBound,
-        Line,
-        OrientedEdge,
-        Plane,
-        Vector,
-        VertexPoint
-
-    }
-
-    internal static class StepItemTypeExtensions
-    {
-
-        public const string AdvancedFaceText = "ADVANCED_FACE";
-        public const string Axis2Placement2DText = "AXIS2_PLACEMENT_2D";
-        public const string Axis2Placement3DText = "AXIS2_PLACEMENT_3D";
-        public const string BSplineCurveWithKnotsText = "B_SPLINE_CURVE_WITH_KNOTS";
-        public const string CartesianPointText = "CARTESIAN_POINT";
-        public const string CircleText = "CIRCLE";
-        public const string CylindricalSurfaceText = "CYLINDRICAL_SURFACE";
-        public const string DirectionText = "DIRECTION";
-        public const string EdgeCurveText = "EDGE_CURVE";
-        public const string EdgeLoopText = "EDGE_LOOP";
-        public const string EllipseText = "ELLIPSE";
-        public const string FaceBoundText = "FACE_BOUND";
-        public const string FaceOuterBoundText = "FACE_OUTER_BOUND";
-        public const string LineText = "LINE";
-        public const string OrientedEdgeText = "ORIENTED_EDGE";
-        public const string PlaneText = "PLANE";
-        public const string VectorText = "VECTOR";
-        public const string VertexPointText = "VERTEX_POINT";
-
-        public static string GetItemTypeString( this StepItemType type )
-        {
-            switch( type )
-            {
-                case StepItemType.AdvancedFace:
-                    return AdvancedFaceText;
-                case StepItemType.AxisPlacement2D:
-                    return Axis2Placement2DText;
-                case StepItemType.AxisPlacement3D:
-                    return Axis2Placement3DText;
-                case StepItemType.BSplineCurveWithKnots:
-                    return BSplineCurveWithKnotsText;
-                case StepItemType.CartesianPoint:
-                    return CartesianPointText;
-                case StepItemType.Circle:
-                    return CircleText;
-                case StepItemType.CylindricalSurface:
-                    return CylindricalSurfaceText;
-                case StepItemType.Direction:
-                    return DirectionText;
-                case StepItemType.EdgeCurve:
-                    return EdgeCurveText;
-                case StepItemType.EdgeLoop:
-                    return EdgeLoopText;
-                case StepItemType.Ellipse:
-                    return EllipseText;
-                case StepItemType.FaceBound:
-                    return FaceBoundText;
-                case StepItemType.FaceOuterBound:
-                    return FaceOuterBoundText;
-                case StepItemType.Line:
-                    return LineText;
-                case StepItemType.OrientedEdge:
-                    return OrientedEdgeText;
-                case StepItemType.Plane:
-                    return PlaneText;
-                case StepItemType.Vector:
-                    return VectorText;
-                case StepItemType.VertexPoint:
-                    return VertexPointText;
-                default:
-                    throw new InvalidOperationException( $"Unexpected item type {type}" );
-            }
-        }
-
-    }
-}
-

StgSharp.Model/Step/Items/StepLine.cs

@@ -1,52 +1,53 @@
 //-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepLine.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
+// -----------------------------------------------------------------------
+// file="StepLine.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
 //     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the ¡°Software¡±), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the ¡°Software¡±), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
 //     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
 //     
-//     THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Math;
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.Mathematics;
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepLine : StepCurve
+    public class StepLine : StepCurve, IExpConvertableFrom<StepLine>
     {
 
         private StepCartesianPoint _point;
         private StepVector _vector;
 
-        private StepLine() : base( string.Empty ) { }
+        private StepLine(StepModel model) : base(model) { }
 
-        public StepLine( string label, StepCartesianPoint point, StepVector vector )
-            : base( label )
+        public StepLine(StepModel model, StepCartesianPoint point, StepVector vector)
+            : base(model)
         {
             Point = point;
             Vector = vector;
@@ -57,10 +58,7 @@ namespace StgSharp.Modeling.Items
             get { return _point; }
             set
             {
-                if( value == null ) {
-                    throw new ArgumentNullException();
-                }
-
+                ArgumentNullException.ThrowIfNull(value);
                 _point = value;
             }
         }
@@ -72,53 +70,51 @@ namespace StgSharp.Modeling.Items
             get { return _vector; }
             set
             {
-                if( value == null ) {
-                    throw new ArgumentNullException();
-                }
-
+                ArgumentNullException.ThrowIfNull(value);
                 _vector = value;
             }
         }
 
+        public void FromInstance(StepLine entity)
+        {
+            base.FromInstance(entity);
+            Point = entity.Point;
+            Vector = entity.Vector;
+        }
+
         public static StepLine FromPoints(
+                               StepModel model,
                                float x1,
                                float y1,
                                float z1,
                                float x2,
                                float y2,
-                               float z2 )
+                               float z2)
         {
-            StepCartesianPoint start = new StepCartesianPoint( string.Empty, x1, y1, z1 );
+            StepCartesianPoint start = new StepCartesianPoint(model, x1, y1, z1);
             float dx = x2 - x1;
             float dy = y2 - y1;
             float dz = z2 - z1;
-            float length = Scaler.Sqrt( dx * dx + dy * dy + dz * dz );
+            float length = Scaler.Sqrt(dx * dx + dy * dy + dz * dz);
             float dxn = dx / length;
             float dyn = dy / length;
             float dzn = dz / length;
             StepVector vector = new StepVector(
-                string.Empty, new StepDirection( string.Empty, dxn, dyn, dzn ), length );
-            return new StepLine( string.Empty, start, vector );
+                model, new StepDirection(model, dxn, dyn, dzn), length);
+            return new StepLine(model, start, vector);
         }
 
-        internal static StepLine CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
+        internal static StepLine FromSyntax(StepModel binder, ExpSyntaxNode syntaxList)
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            StepLine line = new StepLine();
-            enumerator.AssertEnumeratorCount( 3 );
-            line.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => line.Point = v.AsType<StepCartesianPoint>() );
-            binder.BindValue( enumerator.Values[ 2 ], v => line.Vector = v.AsType<StepVector>() );
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator(syntaxList);
+            StepLine line = new StepLine(binder);
+            enumerator.AssertEnumeratorCount(3);
+            line.Name = (enumerator[0]as ExpStringNode)!.Value;
+            line.Point = binder[enumerator[1]] as StepCartesianPoint;
+            line.Vector = binder[enumerator[2]] as StepVector;
             return line;
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
-        {
-            yield return Point;
-            yield return Vector;
-        }
-
     }
 }
 

StgSharp.Model/Step/Items/StepLoop.cs

@@ -28,15 +28,21 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepLoop : StepTopologicalRepresentationItem
+    public abstract class StepLoop : StepTopologicalRepresentationItem, IExpConvertableFrom<StepLoop>
     {
 
-        public StepLoop( string name ) : base( name ) { }
+        protected StepLoop( StepModel model ) : base( model ) { }
+
+        public void FromInstance( StepLoop entity )
+        {
+            base.FromInstance( entity );
+        }
 
     }
 }

StgSharp.Model/Step/Items/StepOrientedEdge.cs

@@ -28,28 +28,31 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using Microsoft.Win32.SafeHandles;
+
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepOrientedEdge : StepEdge
+    public class StepOrientedEdge : StepEdge, IExpConvertableFrom<StepOrientedEdge>
     {
 
         private StepEdge _edgeElement;
 
-        private StepOrientedEdge() { }
+        private StepOrientedEdge( StepModel model ) : base( model ) { }
 
         public StepOrientedEdge(
-               string name,
+               StepModel model,
                StepVertex edgeStart,
                StepVertex edgeEnd,
                StepEdge edgeElement,
                bool orientation )
-            : base( name, edgeStart, edgeEnd )
+            : base( model, edgeStart, edgeEnd )
         {
             EdgeElement = edgeElement;
             Orientation = orientation;
@@ -72,31 +75,24 @@ namespace StgSharp.Modeling.Items
 
         public override StepItemType ItemType => StepItemType.OrientedEdge;
 
-        internal static StepOrientedEdge CreateFromSyntaxList(
-                                         StepBinder binder,
-                                         ExpNode syntaxList )
+        public void FromInstance( StepOrientedEdge entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            StepOrientedEdge orientedEdge = new StepOrientedEdge();
-            enumerator.AssertEnumeratorCount( 5 );
-            orientedEdge.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => orientedEdge.EdgeStart = v.AsType<StepVertex>() );
-            binder.BindValue(
-                enumerator.Values[ 2 ], v => orientedEdge.EdgeEnd = v.AsType<StepVertex>() );
-            binder.BindValue(
-                enumerator.Values[ 3 ], v => orientedEdge.EdgeElement = v.AsType<StepEdge>() );
-            orientedEdge.Orientation = ( enumerator.Values[ 4 ]as ExpBoolNode )!.Value;
-            return orientedEdge;
+            base.FromInstance( entity );
+            EdgeElement = entity.EdgeElement;
+            Orientation = entity.Orientation;
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        internal static StepOrientedEdge FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
         {
-            foreach( StepRepresentationItem item in base.GetReferencedItems() ) {
-                yield return item;
-            }
-
-            yield return EdgeElement;
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            StepOrientedEdge orientedEdge = new StepOrientedEdge( binder );
+            enumerator.AssertEnumeratorCount( 5 );
+            orientedEdge.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            orientedEdge.EdgeStart = binder[ enumerator[ 1 ] ]as StepVertex;
+            orientedEdge.EdgeEnd = binder[ enumerator[ 2 ] ] as StepVertex;
+            orientedEdge.EdgeElement = binder[ enumerator[ 3 ] ] as StepEdge;
+            orientedEdge.Orientation = ( enumerator[ 4 ]as ExpBoolNode )!.Value;
+            return orientedEdge;
         }
 
     }

StgSharp.Model/Step/Items/StepPlacement.cs

@@ -28,15 +28,47 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+using System;
+
+namespace StgSharp.Model.Step
 {
-    public abstract class StepPlacement : StepGeometricRepresentationItem
+    public class StepPlacement : StepGeometricRepresentationItem, IExpConvertableFrom<StepPlacement>
     {
 
-        protected StepPlacement( string name ) : base( name ) { }
+        private StepCartesianPoint _location;
+
+        public StepPlacement( StepModel model ) : base( model ) { }
+
+        public StepPlacement( StepModel model, StepCartesianPoint location )
+            : base( model )
+        {
+            _location = location;
+        }
+
+        public StepCartesianPoint Location
+        {
+            get { return _location; }
+            set
+            {
+                ArgumentNullException.ThrowIfNull( value );
+                _location = value;
+            }
+        }
+
+        public void FromInstance( StepPlacement entity )
+        {
+            base.FromInstance( entity );
+            this.Location = entity.Location;
+        }
+
+        public override bool IsConvertableTo( string entityName )
+        {
+            return base.IsConvertableTo( entityName ) || entityName == "StepPlacement";
+        }
 
     }
 }

StgSharp.Model/Step/Items/StepPlane.cs

@@ -28,29 +28,35 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-
+using StgSharp.Geometries;
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepPlane : StepElementarySurface
+    public class StepPlane : StepElementarySurface, IExpConvertableFrom<StepPlane>
     {
 
-        private StepPlane() : base() { }
+        public StepPlane( StepModel model ) : base( model ) { }
 
-        public StepPlane( string name, StepAxis2Placement3D position ) : base( name, position ) { }
+        public StepPlane( StepModel model, StepAxis2Placement3D position )
+            : base( model, position ) { }
 
         public override StepItemType ItemType => StepItemType.Plane;
 
-        internal static StepPlane CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
+        public void FromInstance( StepPlane entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            StepPlane plane = new StepPlane();
+            base.FromInstance( entity );
+        }
+
+        internal static StepPlane FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        {
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            StepPlane plane = new StepPlane( binder );
             enumerator.AssertEnumeratorCount( 2 );
-            plane.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => plane.Position = v.AsType<StepAxis2Placement3D>() );
+            plane.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            plane.Position = binder[ enumerator[ 1 ] ] as StepAxis2Placement3D;
             return plane;
         }
 

StgSharp.Model/Step/Items/StepPoint.cs

@@ -28,15 +28,30 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+using System;
+
+namespace StgSharp.Model.Step
 {
-    public abstract class StepPoint : StepGeometricRepresentationItem
+    public class StepPoint : StepGeometricRepresentationItem, IExpConvertableFrom<StepPoint>
     {
 
-        protected StepPoint( string name ) : base( name ) { }
+        public StepPoint( StepModel model ) : base( model ) { }
+
+        public override StepItemType ItemType => StepItemType.Point;
+
+        public void FromInstance( StepPoint entity )
+        {
+            base.FromInstance( entity );
+        }
+
+        public override bool IsConvertableTo( string entityName )
+        {
+            return base.IsConvertableTo( entityName ) || entityName == "StepPoint";
+        }
 
     }
 }

StgSharp.Model/Step/Items/StepRepresentationItem.cs

@@ -28,29 +28,35 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Script;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 
+using StgSharp.Model.Step;
+using StgSharp.Script;
 using StgSharp.Script.Express;
 
+using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract partial class StepRepresentationItem
+    public class StepRepresentationItem : StepEntityBase, IExpConvertableFrom<StepRepresentationItem>
     {
 
-        protected StepRepresentationItem( string name )
+        protected StepRepresentationItem( StepModel model )
         {
-            Name = name;
+            Context = model;
         }
 
-        public abstract StepItemType ItemType { get; }
+        public override StepItemType ItemType => StepItemType.PresentationItem;
 
-        public string Name { get; set; }
-
-        internal virtual IEnumerable<StepRepresentationItem> GetReferencedItems()
+        public void FromInstance( StepRepresentationItem entity )
         {
-            yield break;
+            base.FromInstance( entity );
+        }
+
+        public virtual bool IsConvertableTo( string entityName )
+        {
+            return entityName == "StepRepresentationItem";
         }
 
     }

StgSharp.Model/Step/Items/StepRepresentationItem_FromTypedParameter.cs

@@ -1,127 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepRepresentationItem_FromTypedParameter.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the ¡°Software¡±), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Script;
-using StgSharp.Script.Express;
-
-using System.Collections.Generic;
-using System.Diagnostics;
-
-namespace StgSharp.Modeling.Items
-{
-    public abstract partial class StepRepresentationItem
-    {
-
-        internal static HashSet<string> UnsupportedItemTypes { get; } = new HashSet<string>();
-
-        internal static StepRepresentationItem FromTypedParameter(
-                                               StepBinder binder,
-                                               ExpNode itemSyntax )
-        {
-            StepRepresentationItem item = null!;
-            if( itemSyntax is ExpElementInitializingNode initNode )
-            {
-                string name = initNode.EqualityTypeConvert.Name;
-                switch( name )
-                {
-                    case StepItemTypeExtensions.AdvancedFaceText:
-                        item = StepAdvancedFace.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.Axis2Placement2DText:
-                        item = StepAxis2Placement2D.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.Axis2Placement3DText:
-                        item = StepAxis2Placement3D.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.BSplineCurveWithKnotsText:
-                        item = StepBSplineCurveWithKnots.CreateFromSyntaxList(
-                            binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.CartesianPointText:
-                        item = StepCartesianPoint.CreateFromSyntaxList( initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.CircleText:
-                        item = StepCircle.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.CylindricalSurfaceText:
-                        item = StepCylindricalSurface.CreateFromSyntaxList( binder,
-                                                                            initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.DirectionText:
-                        item = StepDirection.CreateFromSyntaxList( initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.EdgeCurveText:
-                        item = StepEdgeCurve.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.EdgeLoopText:
-                        item = StepEdgeLoop.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.EllipseText:
-                        item = StepEllipse.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.FaceBoundText:
-                        item = StepFaceBound.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.FaceOuterBoundText:
-                        item = StepFaceOuterBound.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.LineText:
-                        item = StepLine.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.OrientedEdgeText:
-                        item = StepOrientedEdge.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.PlaneText:
-                        item = StepPlane.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.VectorText:
-                        item = StepVector.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.VertexPointText:
-                        item = StepVertexPoint.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    default:
-                        if( UnsupportedItemTypes.Add( name ) ) {
-                            Debug.WriteLine(
-                                $"Unsupported item {name} at {initNode.Line}, {initNode.Column}" );
-                        }
-                        break;
-                }
-            } else
-            {
-                // TODO:
-            }
-
-            return item;
-        }
-
-    }
-}
-

StgSharp.Model/Step/Items/StepSurface.cs

@@ -28,15 +28,26 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepSurface : StepGeometricRepresentationItem
+    public class StepSurface : StepGeometricRepresentationItem, IExpConvertableFrom<StepSurface>
     {
 
-        public StepSurface( string name ) : base( name ) { }
+        protected StepSurface( StepModel model ) : base( model ) { }
+
+        public void FromInstance( StepSurface entity )
+        {
+            base.FromInstance( entity );
+        }
+
+        public override bool IsConvertableTo( string entityName )
+        {
+            return base.IsConvertableTo( entityName ) || entityName == "StepSurface";
+        }
 
     }
 }

StgSharp.Model/Step/Items/StepTopologicalRepresentationItem.cs

@@ -28,15 +28,29 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+using System;
+
+namespace StgSharp.Model.Step
 {
-    public abstract class StepTopologicalRepresentationItem : StepRepresentationItem
+    public class StepTopologicalRepresentationItem : StepRepresentationItem, IExpConvertableFrom<StepTopologicalRepresentationItem>
     {
 
-        protected StepTopologicalRepresentationItem( string name ) : base( name ) { }
+        protected StepTopologicalRepresentationItem( StepModel model ) : base( model ) { }
+
+        public void FromInstance( StepTopologicalRepresentationItem entity )
+        {
+            base.FromInstance( entity );
+        }
+
+        public override bool IsConvertableTo( string entityName )
+        {
+            return base.IsConvertableTo( entityName ) ||
+                   entityName == "StepTopologicalRepresentationItem";
+        }
 
     }
 }

StgSharp.Model/Step/Items/StepTriple.cs

@@ -1,51 +1,52 @@
 //-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepTriple.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
+// -----------------------------------------------------------------------
+// file="StepTriple.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
 //     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the ¡°Software¡±), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the ¡°Software¡±), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
 //     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
 //     
-//     THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Math;
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.Mathematics;
 
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepTriple : StepPoint
+    public abstract class StepTriple : StepPoint, IExpConvertableFrom<StepTriple>
     {
 
         private Vec3 _coord;
 
-        protected StepTriple() : this( string.Empty, 0.0f, 0.0f, 0.0f ) { }
+        protected StepTriple(StepModel model) : this(model, 0.0f, 0.0f, 0.0f) { }
 
-        protected StepTriple( string name, float x, float y, float z )
-            : base( name )
+        protected StepTriple(StepModel model, float x, float y, float z)
+            : base(model)
         {
             X = x;
             Y = y;
@@ -72,19 +73,28 @@ namespace StgSharp.Modeling.Items
 
         protected abstract int MinimumValueCount { get; }
 
-        public bool Equals( StepTriple other )
+        public bool Equals(StepTriple other)
         {
-            if( ( object )other == null ) {
+            if (other is null) {
                 return false;
             }
 
-            return ItemType == other.ItemType && X == other.X && Y == other.Y && Z == other.Z && Name ==
-                   other.Name;
+            return ItemType == other.ItemType &&
+                   X == other.X &&
+                   Y == other.Y &&
+                   Z == other.Z &&
+                   Name == other.Name;
         }
 
-        public override bool Equals( object obj )
+        public override bool Equals(object obj)
         {
-            return ( obj is StepTriple triple ) && Equals( triple );
+            return (obj is StepTriple triple) && Equals(triple);
+        }
+
+        public void FromInstance(StepTriple entity)
+        {
+            base.FromInstance(entity);
+            _coord = entity._coord;
         }
 
         public override int GetHashCode()
@@ -92,35 +102,38 @@ namespace StgSharp.Modeling.Items
             return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode();
         }
 
-        internal static StepTriple AssignTo( StepTriple triple, ExpNode values )
+        public override bool IsConvertableTo(string entityName)
         {
-            ExpNodeNextEnumerator enumerator = values.GetEnumerator();
-            enumerator.AssertEnumeratorCount( 2 );
-            triple.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            object pointValues = enumerator.Values[ 1 ].GetValueList();
-            pointValues.AssertEnumeratorCount( triple.MinimumValueCount, 3 );
-            triple.X = pointValues.GetRealValueOrDefault( 0 );
-            triple.Y = pointValues.GetRealValueOrDefault( 1 );
-            triple.Z = pointValues.GetRealValueOrDefault( 2 );
+            return base.IsConvertableTo(entityName) || entityName == "StepTriple";
+        }
+
+        internal static T AssignTo<T>(T triple, ExpSyntaxNode values) where T: StepTriple
+        {
+            ExpNodePresidentEnumerator enumerator = values.ToPresidentEnumerator();
+            enumerator.AssertEnumeratorCount(2);
+            triple.Name = (enumerator[0]as ExpStringNode)!.Value;
+            ExpNodePresidentEnumerator pointValues = enumerator[1].TupleToPresidentEnumerator();
+            pointValues.AssertEnumeratorCount(triple.MinimumValueCount, 3);
+            triple._coord = StepDataParser.ToVector3D(pointValues[0]);
             return triple;
         }
 
-        public static bool operator !=( StepTriple left, StepTriple right )
+        public static bool operator !=(StepTriple left, StepTriple right)
         {
-            return !( left == right );
+            return !(left == right);
         }
 
-        public static bool operator ==( StepTriple left, StepTriple right )
+        public static bool operator ==(StepTriple left, StepTriple right)
         {
-            if( ReferenceEquals( left, right ) ) {
+            if (ReferenceEquals(left, right)) {
                 return true;
             }
 
-            if( ( object )left == null || ( object )right == null ) {
+            if (left is null || right is null) {
                 return false;
             }
 
-            return left.Equals( right );
+            return left.Equals(right);
         }
 
     }

StgSharp.Model/Step/Items/StepVector.cs

@@ -28,23 +28,24 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepVector : StepGeometricRepresentationItem
+    public class StepVector : StepGeometricRepresentationItem, IExpConvertableFrom<StepVector>
     {
 
         private StepDirection _direction;
 
-        private StepVector() : base( string.Empty ) { }
+        private StepVector( StepModel model ) : base( model ) { }
 
-        public StepVector( string name, StepDirection direction, double length )
-            : base( name )
+        public StepVector( StepModel model, StepDirection direction, double length )
+            : base( model )
         {
             Direction = direction;
             Length = length;
@@ -57,9 +58,7 @@ namespace StgSharp.Modeling.Items
             get { return _direction; }
             set
             {
-                if( value == null ) {
-                    throw new ArgumentNullException();
-                }
+                ArgumentNullException.ThrowIfNull( value );
 
                 _direction = value;
             }
@@ -67,21 +66,21 @@ namespace StgSharp.Modeling.Items
 
         public override StepItemType ItemType => StepItemType.Vector;
 
-        internal static StepVector CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
+        public void FromInstance( StepVector entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            StepVector vector = new StepVector();
-            enumerator.AssertEnumeratorCount( 3 );
-            vector.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => vector.Direction = v.AsType<StepDirection>() );
-            vector.Length = ( enumerator.Values[ 2 ]as ExpRealNumberNode )!.Value;
-            return vector;
+            base.FromInstance( entity );
+            _direction = entity.Direction;
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        internal static StepVector FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
         {
-            yield return Direction;
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            StepVector vector = new StepVector( binder );
+            enumerator.AssertEnumeratorCount( 3 );
+            vector.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            vector.Direction = binder[ enumerator[ 1 ] ] as StepDirection;
+            vector.Length = ( enumerator[ 2 ]as ExpRealNumberNode )!.Value;
+            return vector;
         }
 
     }

StgSharp.Model/Step/Items/StepVertex.cs

@@ -1,42 +1,52 @@
 //-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepVertex.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
+// -----------------------------------------------------------------------
+// file="StepVertex.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
 //     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the ¡°Software¡±), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the ¡°Software¡±), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
 //     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
 //     
-//     THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.Mathematics;
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public abstract class StepVertex : StepTopologicalRepresentationItem
+    public class StepVertex : StepTopologicalRepresentationItem, IExpConvertableFrom<StepVertex>
     {
 
-        protected StepVertex( string name ) : base( name ) { }
+        public StepVertex(StepModel model) : base(model) { }
+
+        public Vec3 Vertex { get; set; }
+
+        public void FromInstance(StepVertex entity)
+        {
+            base.FromInstance(entity);
+            Vertex = entity.Vertex;
+        }
 
     }
 }

StgSharp.Model/Step/Items/StepVertexPoint.cs

@@ -28,23 +28,24 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Modeling.Items
+namespace StgSharp.Model.Step
 {
-    public class StepVertexPoint : StepVertex
+    public class StepVertexPoint : StepVertex, IExpConvertableFrom<StepVertexPoint>
     {
 
         private StepCartesianPoint _location;
 
-        private StepVertexPoint() : base( string.Empty ) { }
+        public StepVertexPoint( StepModel model ) : base( model ) { }
 
-        public StepVertexPoint( string name, StepCartesianPoint location )
-            : base( name )
+        public StepVertexPoint( StepModel model, StepCartesianPoint location )
+            : base( model )
         {
             Location = location;
         }
@@ -54,32 +55,27 @@ namespace StgSharp.Modeling.Items
             get { return _location; }
             set
             {
-                if( value == null ) {
-                    throw new ArgumentNullException();
-                }
-
+                ArgumentNullException.ThrowIfNull( value );
                 _location = value;
             }
         }
 
         public override StepItemType ItemType => StepItemType.VertexPoint;
 
-        internal static StepVertexPoint CreateFromSyntaxList(
-                                        StepBinder binder,
-                                        ExpNode syntaxList )
+        public void FromInstance( StepVertexPoint entity )
         {
-            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
-            StepVertexPoint vertex = new StepVertexPoint();
-            enumerator.AssertEnumeratorCount( 2 );
-            vertex.Name = enumerator.Values[ 0 ].CodeConvertTemplate;
-            binder.BindValue(
-                enumerator.Values[ 1 ], v => vertex.Location = v.AsType<StepCartesianPoint>() );
-            return vertex;
+            base.FromInstance( entity );
+            this.Location = entity.Location;
         }
 
-        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        internal static StepVertexPoint FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
         {
-            yield return Location;
+            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            StepVertexPoint vertex = new StepVertexPoint( binder );
+            enumerator.AssertEnumeratorCount( 2 );
+            vertex.Name = ( enumerator[ 0 ]as ExpStringNode )!.Value;
+            vertex.Location = binder[ enumerator[ 1 ] ] as StepCartesianPoint;
+            return vertex;
         }
 
     }

StgSharp.Model/Step/Reader/ExpSyntaxAnalyzer.Common.cs

@@ -1,290 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepExpSyntaxAnalyzer.Common.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
-using StgSharp.Script;
-using StgSharp.Script.Express;
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
-using System.Xml.Schema;
-
-using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
-
-namespace StgSharp.Modeling.Step
-{
-    public partial class StepExpSyntaxAnalyzer
-    {
-
-        private bool IsSeparatorMatch( Token leftSperator, Token rightSeparator )
-        {
-            return leftSperator.Value switch
-            {
-                ExpKeyword.LeftBrace => rightSeparator.Value == ExpKeyword.RightBrace,
-                ExpKeyword.LeftParen => rightSeparator.Value == ExpKeyword.RightParen,
-                ExpKeyword.Comma => rightSeparator.Value == ExpKeyword.Comma,
-                ExpKeyword.Semicolon => rightSeparator.Value == ExpKeyword.Semicolon,
-                _ => false
-            };
-        }
-
-        private bool TryAppendIndexLeft( Token t )
-        {
-            if( t.Flag != TokenFlag.Index_Left ) {
-                return false;
-            }
-            if( _cache.TryPeekOperand( out bool isNode, out _, out ExpNode? node ) )
-            {
-                if( node.EqualityTypeConvert is not ExpCollectionBase ) {
-                    ExpInvalidSyntaxException.ThrowNonCollectionIndex( t );
-                }
-            }
-            _cache.PushOperator( t );
-            _cache.IncreaseDepth( ( int )ExpCompileStateCode.CollectionIndex );
-            return true;
-        }
-
-        private bool TryAppendIndexRight( Token t )
-        {
-            if( t.Flag != TokenFlag.Index_Right ) {
-                return false;
-            }
-
-            //reverse building
-            ClosePrefixReverse( t );
-
-            //make index node
-            _cache.PopOperand( out _, out ExpNode? expNode );
-            if( !_cache.PopOperand( out Token colleToken, out ExpNode? colleNode ) ) { }
-            _cache.PushOperand(
-                ExpCollectionIndexNode.Create(
-                    t, ( colleNode as ExpCollectionInstanceBase )!, expNode ) );
-            return true;
-        }
-
-        private bool TryAppendMember( Token t )
-        {
-            if( t.Flag != TokenFlag.Member ) {
-                return false;
-            }
-            if( TryParseConstant( t ) ) {
-                return true;
-            }
-            if( TryParseFunction( t ) ) {
-                return true;
-            }
-            if( TryParseInstance( t ) ) {
-                return true;
-            }
-            if( TryParseKeyword( t ) ) {
-                return true;
-            }
-            if( TryParseElementName( t ) ) {
-                return true;
-            }
-
-            //Many thing miss here
-            _cache.PushOperand( ExpElementMemberNameNode.Create( t ) );
-
-            return true;
-        }
-
-        private bool TryAppendMiddleSeparator( Token t )
-        {
-            if( t.Flag != TokenFlag.Separator_Middle ) {
-                return false;
-            }
-            while( _cache.OperatorAheadOfDepth > 0 )
-            {
-                _cache.TryPopOperator( out Token op );
-                ExpNode node = ConvertAndPushOneOperator( op );
-            }
-            switch( _cache.OperandAheadOfDepth )
-            {
-                case 0:
-                    if( t.Value == ";" ) {
-                        return true;
-                    }
-                    _cache.StatementsInDepth.Push( ExpNode.Empty );
-                    goto case 1;
-                case 1:
-                    _cache.PopOperand( out _, out ExpNode? statement );
-                    _cache.StatementsInDepth.Push( statement );
-                    return true;
-                default:
-                    ExpInvalidSyntaxException.ThrowNoOperator( t );
-                    break;
-            }
-            return true;
-        }
-
-        private bool TryAppendNumAndStrLiteral( Token t )
-        {
-            if( ( t.Flag & ( TokenFlag.String | TokenFlag.Number ) ) == 0 ) {
-                return false;
-            }
-            _cache.PushOperand( ExpElementInstance.CreateLiteral( t ) );
-            return true;
-        }
-
-        private bool TryAppendPrefixSeparator( Token t )
-        {
-            if( t.Flag != TokenFlag.Separator_Left ) {
-                return false;
-            }
-            _cache.PushOperator( t );
-            _cache.IncreaseDepth( ( int )ExpCompileStateCode.Common );
-            return true;
-        }
-
-        private bool TryAppendPrefixSeparatorEnd( Token t )
-        {
-            if( t.Flag != TokenFlag.Separator_Right ) {
-                return false;
-            }
-            ClosePrefixReverse( t );
-            return true;
-        }
-
-        private bool TryAppendSymbol( Token t )
-        {
-            if( ( t.Flag & ( TokenFlag.Symbol_Unary | TokenFlag.Symbol_Binary ) ) == 0 ) {
-                return false;
-            }
-
-            int cmp = -1;
-            processPrecedence:
-            if( _cache.TryPeekOperator( out Token tmp ) )
-            {
-                cmp = CompareOperatorPrecedence( t, tmp );
-                if( cmp >= 0 )
-                {
-                    _cache.PopOperator();
-                    ExpNode node = ConvertAndPushOneOperator( tmp );
-                    goto processPrecedence;
-                }
-            }
-            _cache.PushOperator( t );
-            return true;
-        }
-
-        private bool TryParseConstant( Token t )
-        {
-            switch( t.Value )
-            {
-                case ExpKeyword.E:
-                    _cache.PushOperand( new ExpRealNumberNode( t, MathF.E, true ) );
-                    return true;
-                case ExpKeyword.Pi:
-                    _cache.PushOperand( new ExpRealNumberNode( t, MathF.PI, true ) );
-                    return true;
-                default:
-                    if( ExpElementInstance.TryCreateLiteral( t, out ExpElementInstance? node ) )
-                    {
-                        _cache.PushOperand( node );
-                        return true;
-                    }
-                    return false;
-            }
-        }
-
-        private bool TryParseElementName( Token t )
-        {
-            if( _context.TryGetType( t.Value, out ExpTypeSource? type ) )
-            {
-                _cache.PushOperand( ExpMetaRefNode.RefType( t, type ) );
-                return true;
-            }
-            if( _context.TryGetEntity( t.Value, out ExpEntitySource? entity ) )
-            {
-                _cache.PushOperand( ExpMetaRefNode.RefEntity( t, entity ) );
-                return true;
-            }
-            return false;
-        }
-
-        private bool TryParseFunction( Token t )
-        {
-            if( ExpKeyword.BuiltinFunctions.Contains( t.Value ) )
-            {
-                _cache.PushOperator( t );
-                return true;
-            } else if( _context.TryGetFunction( t.Value, out ExpFunctionSource? f ) )
-            {
-                _cache.PushOperand( t );
-                return true;
-            }
-            return false;
-        }
-
-        private bool TryParseInstance( Token t )
-        {
-            if( _local.TryGetMember( t.Value,
-                                     out ExpNode? node ) && node is ExpElementInstance instance )
-            {
-                _cache.PushOperand( ExpInstanceReferenceNode.MakeReferenceFrom( t, instance ) );
-                return true;
-            } else if( _cache.IsLastAddedOperator )
-            {
-                if( _cache.PeekOperand( out _,
-                                        out ExpNode? typenode ) && typenode is ExpMetaRefNode typeRef )
-                {
-                    _cache.PopOperand( out _, out _ );
-                    _local.AddMember( t.Value, typeRef.SourceRef.CreateInstanceNode( t ) );
-                } else
-                {
-                    return false;
-                }
-            }
-            return false;
-        }
-
-        private bool TryParseKeyword( Token t )
-        {
-            switch( t.Value )
-            {
-                case ExpKeyword.Return:
-                    _cache.PushOperator( t );
-                    return true;
-                case ExpKeyword.Skip:
-                    _cache.PushOperand( ExpProcedureControlNode.Skip( t ) );
-                    return true;
-                default:
-                    return false;
-            }
-        }
-
-    }
-}

StgSharp.Model/Step/Reader/ExpSyntaxAnalyzer.ErrorProcess.cs

@@ -1,56 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="ExpSyntaxAnalyzer.ErrorProcess.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StgSharp.Modeling.Step
-{
-    public partial class StepExpSyntaxAnalyzer
-    {
-
-        public void ThrowCompileException( int errorCode )
-        {
-            switch( errorCode )
-            {
-                case 0 or 1:
-                    return;
-                case TokenTypeNotMatch:
-                    throw new Exception();
-                default:
-                    break;
-            }
-        }
-
-    }
-}

StgSharp.Model/Step/Reader/ExpSyntaxAnalyzer.OperatorParser.cs

@@ -1,184 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="ExpSyntaxAnalyzer.OperatorParser.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Script;
-using StgSharp.Script.Express;
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
-
-namespace StgSharp.Modeling.Step
-{
-    public partial class StepExpSyntaxAnalyzer
-    {
-
-        public int CompareOperatorPrecedence( Token left, Token right )
-        {
-            ExpressCompile.TryGetOperatorPrecedence( left.Value, out int leftPrecedence );
-            ExpressCompile.TryGetOperatorPrecedence( right.Value, out int rightPrecedence );
-            return leftPrecedence - rightPrecedence;
-        }
-
-        public bool TryGenerateUnaryNode( Token t, out ExpNode node )
-        {
-            ExpNode operand = GetNextOperandCache();
-            switch( t.Value )
-            {
-                case ExpKeyword.UnaryPlus:
-                    node = ExpUnaryOperatorNode.UnaryPlus( t, operand );
-                    return true;
-                case ExpKeyword.UnaryMinus:
-                    node = ExpUnaryOperatorNode.UnaryMinus( t, operand );
-                    return true;
-                case ExpKeyword.Not:
-                    node = ExpUnaryOperatorNode.UnaryNot( t, operand );
-                    return true;
-                default:
-                    node = ExpNode.Empty;
-                    return false;
-            }
-        }
-
-        /// <summary>
-        ///   WARNING: This method cannot process INDEXOF, FUNCTION CALLING, LOOP and any ENDING
-        ///   SYMBOLS.
-        /// </summary>
-        private ExpNode ConvertAndPushOneOperator( Token op )
-        {
-            switch( op.Flag )
-            {
-                case TokenFlag.Symbol_Unary:
-                    TryGenerateUnaryNode( op, out ExpNode? node );
-                    _cache.PushOperand( node );
-                    return node;
-                case TokenFlag.Symbol_Binary:
-                    TryGenerateBinaryNode( op, out node );
-                    _cache.PushOperand( node );
-                    return node;
-                case TokenFlag.Member:
-                    if( _context.TryGetFunction( op.Value, out ExpFunctionSource? f ) )
-                    {
-                        if( !_cache.PopOperand( out Token t, out ExpNode? p ) )
-                        {
-                            node = ExpFunctionCallingNode.CallFunction( op, f, p );
-                            return node;
-                        } else
-                        {
-                            throw new ExpCompileException(
-                                t,
-                                "An ExpNode for function calling is needed, but a token was popped" );
-                        }
-                    } else if( _context.TryGetProcedure( op.Value, out ExpProcedureSource? p ) )
-                    {
-                        if( !_cache.PopOperand( out Token t, out ExpNode? param ) )
-                        {
-                            node = ExpProcedureCallingNode.CallProcedure( op, p, param );
-                            return node;
-                        } else
-                        {
-                            throw new ExpCompileException(
-                                t,
-                                "An ExpNode for function calling is needed, but a token was popped" );
-                        }
-                    } else if( ExpSchema.BuiltinSchema.TryGetFunction( op.Value, out f ) )
-                    {
-                        if( !_cache.PopOperand( out Token t, out ExpNode? param ) )
-                        {
-                            node = ExpFunctionCallingNode.CallFunction( op, f, param );
-                            return node;
-                        } else
-                        {
-                            throw new ExpCompileException(
-                                t,
-                                "An ExpNode for function calling is needed, but a token was popped" );
-                        }
-                    } else
-                    {
-                        throw new NotImplementedException();
-
-                        //uncertain case here
-                    }
-                default:
-                    throw new NotImplementedException();
-            }
-        }
-
-        private bool TryGenerateBinaryNode( Token t, out ExpNode node )
-        {
-            ExpNode right = GetNextOperandCache();
-            ExpNode left = GetNextOperandCache();
-            switch( t.Value )
-            {
-                case ExpKeyword.Add:
-                    node = ExpBinaryOperatorNode.Add( t, left, right );
-                    return true;
-                case ExpKeyword.Sub:
-                    node = ExpBinaryOperatorNode.Sub( t, left, right );
-                    return true;
-                case ExpKeyword.Mul:
-                    node = ExpBinaryOperatorNode.Mul( t, left, right );
-                    return true;
-                case ExpKeyword.Div:
-                    node = ExpBinaryOperatorNode.Div( t, left, right );
-                    return true;
-                case ExpKeyword.Equal:
-                    node = ExpBinaryOperatorNode.EqualTo( t, left, right );
-                    return true;
-                case ExpKeyword.NotEqual:
-                    node = ExpBinaryOperatorNode.NotEqualTo( t, left, right );
-                    return true;
-                case ExpKeyword.GreaterThan:
-                    node = ExpBinaryOperatorNode.GreaterThan( t, left, right );
-                    return true;
-                case ExpKeyword.LessThan:
-                    node = ExpBinaryOperatorNode.LessThan( t, left, right );
-                    return true;
-                case ExpKeyword.Assignment:
-                    node = ExpBinaryOperatorNode.Assign( t, left, right );
-                    return true;
-                case ExpKeyword.InstanceEqual:
-                    node = ExpBinaryOperatorNode.CompareInstanceEqual( t, left, right );
-                    return true;
-                case ExpKeyword.InstanceNotEqual:
-                    node = ExpBinaryOperatorNode.CompareInstanceNotEqual( t, left, right );
-                    return true;
-                default:
-                    node = ExpNode.Empty;
-                    return false;
-            }
-        }
-
-    }
-}

StgSharp.Model/Step/Reader/ExpSyntaxAnalyzer.PrefixReverseAnalysing.cs

@@ -1,85 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepExpSyntaxAnalyzer.PrefixReverseAnalysing.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Script;
-using StgSharp.Script.Express;
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel.DataAnnotations;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
-
-namespace StgSharp.Modeling.Step
-{
-    public partial class StepExpSyntaxAnalyzer
-    {
-
-        private void ClosePrefixReverse( Token rightSeparator )
-        {
-            Token op;
-            ExpNode root;
-            if( _cache.OperatorAheadOfDepth == 0 )
-            {
-                if( _cache.OperandAheadOfDepth == 1 )
-                {
-                    _cache.PopOperand( out _, out ExpNode? statement );
-                    _cache.StatementsInDepth.Push( statement );
-                } else
-                {
-                    ExpInvalidSyntaxException.ThrowNoOperator( rightSeparator );
-                }
-            } else
-            {
-                while( _cache.TryPopOperator( out op ) ) {
-                    ConvertAndPushOneOperator( op );
-                }
-                _cache.PopOperand( out _, out root );
-                _cache.StatementsInDepth.Push( root );
-            }
-
-            root = _cache.PackAllStatements();
-            _cache.DecreaseDepth();
-            if( IsSeparatorMatch( _cache.PeekOperator(), rightSeparator ) )
-            {
-                _cache.PopOperator();
-                _cache.PushOperand( root );
-            } else
-            {
-                throw new ExpCompileException(
-                    rightSeparator, "Ending of block does not match its begging" );
-            }
-        }
-
-    }
-}

StgSharp.Model/Step/Reader/ExpSyntaxAnalyzer.cs

@@ -1,145 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepExpSyntaxAnalyzer.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
-using StgSharp.Script;
-using StgSharp.Script.Express;
-using StgSharp.Threading;
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO.Pipes;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
-
-namespace StgSharp.Modeling.Step
-{
-    public partial class StepExpSyntaxAnalyzer : ISyntaxAnalyzer
-    {
-
-        private const int EndLine = 1;
-        private const int TokenGenerated = 0;
-        private const int TokenTypeNotMatch = -1;
-
-        private CompileStack<ExpNode, IExpElementSource> _cache;
-        private ExpNode _lastStatement;
-        private ExpSchema _context;
-        private IExpElementSource _local;
-
-        public StepExpSyntaxAnalyzer()
-        {
-            _cache = new CompileStack<ExpNode, IExpElementSource>();
-        }
-
-        public StepExpSyntaxAnalyzer( ExpSchema context, IExpElementSource local )
-        {
-            _cache = new CompileStack<ExpNode, IExpElementSource>();
-            ArgumentNullException.ThrowIfNull( context );
-            if( context is not ExpSchema_Builtin )
-            {
-                _context = context;
-            } else
-            {
-                throw new InvalidCastException( "Not a valid Schema type" );
-            }
-            _local = local;
-        }
-
-        /// <summary>
-        ///   Append a token to top of cache. This method will automatically convert token to node
-        ///   if meets separators or operators.
-        /// </summary>
-        public void AppendToken( Token expToken )
-        {
-            switch( expToken.Flag )
-            {
-                case TokenFlag.Symbol_Unary or TokenFlag.Symbol_Binary:
-                    TryAppendSymbol( expToken );
-                    break;
-                case TokenFlag.Number or TokenFlag.String:
-                    ExpElementInstance node = ExpElementInstance.CreateLiteral( expToken );
-                    _cache.PushOperand( node );
-                    break;
-                case TokenFlag.Separator_Left:
-                    TryAppendPrefixSeparator( expToken );
-                    break;
-                case TokenFlag.Separator_Right:
-                    TryAppendPrefixSeparatorEnd( expToken );
-                    break;
-                case TokenFlag.Separator_Middle:
-                    TryAppendMiddleSeparator( expToken );
-                    break;
-                case TokenFlag.Index_Left:
-                    TryAppendIndexLeft( expToken );
-                    break;
-                case TokenFlag.Index_Right:
-                    TryAppendIndexRight( expToken );
-                    break;
-                case TokenFlag.Member:
-                    TryAppendMember( expToken );
-                    break;
-                default:
-                    break;
-            }
-        }
-
-        public ExpNode GetNextOperandCache()
-        {
-            if( _cache.PopOperand( out Token t, out ExpNode? n ) )
-            {
-                return n;
-            } else
-            {
-                // process some rare case here
-            }
-
-            throw new NotImplementedException();
-        }
-
-        public enum ExpCompileStateCode
-        {
-
-            Common,
-            ForLoop,
-            RepeatLoop,
-            UntilLoop,
-            IfBranch,
-            CaseBranch,
-            CollectionIndex,
-
-        }
-
-    }
-}

StgSharp.Model/Step/Reader/StepDataReader.cs

@@ -1,90 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepDataReader.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.IO.MemoryMappedFiles;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace StgSharp.Modeling.STEP
-{
-    public partial class StepReader
-    {
-
-        private Regex expressionSpilitter = GetExpressionSplitter();
-
-        private ThreadLocal<ConcurrentQueue<StepCodeLine>> _codeLineQueue 
-            = new ThreadLocal<ConcurrentQueue<StepCodeLine>>();
-
-        public ConcurrentQueue<StepCodeLine> DataSectionPool
-        {
-            get => _codeLineQueue.Value;
-        }
-
-        public void ReadDataSection()
-        {
-            if( _codeLineQueue.Value == null ) {
-                _codeLineQueue.Value = new ConcurrentQueue<StepCodeLine>();
-            }
-            using( MemoryMappedViewStream ms = _memoryFile.CreateViewStream(
-                0, _size, MemoryMappedFileAccess.Read ) )
-            {
-                using( StreamReader sr = new StreamReader( ms ) )
-                {
-                    long pos = _headStart;
-                    string line;
-                    while( string.IsNullOrEmpty( line = sr.ReadLine()! ) )
-                    {
-                        Match match = expressionSpilitter.Match( line );
-                        if( match.Success )
-                        {
-                            int id = int.Parse( match.Groups[ "id" ].Value );
-                            string expression = match.Groups[ "expression" ].Value;
-                            StepCodeLine stepExpression = new StepCodeLine( id, expression );
-                            _codeLineQueue.Value.Enqueue( stepExpression );
-                        }
-                    }
-                }
-            }
-        }
-
-        [GeneratedRegex(
-                @"^#(?<id>[0-9]+)\s*?=\s*?(?<expression>\S.*?)\s*;$",
-                RegexOptions.Compiled | RegexOptions.Singleline )]
-        private static partial Regex GetExpressionSplitter();
-
-    }
-}

StgSharp.Model/Step/Reader/StepDataSectionTokenReader.cs

@@ -1,143 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepDataSectionTokenReader.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Modeling.Step;
-using StgSharp.Script;
-using StgSharp.Script.Express;
-
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StgSharp.Modeling.Step
-{
-    public class StepDataSectionTokenReader : IScriptTokenReader
-    {
-
-        private ExpSourceReader _reader;
-        private Queue<Token> _cache = new Queue<Token>();
-        private StepDataSectionTransmitter _transmitter;
-
-        public StepDataSectionTokenReader( StepDataSectionTransmitter transmitter )
-        {
-            _reader = new ExpSourceReader( transmitter );
-            _transmitter = transmitter;
-        }
-
-        public Token ReadToken()
-        {
-            if( _cache.Count == 0 )
-            {
-                if( _reader.TryReadToken( out Token token0 ) && ( token0.Value != "." ) ) {
-                    return token0;
-                }
-                if( _reader.TryReadToken( out Token token1 ) && ( token1.Value != "T" || token1.Value !=
-                                                                  "F" ) )
-                {
-                    _cache.Enqueue( token1 );
-                    return token0;
-                }
-                if( _reader.TryReadToken( out Token token2 ) && ( token2.Value != "." ) )
-                {
-                    _cache.Enqueue( token1 );
-                    _cache.Enqueue( token2 );
-                    return token0;
-                }
-                switch( token1.Value )
-                {
-                    case "T":
-                        return new Token( ".T.", token0.Line, token1.Column, TokenFlag.Member );
-                    case "F":
-                        return new Token( ".F.", token0.Line, token1.Column, TokenFlag.Member );
-                    default:
-                        break;
-                }
-            }
-            return _cache.Dequeue();
-        }
-
-        public bool TryReadToken( out Token t )
-        {
-            if( _cache.Count == 0 )
-            {
-                if( _reader.TryReadToken( out Token token0 ) )
-                {
-                    if( token0.Value != "." )
-                    {
-                        t = token0;
-                        return true;
-                    }
-                } else
-                {
-                    t = Token.Empty;
-                    return false;
-                }
-                if( _reader.TryReadToken( out Token token1 ) )
-                {
-                    if( token1.Value != "T" || token1.Value != "F" )
-                    {
-                        _cache.Enqueue( token1 );
-                        t = token0;
-                        return true;
-                    }
-                } else
-                {
-                    t = Token.Empty;
-                    return false;
-                }
-                if( _reader.TryReadToken( out Token token2 ) )
-                {
-                    if( token2.Value != "." )
-                    {
-                        _cache.Enqueue( token1 );
-                        _cache.Enqueue( token2 );
-                        t = token0;
-                        return true;
-                    }
-                } else
-                {
-                    t = Token.Empty;
-                    return false;
-                }
-                t = token1.Value switch
-                {
-                    "T" => new Token( ".T.", token0.Line, token1.Column, TokenFlag.Member ),
-                    "F" => new Token( ".F.", token0.Line, token1.Column, TokenFlag.Member ),
-                    _ => Token.Empty
-                };
-            }
-            return _reader.TryReadToken( out t );
-        }
-
-    }
-}

StgSharp.Model/Step/Reader/StepDataSectionsTranmitter.cs

@@ -1,95 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepDataSectionsTranmitter.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Script;
-
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StgSharp.Modeling.Step
-{
-    public class StepDataSectionTransmitter : IScriptSourceProvider
-    {
-
-        private bool _isEmpty;
-        private ConcurrentQueue<string> _cache = new ConcurrentQueue<string>();
-        private int _line = 0;
-
-        public bool IsEmpty => _isEmpty;
-
-        public int Location => _line;
-
-        public void EndWriting()
-        {
-            _cache.Enqueue( "END_DATA" );
-        }
-
-        public string ReadLine()
-        {
-            _cache.TryDequeue( out string? line );
-            while( !IsEmpty )
-            {
-                if( _cache.TryDequeue( out line ) )
-                {
-                    if( line == "END_DATA" )
-                    {
-                        _isEmpty = true;
-                        return string.Empty;
-                    }
-                    _line++;
-                    return line;
-                }
-            }
-            return string.Empty;
-        }
-
-        public string ReadLine( out int position )
-        {
-            string ret = ReadLine();
-            position = _line;
-            return ret;
-        }
-
-        public void WriteLine( string line )
-        {
-            _cache.Enqueue( line );
-        }
-
-        IScriptSourceProvider IScriptSourceProvider.Slice( int location, int count )
-        {
-            throw new NotSupportedException();
-        }
-
-    }
-}

StgSharp.Model/Step/Reader/StepDataTokenReader.cs

@@ -1,112 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepDataTokenReader.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Modeling.Step;
-using StgSharp.Script;
-using StgSharp.Script.Express;
-
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace StgSharp.Modeling.Step
-{
-    public class StepDataTokenReader : IScriptTokenReader
-    {
-
-        private ExpTokenReader _reader;
-
-        private HashSet<string> token1Hash = [
-            "T","F","UNSPECIFIED"
-            ];
-        private Queue<Token> _cache = new Queue<Token>();
-        private StepDataSectionTransmitter _transmitter;
-
-        public StepDataTokenReader( StepDataSectionTransmitter transmitter )
-        {
-            _reader = new ExpTokenReader( transmitter );
-            _reader.TokenReaderPreProcessor = new TokenPreReader();
-            _transmitter = transmitter;
-        }
-
-        public Token ReadToken()
-        {
-            return _reader.ReadToken();
-        }
-
-        public bool TryReadToken( out Token t )
-        {
-            return _reader.TryReadToken( out t );
-        }
-
-        private class TokenPreReader : ExpTokenReaderPreProcessor
-        {
-
-            private static Regex NextEnumPattern = GetNextEnumPattern();
-
-            public override bool Process( string codeLine, int line, ref int current, out Token t )
-            {
-                ReadOnlySpan<char> chars = codeLine.AsSpan( current );
-                char c = chars[ 0 ];
-                if( c != '.' )
-                {
-                    t = Token.Empty;
-                    return false;
-                }
-                Match match = NextEnumPattern.Match( codeLine, current );
-                if( match.Success )
-                {
-                    int begin = match.Groups[ "begin" ].Index;
-                    int end = match.Groups[ "end" ].Length;
-                    int rest = match.Groups[ "rets" ].Length;
-                    current = rest;
-                    t = new Token( match.Groups[ "begin" ].Value, line, begin, TokenFlag.Enum );
-                    return true;
-                } else
-                {
-                    t = Token.Empty;
-                    return false;
-                }
-            }
-
-            [GeneratedRegex(
-                    @"(?<begin>\.[A-Za-z_]+\.)(?<end>\s*)(?<rest>\S*)",
-                    RegexOptions.Singleline )]
-            private static extern Regex GetNextEnumPattern();
-
-        }
-
-    }
-}

StgSharp.Model/Step/Reader/StepExpressParser.cs

@@ -1,57 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepExpressParser.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Modeling.Step;
-using StgSharp.Script;
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StgSharp.Modeling.Step
-{
-    public class StepExpressSyntaxParser : ISyntaxAnalyzer
-    {
-
-        private StepExpSyntaxAnalyzer _analyzer;
-
-        public StepExpressSyntaxParser()
-        {
-            _analyzer = new StepExpSyntaxAnalyzer();
-        }
-
-        public void AppendToken( Token t )
-        {
-        }
-
-    }
-}

StgSharp.Model/Step/Reader/StepHeadReader.cs

@@ -1,112 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepHeadReader.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the ¡°Software¡±), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.IO.MemoryMappedFiles;
-using System.Runtime.Serialization;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-
-namespace StgSharp.Modeling.STEP
-{
-    public partial class StepReader
-    {
-        /**/
-
-        private static Regex expressionSplitter = new Regex(
-            @"^(?<CALLER>[A-Z_]+)\s?\((?<PARAM>.+)\)\;",
-            RegexOptions.Compiled );
-
-        public StepInfo GetInfo()
-        {
-            StepInfo info = new StepInfo();
-            List<StepObjectConstructor> constructorList = new List<StepObjectConstructor>();
-            using( MemoryMappedViewStream ms = _memoryFile.CreateViewStream(
-                0, _size, MemoryMappedFileAccess.Read ) ) {
-                using( StreamReader sr = new StreamReader( ms ) ) {
-                    long pos = _headStart;
-                    ms.Seek( _headStart, SeekOrigin.Begin );
-                    while( pos <= _headEnd ) {
-                        string token = ReadToken( sr, ref pos );
-                        if( token == "HEADER;" ) {
-                            continue;
-                        }
-
-                        if( token == "ENDSEC;" ) {
-                            break;
-                        }
-
-                        GroupCollection match = expressionSplitter.Match(
-                            token )
-                                .Groups;
-                        constructorList.Add(
-                            new StepObjectConstructor(
-                                0, match[ "CALLER" ].ToString(),
-                                match[ "PARAM" ].ToString() ) );
-                    }
-                    foreach( StepObjectConstructor constructor in constructorList ) {
-                        switch( constructor.Caller ) {
-                            case "FILE_DESCRIPTION":
-                                info.Description = StepDataParser.ToString(
-                                    constructor[ 0 ] );
-                                info.Level = StepDataParser.ToVersion(
-                                    constructor[ 1 ] );
-                                break;
-                            case "FILE_NAME":
-                                info.Name = StepDataParser.ToString(
-                                    constructor[ 0 ] );
-                                info.TimeStamp = StepDataParser.ToDateTime(
-                                    constructor[ 1 ] );
-                                info.Author = StepDataParser.ToString(
-                                    constructor[ 2 ] );
-                                info.Organization = StepDataParser.ToString(
-                                    constructor[ 3 ] );
-                                info.PreprocessorVersion = StepDataParser.ToString(
-                                    constructor[ 4 ] );
-                                info.OriginatingSystem = StepDataParser.ToString(
-                                    constructor[ 5 ] );
-                                info.Authorization = StepDataParser.ToString(
-                                    constructor[ 6 ] );
-                                break;
-                            default:
-                                break;
-                        }
-                    }
-                }
-            }
-            return info;
-        }
-        /**/
-
-    }
-}

StgSharp.Model/Step/Reader/StepReader.cs

@@ -1,158 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepReader.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp;
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.IO.MemoryMappedFiles;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-
-namespace StgSharp.Modeling.STEP
-{
-    public partial class StepReader : IDisposable
-    {
-
-        private const string fileLabel = "ISO-10303-21;";
-
-        private bool disposedValue;
-        private FileStream _fileStream;
-        private long _headStart = -1, _headEnd = -1, _dataStart = -1, _size;
-        private MemoryMappedFile _memoryFile;
-
-        private StepReader() { }
-
-        private StepReader( FileStream stream, long size )
-        {
-            _fileStream = stream;
-            _size = size;
-            _memoryFile = MemoryMappedFile.CreateFromFile(
-                stream, mapName: null, size, MemoryMappedFileAccess.Read,
-                HandleInheritability.None, leaveOpen: true );
-        }
-
-        // ~StepReader()
-        // {
-        //     Dispose(disposing: false);
-        // }
-
-        public void Dispose()
-        {
-            Dispose( disposing: true );
-            GC.SuppressFinalize( this );
-        }
-
-        public static bool FromFile( string path, out StepReader reader )
-        {
-            FileInfo info = new FileInfo( path );
-            if( !info.Exists ) {
-                reader = null!;
-                return false;
-            }
-            FileStream stream = new FileStream(
-                path, FileMode.Open, FileAccess.Read, FileShare.Read,
-                bufferSize: 4096, useAsync: true );
-            byte[] fileHead = new byte[40];
-            stream.Read( fileHead, 0, fileLabel.Length );
-            if( !Encoding.UTF8.GetString( fileHead ).Contains( fileLabel ) ) {
-                throw new InvalidDataException(
-                    "The given file is not a STEP file" );
-            }
-            reader = new StepReader( stream, info.Length );
-            reader.LocateSection();
-            return  reader != null;
-        }
-
-        private void LocateSection()
-        {
-            long startPos = 0;
-            byte[] buffer = new byte[1024];
-            Span<byte> bufferSpan = buffer, 
-                headerSec = Encoding.UTF8.GetBytes( "HEADER;" ),
-                endsecSec = Encoding.UTF8.GetBytes( "ENDSEC;" ),
-                dataSec = Encoding.UTF8.GetBytes( "DATA;" );
-            _fileStream.Position = 0;
-            for( ; startPos < _size; startPos += 1000 ) {
-                _fileStream.Read( buffer );
-                if( _headStart == -1 ) {
-                    long pos = bufferSpan.IndexOf( headerSec );
-                    if( pos >= 0 ) {
-                        _headStart = startPos + pos;
-                    }
-                }
-                if( _headEnd == -1 ) {
-                    long pos = bufferSpan.IndexOf( endsecSec );
-                    if( pos >= 0 ) {
-                        _headEnd = startPos + pos;
-                    }
-                }
-                if( _dataStart == -1 ) {
-                    long pos = bufferSpan.IndexOf( dataSec );
-                    if( pos >= 0 ) {
-                        _dataStart = startPos + pos;
-                    }
-                } else {
-                    break;
-                }
-                _fileStream.Seek( 1000, SeekOrigin.Current );
-            }
-        }
-
-        private string ReadToken( StreamReader reader, ref long posCache )
-        {
-            StringBuilder token = new StringBuilder( 100 );
-            while( token.Length == 0 || token[ token.Length - 1 ] != ';' ) {
-                string subString = reader.ReadLine();
-                if( subString == null ) {
-                    break;
-                }
-                token.Append( subString.TrimStart() );
-            }
-            posCache += token.Length;
-            return token.ToString();
-        }
-
-        private protected virtual void Dispose( bool disposing )
-        {
-            if( !disposedValue ) {
-                if( disposing ) {
-                    _fileStream.Dispose();
-                    _memoryFile.Dispose();
-                }
-
-                disposedValue = true;
-            }
-        }
-
-    }
-}

StgSharp.Model/Step/StepDataParser.cs

@@ -1,94 +1,193 @@
 //-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepDataParser.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
+// -----------------------------------------------------------------------
+// file="StepDataParser.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
 //     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the “Software”), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
 //     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
 //     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// THE SOFTWARE IS PROVIDED “AS IS”, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp.Math;
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+using StgSharp.Mathematics;
+using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Text.RegularExpressions;
+using System.Xml.Linq;
 
-namespace StgSharp.Modeling.STEP
+namespace StgSharp.Model.Step
 {
-    public static class StepDataParser
+    internal static partial class StepDataParser
     {
 
-        private static Regex _stringParser = new Regex(
-            @"(\(\s?'|')\s*(?<value>.+)\s*('\s*\)|')", RegexOptions.Compiled );
-        private static Regex _vectorParser = new Regex(
-            @"^\(\s+(?<x>-?[0-9]+\.[0-9]+),\s+(?<y>-?[0-9]+\.[0-9]+),\s+(?<z>-?[0-9]+\.[0-9]+)\s+\)$",
-            RegexOptions.Compiled );
+        private static Regex _stringParser = GetStringParser();
+        private static Regex _vectorParser = GetVectorParser();
+        private static Type _implementorInterface = typeof(IExpConvertableFrom<>);
 
-        public static DateTime ToDateTime( string source )
+        public static StepRepresentationItem Implement(
+                                             StepRepresentationItem left,
+                                             StepRepresentationItem right)
         {
-            Match match = _stringParser.Match( source );
-            if( match.Success ) {
-                return DateTime.Parse( match.Groups[ "value" ].Value );
+            Type tLeft = left.GetType(),
+                tRight = right.GetType(),
+                iLeft = _implementorInterface.MakeGenericType(tLeft),
+                iRight = _implementorInterface.MakeGenericType(tRight);
+            if (tLeft.IsAssignableTo(iRight))
+            {
+                ((dynamic)left).FromInstance((dynamic)right);
+                return left;
+            }
+            if (tRight.IsAssignableTo(iLeft))
+            {
+                ((dynamic)right).FromInstance((dynamic)left);
+                return right;
+            }
+            throw new InvalidCastException(
+                $"{tLeft.Name } and { tRight.Name } has no implementation or inheritance relationship");
+        }
+
+        public static DateTime ToDateTime(string source)
+        {
+            Match match = _stringParser.Match(source);
+            if (match.Success) {
+                return DateTime.Parse(match.Groups["value"].Value);
             }
             throw new InvalidCastException();
         }
 
-        public static string ToString( string source )
+        public static string ToString(string source)
         {
-            Match match = _stringParser.Match( source );
-            if( match.Success ) {
-                return match.Groups[ "value" ].Value;
+            Match match = _stringParser.Match(source);
+            if (match.Success) {
+                return match.Groups["value"].Value;
             }
             return string.Empty;
         }
 
-        public static Vec3 ToVector3D( string source )
+        public static Vec3 ToVector3D(ExpNodePresidentEnumerator enumerator)
         {
-            Match match = _vectorParser.Match( source );
-            if( match.Success ) {
-                return new Vec3(
-                    float.Parse( match.Groups[ "x" ].Value ),
-                    float.Parse( match.Groups[ "y" ].Value ),
-                    float.Parse( match.Groups[ "z" ].Value ) );
+            enumerator.AssertEnumeratorCount(3);
+            Vec3 result = new Vec3();
+            ExpSyntaxNode node = enumerator.Current;
+            if (node is ExpRealNumberNode x)
+            {
+                result.X = x.Value;
+                enumerator.MoveNext();
+            } else
+            {
+                throw new InvalidCastException();
             }
-            return Vec3.Zero;
+            if (node is ExpRealNumberNode y)
+            {
+                result.Y = y.Value;
+                enumerator.MoveNext();
+            } else
+            {
+                throw new InvalidCastException();
+            }
+            if (node is ExpRealNumberNode z)
+            {
+                result.Z = z.Value;
+                enumerator.MoveNext();
+            } else
+            {
+                throw new InvalidCastException();
+            }
+            return result;
         }
 
-        public static (int, int?) ToVersion( string source )
+        public static Vec3 ToVector3D(ExpSyntaxNode node)
         {
-            Match match = _stringParser.Match( source );
-            if( match.Success ) {
-                string data = match.Groups[ "value" ].Value;
-                if( data.Contains( ';' ) ) {
-                    string[] subData = data.Split( ';' );
-                    return (int.Parse( subData[ 0 ] ), int.Parse( subData[ 1 ] ));
+            Vec3 result = new Vec3();
+            if (node is ExpTupleNode)
+            {
+                ToVector3DPrivate(node.Right, ref result);
+            } else
+            {
+                ToVector3DPrivate(node, ref result);
+            }
+            return result;
+        }
+
+        public static (int, int?) ToVersion(string source)
+        {
+            Match match = _stringParser.Match(source);
+            if (match.Success)
+            {
+                string data = match.Groups["value"].Value;
+                if (data.Contains(';'))
+                {
+                    string[] subData = data.Split(';');
+                    return (int.Parse(subData[0]), int.Parse(subData[1]));
                 }
-                return (int.Parse( data ), null);
+                return (int.Parse(data), null);
             }
             return (-1,-1);
         }
 
+        [GeneratedRegex(@"(\(\s?'|')\s*(?<value>.+)\s*('\s*\)|')", RegexOptions.Singleline)]
+        private static partial Regex GetStringParser();
+
+        [GeneratedRegex(
+                @"^\(\s+(?<x>-?[0-9]+\.[0-9]+),\s+(?<y>-?[0-9]+\.[0-9]+),\s+(?<z>-?[0-9]+\.[0-9]+)\s+\)$",
+                RegexOptions.Singleline)]
+        private static partial Regex GetVectorParser();
+
+        private static void ToVector3DPrivate(ExpSyntaxNode node, ref Vec3 result)
+        {
+            ExpSyntaxNode begin = node;
+            if (node is ExpRealNumberNode x)
+            {
+                result.X = x.Value;
+                node = node.Next;
+            } else
+            {
+                throw new InvalidCastException();
+            }
+            if (node is ExpRealNumberNode y)
+            {
+                result.Y = y.Value;
+                node = node.Next;
+            } else
+            {
+                throw new InvalidCastException();
+            }
+            if (node is ExpRealNumberNode z)
+            {
+                result.Z = z.Value;
+                node = node.Next;
+            } else
+            {
+                throw new InvalidCastException();
+            }
+            if (!ReferenceEquals(node, begin)) {
+                throw new InvalidCastException();
+            }
+        }
+
     }
 }

StgSharp.Model/Step/StepEntityBase.cs

@@ -30,36 +30,104 @@
 //-----------------------------------------------------------------------
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
-using StgSharp.Math;
-using StgSharp.Modeling.Step;
+using StgSharp.Mathematics;
+using StgSharp.Model.Step;
 using StgSharp.PipeLine;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
-    public abstract class StepEntityBase : IExpMarshalType<StepUninitializedEntity>
+    public abstract class StepEntityBase : IExpConvertableFrom<StepEntityBase>
     {
 
-        protected StepEntityBase( string name )
+        public IEnumerable<int> Dependencies { get; private protected set; }
+
+        public int Id
         {
-            Name = name;
+            get => Label.Id;
+            protected set { Label = new StepEntityLabel( value ); }
         }
 
-        public int Id { get; protected set; }
+        public StepEntityLabel Label { get; protected set; }
 
         public abstract StepItemType ItemType { get; }
 
+        public StepModel Context { get; init; }
+
         public string Name { get; protected set; }
 
-        public static StepUninitializedEntity Create( string name, ExpSyntaxNode node )
+        protected string ExpEntityTypeName { get; set; }
+
+        public void FromInstance( StepEntityBase entity )
         {
-            return new StepUninitializedEntity( name, 0 );
+            this.Id = entity.Id;
+            this.Label = entity.Label;
+            this.ExpEntityTypeName = entity.ExpEntityTypeName;
+            this.Name = entity.Name;
+        }
+
+        public unsafe string[] GetEntityDescription( int depth )
+        {
+            List<string> ret = new();
+            string thisDescription = $"Entity Id: {Id}, type: {ExpEntityTypeName}";
+            if( depth <= 0 ) {
+                return [thisDescription];
+            }
+            switch( Dependencies.Count() )
+            {
+                case 0:
+                    return [thisDescription];
+                case 1:
+                    ret.Add( thisDescription );
+                    int only = Dependencies.First();
+                    string[] dep = Context[ only ]!.GetEntityDescription( depth - 1 );
+                    ret.Add( $"  ©¸-{dep[0]}" );
+                    for( int i = 1; i < dep.Length; i++ ) {
+                        ret.Add( $"    {dep[i]}" );
+                    }
+                    return ret.ToArray();
+                default:
+                    ret.Add( thisDescription );
+                    int first = Dependencies.First();
+                    dep = Context[ first ]!.GetEntityDescription( depth - 1 );
+                    ret.Add( $"  ©À-{dep[0]}" );
+                    int index = 0;
+                    for( int i = 1; i < dep.Length; i++ ) {
+                        ret.Add( $"  | {dep[i]}" );
+                    }
+                    foreach( int item in Dependencies )
+                    {
+                        index++;
+                        if( index == 1 || index >= Dependencies.Count() )
+                        {
+                            continue;
+                        }
+                        dep = Context[ item ]!.GetEntityDescription( depth - 1 );
+                        ret.Add( $"  ©À-{dep[0]}" );
+                        for( int i = 1; i < dep.Length; i++ ) {
+                            ret.Add( $"  | {dep[i]}" );
+                        }
+                    }
+                    dep = Context[ Dependencies.Last() ].GetEntityDescription( depth - 1 );
+                    ret.Add( $"  ©¸-{dep[0]}" );
+                    for( int i = 1; i < dep.Length; i++ ) {
+                        ret.Add( $"    {dep[i]}" );
+                    }
+                    return ret.ToArray();
+            }
+        }
+
+        public bool IsConvertableTo( string entityName )
+        {
+            return false;
         }
 
     }
-}
+}

StgSharp.Model/Step/StepEntityLabel.cs

@@ -28,7 +28,6 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-
 using StgSharp.PipeLine;
 
 using System;

StgSharp.Model/Step/StepHeader.cs

@@ -1,7 +1,7 @@
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-//     file="STEPHeader.cs"
-//     Project: StgSharp
+//     file="StepHeader.cs"
+//     Project: World
 //     AuthorGroup: Nitload Space
 //     Copyright (c) Nitload Space. All rights reserved.
 //     
@@ -32,17 +32,16 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     /// <summary>
-    /// C# implementation of HEADER part in STEP file.
+    ///   C# implementation of HEADER part in STEP file.
     /// </summary>
-    public struct StepInfo
+    public record class StepInfo
     {
-
-        private STEPFileDescriptor _header;
-        private STEPFileName _name;
-        private STEPSchema _schema;
+        private STEPFileDescriptor _header = new();
+        private STEPFileName _name = new();
+        private STEPSchema _schema = new();
 
         public (int mainLevel, int? subLevel) Level
         {
@@ -127,101 +126,46 @@ namespace StgSharp.Modeling.Step
             get => _schema.Data;
             internal set => _schema.Data = value;
         }
-
     }
 
     /// <summary>
-    /// C# implementation of FILE_NAME part in header of STEP file.
+    ///   C# implementation of FILE_NAME part in header of STEP file.
     /// </summary>
-    public struct STEPFileName
+    public record class STEPFileName
     {
+        public DateTime TimeStamp { get; internal set; }
 
-        public DateTime TimeStamp
-        {
-            get;
-            internal set;
-        }
+        public string Name { get; internal set; }
 
-        public string Name
-        {
-            get;
-            internal set;
-        }
+        public string Author { get; internal set; }
 
-        public string Author
-        {
-            get;
-            internal set;
-        }
+        public string Description { get; internal set; }
 
-        public string Description
-        {
-            get;
-            internal set;
-        }
+        public string PreprocessorVersion { get; internal set; }
 
-        public string PreprocessorVersion
-        {
-            get;
-            internal set;
-        }
+        public string Version { get; internal set; }
 
-        public string Version
-        {
-            get;
-            internal set;
-        }
+        public string Organization { get; internal set; }
 
-        public string Organization
-        {
-            get;
-            internal set;
-        }
-
-        public string OriginatingSystem
-        {
-            get;
-            internal set;
-        }
-
-        public string Authorization
-        {
-            get;
-            internal set;
-        }
+        public string OriginatingSystem { get; internal set; }
 
+        public string Authorization { get; internal set; }
     }
 
-    public struct STEPSchema
+    public record class STEPSchema
     {
+        private List<string> _schema = new();
 
-        private List<string> _schema;
-
-        public string Data
-        {
-            get;
-            internal set;
-        }
-
+        public string Data { get; internal set; }
     }
 
     /// <summary>
-    /// C# implementation of FILE_NAME part in header of STEP file.
+    ///   C# implementation of FILE_NAME part in header of STEP file.
     /// </summary>
-    public struct STEPFileDescriptor
+    public record class STEPFileDescriptor
     {
+        public (int mainLevel,int? subLevel) Level { get; internal set; }
 
-        public (int mainLevel,int? subLevel) Level
-        {
-            get;
-            internal set;
-        }
-
-        public string Description
-        {
-            get;
-            internal set;
-        }
-
+        public string Description { get; internal set; }
     }
 }

StgSharp.Model/Step/StepItemType.cs

@@ -28,23 +28,28 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Modeling.Step;
+using StgSharp.Model.Step;
 using StgSharp.Script;
 
 using System;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     public enum StepItemType
     {
 
+        BoundedSurface,
+        BSplineSurface,
         Unknown,
+        Face,
+        Conic,
         AdvancedFace,
         AxisPlacement2D,
         AxisPlacement3D,
         BSplineCurveWithKnots,
         CartesianPoint,
         Circle,
+        Curve,
         CylindricalSurface,
         Direction,
         EdgeCurve,
@@ -55,6 +60,8 @@ namespace StgSharp.Modeling.Step
         Line,
         OrientedEdge,
         Plane,
+        Point,
+        PresentationItem,
         Vector,
         VertexPoint
 

StgSharp.Model/Step/StepModel.cs

@@ -29,51 +29,170 @@
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
 using StgSharp.PipeLine;
+using StgSharp.Script.Express;
+
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices.Marshalling;
 using System.Text;
+using System.Xml.Linq;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     public class StepModel
     {
 
-        private BlueprintScheduler _builder;
-        private Dictionary<int, StepUncertainEntity> _nodes 
-            = new Dictionary<int, StepUncertainEntity>();
+        private Dictionary<int, StepEntityBase> _nodes
+            = new Dictionary<int, StepEntityBase>();
+
+        private PipelineScheduler _builder;
+
+        private PipelineScheduler _initScheduler = new PipelineScheduler();
         private StepInfo _header;
 
         internal StepModel( StepInfo header )
         {
             _header = header;
-            _builder = new BlueprintScheduler();
+            _builder = new PipelineScheduler();
         }
 
-        public StepUncertainEntity this[ int id ]
+        public StepEntityBase? this[ int id ]
         {
             get
             {
-                if( _nodes.TryGetValue( id, out StepUncertainEntity? node ) ) {
+                if( id == 0 ) {
+                    return null;
+                }
+                if( _nodes.TryGetValue( id, out StepEntityBase? node ) )
+                {
+                    if( node is StepUnsupportedEntity ) {
+                        throw new StepEntityUnsupportedException();
+                    }
                     return node;
                 }
-                node = StepUncertainEntity.Create( id );
+                node = new StepUninitializedEntity( this, id );
+                _nodes.Add( id, node );
                 return node;
             }
+            private set { _nodes[ id ] = value!; }
         }
 
-        public void AddUncertainEntity( int id, StepUncertainEntity entity )
+        internal StepEntityBase? this[ ExpSyntaxNode node ]
         {
-            if( _nodes.ContainsKey( id ) ) {
-                throw new InvalidOperationException(
-                    "Attempt to add entity with same id more than once" );
+            get
+            {
+                if( node is not StepEntityInstanceNode instance ) {
+                    throw new InvalidCastException();
+                }
+                return this[ instance.Id ];
+            }
+            set
+            {
+                if( node is not StepEntityInstanceNode instance ) {
+                    throw new InvalidCastException();
+                }
+                this[ instance.Id ] = value;
             }
-            _nodes.Add( id, entity );
         }
 
-        public void OrganizeNode()
+        public void BindValue( ExpSyntaxNode node, Action<StepEntityBase> action ) { }
+
+        public StepUninitializedEntity FromInitSequence( StepEntityDefineSequence sequence )
         {
-            foreach( KeyValuePair<int, StepUncertainEntity> node in _nodes ) { }
+            int id = ( sequence.Expression.Left as StepEntityInstanceNode )!.Id;
+            PipelineNode node;
+            if( _nodes.TryGetValue( id, out StepEntityBase? e ) && e is StepUninitializedEntity u )
+            {
+                u.FromSequence( sequence );
+                node = _initScheduler.GetNode( u.Label );
+            } else
+            {
+                u = new StepUninitializedEntity( this, id );
+                u.FromSequenceUnsafe( sequence );
+                _nodes.Add( id, u );
+                node = _initScheduler.Create( u.Label, u );
+            }
+
+            PipelineNodeInPort port = node.GetInputPort( StepUninitializedEntity.InName );
+            if( sequence.Dependencies.Count() == 0 )
+            {
+                _initScheduler.LinkToInput( port );
+            } else
+            {
+                foreach( int i in sequence.Dependencies )
+                {
+                    PipelineNode dNode;
+                    StepEntityLabel label = new StepEntityLabel( i );
+                    if( _nodes.TryGetValue( i, out e ) )
+                    {
+                        dNode = _initScheduler.GetNode( label );
+                    } else
+                    {
+                        u = new StepUninitializedEntity( this, i );
+                        _nodes.Add( i, u );
+                        dNode = _initScheduler.Create( u.Label, u );
+                    }
+                    port.Connect( dNode.GetOutputPort( StepUninitializedEntity.OutName ) );
+                }
+            }
+            return u;
+        }
+
+        public void InitEntity()
+        {
+            if( _initScheduler is null ) {
+                return;
+            }
+            _initScheduler.ArrangeNodes();
+            PipeLineRunner.Run( _initScheduler );
+            _initScheduler = null!;
+        }
+
+        public void ReplaceEntity(
+                    StepUninitializedEntity uninitialized,
+                    StepEntityBase accurateEntity )
+        {
+            ArgumentNullException.ThrowIfNull( uninitialized );
+            if( uninitialized.Context != this || accurateEntity.Context != this ) {
+                throw new InvalidOperationException();
+            }
+            if( uninitialized.Id != accurateEntity.Id ) {
+                throw new InvalidOperationException();
+            }
+            _nodes[ uninitialized.Id ] = accurateEntity;
+        }
+
+        public string[] ShowStructure( int depth )
+        {
+            _initScheduler.ArrangeNodes();
+            IEnumerable<PipelineNode> nodes = PipelineMarshal.GetNodeSortedEnumeration(
+                _initScheduler );
+            int count = 0;
+            List<string> info = [
+                @$"Step model root",
+                ];
+            foreach( PipelineNode node in nodes )
+            {
+                count++;
+                StepUninitializedEntity uncertain = ( node.NodeOperation as StepUninitializedEntity )!;
+                string[] strings = uncertain.GetEntityDescription( depth - 1 );
+                if( count < nodes.Count() )
+                {
+                    info.Add( $"  ├-{strings[0]}" );
+                    for( int i = 1; i < strings.Length; i++ ) {
+                        info.Add( $"  | {strings[i]}" );
+                    }
+                } else
+                {
+                    info.Add( $"  └-{strings[0]}" );
+                    for( int i = 1; i < strings.Length; i++ ) {
+                        info.Add( $"    {strings[i]}" );
+                    }
+                }
+            }
+            return info.ToArray();
         }
 
     }

StgSharp.Model/Step/StepObjectConstructor.cs

@@ -1,101 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepObjectConstructor.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-
-namespace StgSharp.Modeling.Step
-{
-    public class StepObjectConstructor
-    {
-
-        private static Regex regex = new Regex(
-            @"(?<param1>.+?(\)|'\s?\)|'))\s?(?<sepcomma>,)\s?(?<other>(.|\(|\(\s?').+)",
-            RegexOptions.Compiled );
-
-        private readonly int _id;
-        private readonly List<string> _paramList;
-        private string _caller;
-
-        public StepObjectConstructor( int id, string caller, string parameters )
-        {
-            _caller = caller;
-            _paramList = new List<string>();
-            SplitParameter( parameters );
-        }
-
-        public string this[ int paramIndex ]
-        {
-            get => _paramList[ paramIndex ];
-        }
-
-        public ReadOnlyCollection<string> ParamList
-        {
-            get => _paramList.AsReadOnly();
-        }
-
-        public static string TempCallerName
-        {
-            get => "TEMPCALLER";
-        }
-
-        public string Caller
-        {
-            get => _caller;
-            internal set => _caller = value;
-        }
-
-        public static StepObjectConstructor CreateTempExpression( int id )
-        {
-            return new StepObjectConstructor( id, "TEMPCALLER", string.Empty );
-        }
-
-        private void SplitParameter( string parameters )
-        {
-            if( string.IsNullOrEmpty( parameters ) || string.IsNullOrWhiteSpace( parameters ) ) {
-                return;
-            }
-            Match match = regex.Match( parameters );
-            while( match.Success )
-            {
-                _paramList.Add( match.Groups[ "param1" ].Value );
-                parameters = match.Groups[ "other" ].Value;
-                match = regex.Match( parameters );
-            }
-            _paramList.Add( parameters );
-        }
-
-    }
-}

StgSharp.Model/Step/StepReader.DataSectionReader.cs

@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-//     file="StepDataReader.cs"
+//     file="StepReader.DataSectionReader.cs"
 //     Project: StgSharp
 //     AuthorGroup: Nitload Space
 //     Copyright (c) Nitload Space. All rights reserved.
@@ -28,8 +28,8 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Modeling.Step;
-using StgSharp.Modeling.Step;
+using StgSharp.Model.Step;
+using StgSharp.Model.Step;
 using StgSharp.Script;
 
 using System;
@@ -43,7 +43,7 @@ using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     public partial class StepReader
     {
@@ -51,15 +51,16 @@ namespace StgSharp.Modeling.Step
         public StepDataSectionTransmitter DataTransmitter { get; } = new StepDataSectionTransmitter(
             );
 
-        public async void ReadDataSection()
+        internal async void ReadDataSection()
         {
             using( MemoryMappedViewStream ms = _memoryFile.CreateViewStream(
                 0, _size, MemoryMappedFileAccess.Read ) )
             {
                 StreamReader sr = new StreamReader( ms );
-                long pos = _headStart;
+                ms.Position = _dataStart;
+                DataTransmitter.Begin = _dataBeginLine;
                 string line;
-                while( string.IsNullOrEmpty( line = sr.ReadLine()! ) ) {
+                while( !string.IsNullOrEmpty( line = sr.ReadLine()! ) ) {
                     DataTransmitter.WriteLine( line );
                 }
                 sr.Dispose();

StgSharp.Model/Step/StepReader.HeadReader.cs

@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-//     file="StepHeadReader.cs"
+//     file="StepReader.HeadReader.cs"
 //     Project: StgSharp
 //     AuthorGroup: Nitload Space
 //     Copyright (c) Nitload Space. All rights reserved.
@@ -37,13 +37,12 @@ using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     public partial class StepReader
     {
 
-        private static Regex expressionSplitter = new Regex(
-            @"^(?<CALLER>[A-Z_]+)\s?\((?<PARAM>.+)\)\;", RegexOptions.Compiled );
+        private static Regex expressionSplitter = GetStepHeadExpressionParser();
         /**/
         private StepInfo _info;
 
@@ -53,7 +52,7 @@ namespace StgSharp.Modeling.Step
                 return _info;
             }
             StepInfo info = new StepInfo();
-            List<StepObjectConstructor> constructorList = new List<StepObjectConstructor>();
+            List<StepHeaderLineConstructor> constructorList = new List<StepHeaderLineConstructor>();
             using( MemoryMappedViewStream ms = _memoryFile.CreateViewStream(
                 0, _size, MemoryMappedFileAccess.Read ) )
             {
@@ -76,10 +75,10 @@ namespace StgSharp.Modeling.Step
 
                         GroupCollection match = expressionSplitter.Match( token ).Groups;
                         constructorList.Add(
-                            new StepObjectConstructor(
+                            new StepHeaderLineConstructor(
                                 0, match[ "CALLER" ].ToString(), match[ "PARAM" ].ToString() ) );
                     }
-                    foreach( StepObjectConstructor constructor in constructorList )
+                    foreach( StepHeaderLineConstructor constructor in constructorList )
                     {
                         switch( constructor.Caller )
                         {
@@ -105,6 +104,9 @@ namespace StgSharp.Modeling.Step
             }
             return info;
         }
+
+        [GeneratedRegex( @"^(?<CALLER>[A-Z_]+)\s?\((?<PARAM>.+)\)\;", RegexOptions.Compiled )]
+        private static partial Regex GetStepHeadExpressionParser();
         /**/
 
     }

StgSharp.Model/Step/StepReader.ToModel.cs

@@ -39,7 +39,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     public partial class StepReader
     {
@@ -66,20 +66,19 @@ namespace StgSharp.Modeling.Step
             GetInfo();
             tokenReader = new StepDataTokenReader( DataTransmitter );
             analyzer = new StepExpSyntaxAnalyzer();
+            ConcurrentQueue<StepEntityDefineSequence> initStatements = analyzer.StepEntityInitStatements;
             Task secTask = Task.Run( ReadDataSection );
             Task anTask = Task.Run( ReadStepToken );
-            ConcurrentQueue<ExpSyntaxNode> initStatements = analyzer.StepEntityInitStatements;
             Model = new StepModel( _info );
-            while( initStatements.TryDequeue( out ExpSyntaxNode? statement ) || !anTask.IsCompleted )
+            while( initStatements.TryDequeue( out StepEntityDefineSequence? statement ) ||
+                   !anTask.IsCompleted )
             {
                 if( statement is null )
                 {
                     Thread.Sleep( 0 );
                     continue;
                 }
-                StepUninitializedEntity entity = StepUninitializedEntity.FromSyntax(
-                    Model, statement );
-                Model.AddUncertainEntity( entity.Id, entity );
+                StepUninitializedEntity entity = Model.FromInitSequence( statement );
             }
             Task.WaitAll( secTask, anTask );
             return Model;
@@ -93,6 +92,35 @@ namespace StgSharp.Modeling.Step
             return await ReadToModelTask;
         }
 
+        public StepModel ReadToModelSingleThread()
+        {
+            if( Model is not null ) {
+                return Model;
+            }
+            if( _version != 0 ) {
+                throw new InvalidOperationException(
+                    "A ReadToModel method has been called and is running now, use Async version instead" );
+            }
+            Interlocked.Increment( ref _version );
+            GetInfo();
+            tokenReader = new StepDataTokenReader( DataTransmitter );
+            analyzer = new StepExpSyntaxAnalyzer();
+            ConcurrentQueue<StepEntityDefineSequence> initStatements = analyzer.StepEntityInitStatements;
+            ReadDataSection();
+            ReadStepToken();
+            Model = new StepModel( _info );
+            while( initStatements.TryDequeue( out StepEntityDefineSequence? statement ) )
+            {
+                if( statement is null )
+                {
+                    Thread.Sleep( 0 );
+                    continue;
+                }
+                StepUninitializedEntity entity = Model.FromInitSequence( statement );
+            }
+            return Model;
+        }
+
         private void ReadStepToken()
         {
             while( !tokenReader.IsEmpty )

StgSharp.Model/Step/StepReader.cs

@@ -43,7 +43,7 @@ using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     public partial class StepReader : IDisposable
     {
@@ -52,6 +52,7 @@ namespace StgSharp.Modeling.Step
 
         private bool disposedValue;
         private FileStream _fileStream;
+        private int _dataBeginLine;
         private long _headStart = -1, _headEnd = -1, _dataStart = -1, _size;
         private MemoryMappedFile _memoryFile;
 

StgSharp.Model/Step/StepUncertainElement.cs

@@ -1,197 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="StepUncertainElement.cs"
-//     Project: StgSharp
-//     AuthorGroup: Nitload Space
-//     Copyright (c) Nitload Space. All rights reserved.
-//     
-//     Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
-//     files (the ¡°Software¡±), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
-//     
-//     The above copyright notice and 
-//     this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
-//     
-//     THE SOFTWARE IS PROVIDED ¡°AS IS¡±, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//     
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-using StgSharp;
-using StgSharp.PipeLine;
-using StgSharp.Script;
-
-using StgSharp.Script.Express;
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-
-namespace StgSharp.Modeling.Step
-{
-    public class StepUninitializedEntity : StepEntityBase, IConvertableToPipelineNode
-    {
-
-        private ExpSyntaxNode data;
-        private int _id;
-        private StepModel _model;
-        private string _name;
-
-        public StepUninitializedEntity( string name, int id )
-            : base( name )
-        {
-            _name = name;
-            _id = id;
-        }
-
-        public int Id
-        {
-            get => _id;
-        }
-
-        public override StepItemType ItemType => StepItemType.Unknown;
-
-        public string Name
-        {
-            get => _name;
-        }
-
-        internal static HashSet<string> UnsupportedItemTypes { get; } = new HashSet<string>();
-
-        public static StepUninitializedEntity Create( int id )
-        {
-            return new StepUninitializedEntity( string.Empty, id );
-        }
-
-        public static StepUninitializedEntity Create( string name, ExpSyntaxNode node )
-        {
-            return new StepUninitializedEntity( name, 0 );
-        }
-
-        public void Init( StepModel model, ExpSyntaxNode param )
-        {
-            if( param is ExpFunctionCallingNode caller )
-            {
-                string entityName = caller.FunctionCaller.Name;
-                ExpSyntaxNode p = caller.Right;
-                ExpNodeNextEnumerator e = p.ToEnumerator();
-            } else
-            {
-                throw new ExpInvalidSyntaxException(
-                    "Assigned syntax node is not a function caller." );
-            }
-        }
-
-        public void InitGeometry()
-        {
-            throw new NotImplementedException();
-        }
-
-        internal static StepEntityBase FromTypedParameter(
-                                       StepModel binder,
-                                       ExpSyntaxNode itemSyntax )
-        {
-            StepEntityBase item = null!;
-            if( itemSyntax is ExpElementInitializingNode initNode )
-            {
-                string name = initNode.EqualityTypeConvert.Name;
-                switch( name )
-                {
-                    case StepItemTypeExtensions.AdvancedFaceText:
-                        item = StepAdvancedFace.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.Axis2Placement2DText:
-                        item = StepAxis2Placement2D.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.Axis2Placement3DText:
-                        item = StepAxis2Placement3D.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.BSplineCurveWithKnotsText:
-                        item = StepBSplineCurveWithKnots.CreateFromSyntaxList(
-                            binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.CartesianPointText:
-                        item = StepCartesianPoint.CreateFromSyntaxList( initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.CircleText:
-                        item = StepCircle.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.CylindricalSurfaceText:
-                        item = StepCylindricalSurface.CreateFromSyntaxList( binder,
-                                                                            initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.DirectionText:
-                        item = StepDirection.CreateFromSyntaxList( initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.EdgeCurveText:
-                        item = StepEdgeCurve.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.EdgeLoopText:
-                        item = StepEdgeLoop.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.EllipseText:
-                        item = StepEllipse.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.FaceBoundText:
-                        item = StepFaceBound.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.FaceOuterBoundText:
-                        item = StepFaceOuterBound.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.LineText:
-                        item = StepLine.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.OrientedEdgeText:
-                        item = StepOrientedEdge.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.PlaneText:
-                        item = StepPlane.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.VectorText:
-                        item = StepVector.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    case StepItemTypeExtensions.VertexPointText:
-                        item = StepVertexPoint.CreateFromSyntaxList( binder, initNode.Right );
-                        break;
-                    default:
-                        if( UnsupportedItemTypes.Add( name ) ) {
-                            Debug.WriteLine(
-                                $"Unsupported item {name} at {initNode.Line}, {initNode.Column}" );
-                        }
-                        break;
-                }
-            } else
-            {
-                // TODO:
-            }
-
-            return item;
-        }
-
-        void IConvertableToPipelineNode.NodeMain(
-                                        in Dictionary<string, PipelineNodeImport> input,
-                                        in Dictionary<string, PipelineNodeExport> output )
-        {
-            InitGeometry();
-            PipelineNodeExport.SkipAll( output );
-        }
-
-        IEnumerable<string> IConvertableToPipelineNode.InputInterfacesName => ["in"];
-
-        PipelineNodeOperation IConvertableToPipelineNode.Operation => ( this as IConvertableToPipelineNode ).NodeMain;
-
-        IEnumerable<string> IConvertableToPipelineNode.OutputInterfacesName => ["out"];
-
-    }
-}

StgSharp.Model/Step/SyntaxNode/StepComplexEntityNode.cs

@@ -43,7 +43,7 @@ namespace StgSharp.Model.Step
 
         private ExpSyntaxNode _begin;
 
-        public StepComplexEntityNode( ExpSyntaxNode node )
+        private StepComplexEntityNode( ExpSyntaxNode node )
             : base( node.Source )
         {
             _begin = node;
@@ -53,9 +53,9 @@ namespace StgSharp.Model.Step
 
         public override ExpSyntaxNode Right => _begin;
 
-        public override IExpElementSource EqualityTypeConvert => throw new NotImplementedException();
+        public override IExpElementSource EqualityTypeConvert => StepEntityType.Source;
 
-        public StepComplexEntityNode FromTuple( ExpSyntaxNode node )
+        public static StepComplexEntityNode FromTuple( ExpSyntaxNode node )
         {
             if( node is not ExpTupleNode tuple ) {
                 throw new ExpInvalidSyntaxException( "Node to convert is not a complex" );

StgSharp.Model/Step/SyntaxNode/StepEntityInitCaller.cs

@@ -30,7 +30,6 @@
 //-----------------------------------------------------------------------
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
-using StgSharp.Modeling.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
@@ -41,7 +40,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Model.Step.SyntaxNode
+namespace StgSharp.Model.Step
 {
     public class StepEntityInitCaller : ExpFunctionSource
     {

StgSharp.Model/Step/SyntaxNode/StepEntityInstanceNode.cs

@@ -28,37 +28,78 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Modeling.Step;
+using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.Http.Headers;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     public class StepEntityInstanceNode : ExpSyntaxNode
     {
 
-        private int id;
-        private StepModel _model;
-
-        public StepEntityInstanceNode( Token source, StepModel model ) : base( source ) { }
+        private StepEntityInstanceNode( Token source ) : base( source ) { }
 
         public override ExpSyntaxNode Left => Empty;
 
         public override ExpSyntaxNode Right => Empty;
 
-        public override IExpElementSource EqualityTypeConvert => throw new NotImplementedException();
+        public override IExpElementSource EqualityTypeConvert => StepEntityType.Source;
 
-        private void GetInstance()
+        public int Id { get; init; }
+
+        public static StepEntityInstanceNode Register( Token t )
         {
-            _model 
+            if( t.Value[ 0 ] != '#' ) {
+                throw new ExpInvalidSyntaxException( "Entity label in STEP should be # + number" );
+            }
+            StepEntityInstanceNode node = new StepEntityInstanceNode( t )
+            {
+                Id = int.Parse( t.Value.AsSpan( 1 ) ),
+            };
+            return node;
+        }
 
+        public static StepEntityInstanceNode RegisterNull( Token t )
+        {
+            if( t.Value != "$" ) {
+                throw new ExpInvalidSyntaxException(
+                    $"Token {t.Value} does not represent a null entity" );
+            }
+            StepEntityInstanceNode node = new StepEntityInstanceNode( t )
+            {
+                Id = 0,
+            };
+            return node;
+        }
+
+        public static StepEntityInstanceNode RegisterRuntimeInference( Token t )
+        {
+            if( t.Value != "*" ) {
+                throw new ExpInvalidSyntaxException(
+                    $"Token {t.Value} does not represent a runtime inferences entity" );
+            }
+            StepEntityInstanceNode node = new StepEntityInstanceNode( t )
+            {
+                Id = -1,
+            };
+            return node;
         }
 
     }
+
+    internal class StepEntityType : ExpTypeSource
+    {
+
+        private StepEntityType( string typeName ) : base( typeName ) { }
+
+        public static StepEntityType Source { get; } = new StepEntityType( "ENTITY" );
+
+    }
 }

StgSharp.Model/Step/SyntaxNode/StepExpEnumValueNode.cs

@@ -37,7 +37,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Modeling.Step
+namespace StgSharp.Model.Step
 {
     internal class StepExpEnumValueNode : ExpSyntaxNode
     {