old data

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

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

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

@@ -28,6 +28,7 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
+using StgSharp.Model.Step.SyntaxNode;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
@@ -39,7 +40,7 @@ using System.Threading.Tasks;
 
 using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Step
 {
     internal partial class StepExpSyntaxAnalyzer
     {
@@ -91,7 +92,7 @@ namespace StgSharp.Model.Step
                     _cache.PopOperand( out _, out ExpSyntaxNode? p );
                     StepEntityInitCaller caller = StepEntityInitCaller.CreateCaller( op.Value );
                     node = ExpFunctionCallingNode.CallFunction( op, caller, p );
-                    _cache.StatementsInDepth.Push( node );
+                    _cache.PushOperand( node );
                     return node;
                 default:
                     throw new NotImplementedException();
@@ -100,27 +101,43 @@ namespace StgSharp.Model.Step
 
         private bool TryGenerateBinaryNode( Token t, out ExpSyntaxNode node )
         {
-            /*
             ExpSyntaxNode right = GetNextOperandCache();
             ExpSyntaxNode left = GetNextOperandCache();
-            /**/
             switch( t.Value )
             {
-                case "=":
-                    ExpSyntaxNode right = GetNextOperandCache();
-                    ExpSyntaxNode left;
-                    if( right is ExpTupleNode tuple )
-                    {
-                        right = StepComplexEntityNode.FromTuple( tuple );
-                        left = GetNextOperandCache();
-                    } else
-                    {
-                        left = right;
-                        right = _cache.StatementsInDepth.Pop();
-                    }
-
+                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 = 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.Model.Step
+namespace StgSharp.Modeling.Step
 {
     internal partial class StepExpSyntaxAnalyzer
     {
@@ -57,19 +57,15 @@ namespace StgSharp.Model.Step
                     _cache.StatementsInDepth.Push( statement );
                 } else
                 {
-                    _cache.StatementsInDepth.Push( ExpSyntaxNode.Empty );
+                    ExpInvalidSyntaxException.ThrowNoOperator( rightSeparator );
                 }
             } else
             {
-                while( _cache.TryPopOperator( out op ) )
-                {
-                    ExpSyntaxNode node = ConvertAndPushOneOperator( op );
-                }
-                if( _cache.OperandAheadOfDepth == 1 )
-                {
-                    _cache.PopOperand( out _, out root );
-                    _cache.StatementsInDepth.Push( root );
+                while( _cache.TryPopOperator( out op ) ) {
+                    ConvertAndPushOneOperator( op );
                 }
+                _cache.PopOperand( out _, out root );
+                _cache.StatementsInDepth.Push( root );
             }
 
             root = _cache.PackAllStatements();
@@ -77,7 +73,6 @@ namespace StgSharp.Model.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.Model.Step
+namespace StgSharp.Modeling.Step
 {
     internal partial class StepExpSyntaxAnalyzer : ISyntaxAnalyzer
     {
@@ -62,10 +62,24 @@ namespace StgSharp.Model.Step
         public StepExpSyntaxAnalyzer()
         {
             _cache = new CompileStack<ExpSyntaxNode, IExpElementSource>();
-            _context = new ExpressStepUtil();
         }
 
-        public ConcurrentQueue<StepEntityDefineSequence> StepEntityInitStatements { get; } = new();
+        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>(
+            );
 
         /// <summary>
         ///   Append a token to top of cache. This method will automatically convert token to node
@@ -100,9 +114,6 @@ namespace StgSharp.Model.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.Model.Step
+namespace StgSharp.Modeling.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 StepDataSectionTransmitter() { }
-
-        public StepDataSectionTransmitter( int begins )
-        {
-            Begin = begins;
-            _line = Begin;
-        }
-
-        public bool IsEmpty => _cache.IsEmpty && !IsWriting;
+        public bool IsEmpty => _isEmpty;
 
         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()
         {
-            if( _cache.TryDequeue( out string? line ) )
+            _cache.TryDequeue( out string? line );
+            while( !IsEmpty )
             {
-                _line++;
-                return line;
+                if( _cache.TryDequeue( out line ) )
+                {
+                    if( line == EndDataText )
+                    {
+                        _isEmpty = true;
+                        return string.Empty;
+                    }
+                    _line++;
+                    return line;
+                }
             }
             return string.Empty;
         }
@@ -89,17 +89,10 @@ namespace StgSharp.Model.Step
 
         public void WriteLine( string line )
         {
-            if( line == "DATA;" ) {
-                return;
-            }
-            if( line == EndDataText )
-            {
+            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.Model.Step;
+using StgSharp.Modeling.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.Model.Step
+namespace StgSharp.Modeling.Step
 {
-    public partial class StepDataTokenReader : IScriptTokenReader
+    public class StepDataTokenReader : IScriptTokenReader
     {
 
         private ExpTokenReader _reader;
 
-        private HashSet<string> tokenHash = [
+        private HashSet<string> token1Hash = [
             "T","F","UNSPECIFIED"
             ];
         private Queue<Token> _cache = new Queue<Token>();
@@ -63,13 +63,7 @@ namespace StgSharp.Model.Step
 
         public bool IsEmpty
         {
-            get
-            {
-                if( _reader.IsEmpty ) {
-                    return !_transmitter.IsWriting;
-                }
-                return false;
-            }
+            get => _reader.IsEmpty && _transmitter.IsWriting;
         }
 
         public Token ReadToken()
@@ -82,93 +76,40 @@ namespace StgSharp.Model.Step
             return _reader.TryReadToken( out t );
         }
 
-        private partial class TokenPreReader : ExpTokenReaderPreProcessor
+        private class TokenPreReader : ExpTokenReaderPreProcessor
         {
 
-            private static Regex
-                _nextHashtagSymbolPattern = GetEntityTagSymbolPattern(),
-                _nextEnumPattern = GetNextEnumPattern(),
-                _stringPattern = GetStringPattern();
+            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 ];
-                Match match;
-                switch( c )
+                if( c != '.' )
                 {
-                    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;
+                }
+                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;
                 }
-                t = Token.Empty;
-                return false;
             }
 
             [GeneratedRegex(
-                    @"(?<token>#[0-9A-Za-z]+)(?<end>\s*?)(?<rest>\S|$)",
+                    @"(?<begin>\.[A-Za-z_]+\.)(?<end>\s*)(?<rest>\S*)",
                     RegexOptions.Singleline )]
-            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();
+            private static extern Regex GetNextEnumPattern();
 
         }
 

StgSharp.Model/Step/ExpressStepUntil.cs

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

StgSharp.Model/Step/FileStructure/IStepObject.cs

@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,135 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,227 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,64 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

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

StgSharp.Model/Step/Items/StepAxis2Placement.cs

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

StgSharp.Model/Step/Items/StepAxis2Placement2D.cs

@@ -28,25 +28,24 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
-
 using StgSharp.Script;
+
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepAxis2Placement2D : StepAxis2Placement, IExpConvertableFrom<StepAxis2Placement2D>
+    public class StepAxis2Placement2D : StepAxis2Placement
     {
 
-        private StepAxis2Placement2D( StepModel model ) : base( model ) { }
+        private StepAxis2Placement2D() : base( string.Empty ) { }
 
         public StepAxis2Placement2D(
-               StepModel model,
+               string label,
                StepCartesianPoint location,
                StepDirection direction )
-            : base( model )
+            : base( label )
         {
             Location = location;
             RefDirection = direction;
@@ -54,24 +53,25 @@ namespace StgSharp.Model.Step
 
         public override StepItemType ItemType => StepItemType.AxisPlacement2D;
 
-        public void FromInstance( StepAxis2Placement2D entity )
+        internal static StepAxis2Placement2D CreateFromSyntaxList(
+                                             StepBinder binder,
+                                             ExpNode syntaxList )
         {
-            base.FromInstance( entity );
-            Location = entity.Location;
-            RefDirection = entity.RefDirection;
+            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;
         }
 
-        internal static StepAxis2Placement2D FromSyntax(
-                                             StepModel binder,
-                                             ExpSyntaxNode syntaxList )
+        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
         {
-            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;
+            yield return Location;
+            yield return RefDirection;
         }
 
     }

StgSharp.Model/Step/Items/StepAxis2Placement3D.cs

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

StgSharp.Model/Step/Items/StepBSplineCurve.cs

@@ -28,7 +28,6 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
@@ -37,7 +36,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
     public enum StepBSplineCurveForm
     {
@@ -51,89 +50,81 @@ namespace StgSharp.Model.Step
 
     }
 
-    public static class StepExpEnumValue
+;
+
+    public abstract class StepBSplineCurve : StepBoundedCurve
     {
 
-        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 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 static HashSet<string> AllPossibleValue { get; } = [
-                CIRCULAR_ARC,
-                ELLIPTIC_ARC,
-                HYPERBOLIC_ARC,
-                PARABOLIC_ARC,
-                POLYLINE_FORM,
-                UNSPECIFIED,
-            ];
+        private const string POLYLINE_FORM = "POLYLINE_FORM";
+        private const string UNSPECIFIED = "UNSPECIFIED";
 
-    }
-
-    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 )
+        public StepBSplineCurve( string name, IEnumerable<StepCartesianPoint> controlPoints )
+            : base( name )
         {
             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; private set; } 
-            = new List<StepCartesianPoint>();
+        public List<StepCartesianPoint> ControlPointsList { get; } = new List<StepCartesianPoint>();
 
         public StepBSplineCurveForm CurveForm { get; set; } = StepBSplineCurveForm.Unspecified;
 
-        public void FromInstance( StepBSplineCurve entity )
+        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
         {
-            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";
+            return ControlPointsList;
         }
 
         protected static string GetCurveFormString( StepBSplineCurveForm form )
         {
-            return form switch
+            switch( form )
             {
-                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(),
-            };
+                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();
         }
 
         protected static StepBSplineCurveForm ParseCurveForm( string enumerationValue )
         {
-            return enumerationValue.ToUpperInvariant() switch
+            switch( enumerationValue.ToUpperInvariant() )
             {
-                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,
-            };
+                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;
+            }
         }
 
     }

StgSharp.Model/Step/Items/StepBSplineCurveWithKnots.cs

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

StgSharp.Model/Step/Items/StepBoundedCurve.cs

@@ -28,31 +28,15 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepBoundedCurve : StepCurve, IExpConvertableFrom<StepBoundedCurve>
+    public abstract class StepBoundedCurve : StepCurve
     {
 
-        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 );
-        }
+        protected StepBoundedCurve( string name ) : base( name ) { }
 
     }
 }

StgSharp.Model/Step/Items/StepCartesianPoint.cs

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

StgSharp.Model/Step/Items/StepCircle.cs

@@ -28,24 +28,23 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepCircle : StepConic, IExpConvertableFrom<StepCircle>
+    public class StepCircle : StepConic
     {
 
         private StepAxis2Placement _position;
 
-        public StepCircle( StepModel model ) : base( model ) { }
+        private StepCircle() : base( string.Empty ) { }
 
-        public StepCircle( StepModel model, StepAxis2Placement position, float radius )
-            : base( model )
+        public StepCircle( string label, StepAxis2Placement position, float radius )
+            : base( label )
         {
             Position = position;
             Radius = radius;
@@ -68,21 +67,21 @@ namespace StgSharp.Model.Step
 
         public override StepItemType ItemType => StepItemType.Circle;
 
-        public void FromInstance( StepCircle entity )
+        internal static StepCircle CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
         {
-            base.FromInstance( entity );
-            this._position = entity.Position;
+            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;
         }
 
-        internal static StepCircle FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
         {
-            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;
+            yield return Position;
         }
 
     }

StgSharp.Model/Step/Items/StepConic.cs

@@ -28,28 +28,15 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepConic : StepCurve, IExpConvertableFrom<StepConic>
+    public abstract class StepConic : StepCurve
     {
 
-        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 );
-        }
+        protected StepConic( string name ) : base( name ) { }
 
     }
 }

StgSharp.Model/Step/Items/StepCurve.cs

@@ -28,28 +28,15 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepCurve : StepGeometricRepresentationItem, IExpConvertableFrom<StepCurve>
+    public abstract class StepCurve : StepGeometricRepresentationItem
     {
 
-        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";
-        }
+        protected StepCurve( string name ) : base( name ) { }
 
     }
 }

StgSharp.Model/Step/Items/StepCylindricalSurface.cs

@@ -28,25 +28,21 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
-
 using StgSharp.Script;
+
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepCylindricalSurface : StepElementarySurface, IExpConvertableFrom<StepCylindricalSurface>
+    public class StepCylindricalSurface : StepElementarySurface
     {
 
-        public StepCylindricalSurface( StepModel model ) : base( model ) { }
+        private StepCylindricalSurface() : base() { }
 
-        public StepCylindricalSurface(
-               StepModel model,
-               StepAxis2Placement3D position,
-               float radius )
-            : base( model, position )
+        public StepCylindricalSurface( string name, StepAxis2Placement3D position, float radius )
+            : base( name, position )
         {
             Radius = radius;
         }
@@ -55,22 +51,17 @@ namespace StgSharp.Model.Step
 
         public override StepItemType ItemType => StepItemType.CylindricalSurface;
 
-        public void FromInstance( StepCylindricalSurface entity )
+        internal static StepRepresentationItem CreateFromSyntaxList(
+                                               StepBinder binder,
+                                               ExpNode syntaxList )
         {
-            base.FromInstance( entity );
-            Radius = entity.Radius;
-        }
-
-        internal static StepRepresentationItem FromSyntax(
-                                               StepModel binder,
-                                               ExpSyntaxNode syntaxList )
-        {
-            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
             enumerator.AssertEnumeratorCount( 3 );
-            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;
+            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;
             return surface;
         }
 

StgSharp.Model/Step/Items/StepDirection.cs

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

StgSharp.Model/Step/Items/StepEdge.cs

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

StgSharp.Model/Step/Items/StepEdgeCurve.cs

@@ -28,29 +28,28 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepEdgeCurve : StepEdge, IExpConvertableFrom<StepEdgeCurve>
+    public class StepEdgeCurve : StepEdge
     {
 
         private StepCurve _edgeGeometry;
 
-        private StepEdgeCurve( StepModel model ) : base( model ) { }
+        private StepEdgeCurve() : base() { }
 
         public StepEdgeCurve(
-               StepModel model,
+               string name,
                StepVertex edgeStart,
                StepVertex edgeEnd,
                StepCurve edgeGeometry,
                bool isSameSense )
-            : base( model, edgeStart, edgeEnd )
+            : base( name, edgeStart, edgeEnd )
         {
             EdgeGeometry = edgeGeometry;
             IsSameSense = isSameSense;
@@ -63,30 +62,39 @@ namespace StgSharp.Model.Step
             get { return _edgeGeometry; }
             set
             {
-                ArgumentNullException.ThrowIfNull( value );
+                if( value == null ) {
+                    throw new ArgumentNullException();
+                }
+
                 _edgeGeometry = value;
             }
         }
 
         public override StepItemType ItemType => StepItemType.EdgeCurve;
 
-        public void FromInstance( StepEdgeCurve entity )
+        internal static StepEdgeCurve CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
         {
-            base.FromInstance( entity );
-            EdgeGeometry = entity.EdgeGeometry;
+            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;
         }
 
-        internal static StepEdgeCurve FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
         {
-            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;
+            foreach( StepRepresentationItem item in base.GetReferencedItems() ) {
+                yield return item;
+            }
+
+            yield return EdgeGeometry;
         }
 
     }

StgSharp.Model/Step/Items/StepEdgeLoop.cs

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

StgSharp.Model/Step/Items/StepElementarySurface.cs

@@ -28,24 +28,23 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepElementarySurface : StepSurface, IExpConvertableFrom<StepElementarySurface>
+    public abstract class StepElementarySurface : StepSurface
     {
 
         private StepAxis2Placement3D _position;
 
-        public StepElementarySurface( StepModel model ) : base( model ) { }
+        protected StepElementarySurface() : base( string.Empty ) { }
 
-        public StepElementarySurface( StepModel model, StepAxis2Placement3D position )
-            : base( model )
+        public StepElementarySurface( string name, StepAxis2Placement3D position )
+            : base( name )
         {
             Position = position;
         }
@@ -55,15 +54,17 @@ namespace StgSharp.Model.Step
             get { return _position; }
             set
             {
-                ArgumentNullException.ThrowIfNull( value );
+                if( value == null ) {
+                    throw new ArgumentNullException();
+                }
+
                 _position = value;
             }
         }
 
-        public void FromInstance( StepElementarySurface entity )
+        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
         {
-            base.FromInstance( entity );
-            _position = entity.Position;
+            yield return 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.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepEllipse : StepConic, IExpConvertableFrom<StepEllipse>
+    public class StepEllipse : StepConic
     {
 
         private StepAxis2Placement _position;
 
-        private StepEllipse( StepModel model ) : base( model ) { }
+        private StepEllipse() : base( string.Empty ) { }
 
         public StepEllipse(
-               StepModel model,
                string name,
                StepAxis2Placement position,
-               float semiAxis1,
-               float semiAxis2 )
-            : base( model )
+               double semiAxis1,
+               double semiAxis2 )
+            : base( name )
         {
             Position = position;
             SemiAxis1 = semiAxis1;
             SemiAxis2 = semiAxis2;
         }
 
-        public float SemiAxis1 { get; set; }
+        public double SemiAxis1 { get; set; }
 
-        public float SemiAxis2 { get; set; }
+        public double SemiAxis2 { get; set; }
 
         public StepAxis2Placement Position
         {
             get { return _position; }
             set
             {
-                ArgumentNullException.ThrowIfNull( value );
+                if( value == null ) {
+                    throw new ArgumentNullException();
+                }
 
                 _position = value;
             }
@@ -74,23 +74,22 @@ namespace StgSharp.Model.Step
 
         public override StepItemType ItemType => StepItemType.Ellipse;
 
-        public void FromInstance( StepEllipse entity )
+        internal static StepEllipse CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
         {
-            base.FromInstance( entity );
-            SemiAxis1 = entity.SemiAxis1;
-            SemiAxis2 = entity.SemiAxis2;
+            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;
         }
 
-        internal static StepEllipse FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
         {
-            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;
+            yield return Position;
         }
 
     }

StgSharp.Model/Step/Items/StepFace.cs

@@ -28,34 +28,20 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 using System.Linq;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepFace : StepTopologicalRepresentationItem, IExpConvertableFrom<StepFace>
+    public abstract class StepFace : StepTopologicalRepresentationItem
     {
 
-        public StepFace( StepModel model ) : base( model ) { }
+        public StepFace( string name ) : base( name ) { }
 
-        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";
-        }
+        public List<StepFaceBound> Bounds { get; } = new List<StepFaceBound>();
 
     }
 }

StgSharp.Model/Step/Items/StepFaceBound.cs

@@ -28,22 +28,21 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
-
 using StgSharp.Script;
+
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepFaceBound : StepTopologicalRepresentationItem, IExpConvertableFrom<StepFaceBound>
+    public class StepFaceBound : StepTopologicalRepresentationItem
     {
 
-        public StepFaceBound( StepModel model ) : base( model ) { }
+        protected StepFaceBound() : base( string.Empty ) { }
 
-        public StepFaceBound( StepModel model, StepLoop bound, bool orientation )
-            : base( model )
+        public StepFaceBound( string name, StepLoop bound, bool orientation )
+            : base( name )
         {
             Bound = bound;
             Orientation = orientation;
@@ -55,22 +54,20 @@ namespace StgSharp.Model.Step
 
         public StepLoop Bound { get; set; }
 
-        public void FromInstance( StepFaceBound entity )
+        internal static StepFaceBound CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
         {
-            base.FromInstance( entity );
-            Bound = entity.Bound;
-            Orientation = entity.Orientation;
+            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;
         }
 
-        internal static StepFaceBound FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
         {
-            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;
+            yield return Bound;
         }
 
     }

StgSharp.Model/Step/Items/StepFaceOuterBound.cs

@@ -28,37 +28,33 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
+
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepFaceOuterBound : StepFaceBound, IExpConvertableFrom<StepFaceOuterBound>
+    public class StepFaceOuterBound : StepFaceBound
     {
 
-        private StepFaceOuterBound( StepModel model ) : base( model ) { }
+        private StepFaceOuterBound() : base() { }
 
-        public StepFaceOuterBound( StepModel model, StepLoop bound, bool orientation )
-            : base( model, bound, orientation ) { }
+        public StepFaceOuterBound( string name, StepLoop bound, bool orientation )
+            : base( name, bound, orientation ) { }
 
         public override StepItemType ItemType => StepItemType.FaceOuterBound;
 
-        public void FromInstance( StepFaceOuterBound entity )
+        internal static new StepFaceOuterBound CreateFromSyntaxList(
+                                               StepBinder binder,
+                                               ExpNode syntaxList )
         {
-            base.FromInstance( entity );
-        }
-
-        internal static new StepFaceOuterBound FromSyntax(
-                                               StepModel binder,
-                                               ExpSyntaxNode syntaxList )
-        {
-            ExpNodePresidentEnumerator enumerator = new ExpNodePresidentEnumerator( syntaxList );
+            ExpNodeNextEnumerator enumerator = new ExpNodeNextEnumerator( syntaxList );
             enumerator.AssertEnumeratorCount( 3 );
-            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;
+            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;
             return faceOuterBound;
         }
 

StgSharp.Model/Step/Items/StepFaceSurface.cs

@@ -28,31 +28,23 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
-
 using StgSharp.Script;
+
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepFaceSurface : StepFace, IExpConvertableFrom<StepFaceSurface>
+    public abstract class StepFaceSurface : StepFace
     {
 
-        public StepFaceSurface( StepModel model ) : base( model ) { }
+        public StepFaceSurface( string name ) : base( name ) { }
 
         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,27 +28,15 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepGeometricRepresentationItem : StepRepresentationItem, IExpConvertableFrom<StepGeometricRepresentationItem>
+    public abstract class StepGeometricRepresentationItem : StepRepresentationItem
     {
 
-        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";
-        }
+        protected StepGeometricRepresentationItem( string name ) : base( name ) { }
 
     }
 }

StgSharp.Model/Step/Items/StepItemType.cs

@@ -0,0 +1,131 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,53 +1,52 @@
 //-----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-// 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.Mathematics;
-using StgSharp.Model.Step;
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Math;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepLine : StepCurve, IExpConvertableFrom<StepLine>
+    public class StepLine : StepCurve
     {
 
         private StepCartesianPoint _point;
         private StepVector _vector;
 
-        private StepLine(StepModel model) : base(model) { }
+        private StepLine() : base( string.Empty ) { }
 
-        public StepLine(StepModel model, StepCartesianPoint point, StepVector vector)
-            : base(model)
+        public StepLine( string label, StepCartesianPoint point, StepVector vector )
+            : base( label )
         {
             Point = point;
             Vector = vector;
@@ -58,7 +57,10 @@ namespace StgSharp.Model.Step
             get { return _point; }
             set
             {
-                ArgumentNullException.ThrowIfNull(value);
+                if( value == null ) {
+                    throw new ArgumentNullException();
+                }
+
                 _point = value;
             }
         }
@@ -70,51 +72,53 @@ namespace StgSharp.Model.Step
             get { return _vector; }
             set
             {
-                ArgumentNullException.ThrowIfNull(value);
+                if( value == null ) {
+                    throw new ArgumentNullException();
+                }
+
                 _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(model, x1, y1, z1);
+            StepCartesianPoint start = new StepCartesianPoint( string.Empty, 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(
-                model, new StepDirection(model, dxn, dyn, dzn), length);
-            return new StepLine(model, start, vector);
+                string.Empty, new StepDirection( string.Empty, dxn, dyn, dzn ), length );
+            return new StepLine( string.Empty, start, vector );
         }
 
-        internal static StepLine FromSyntax(StepModel binder, ExpSyntaxNode syntaxList)
+        internal static StepLine CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
         {
-            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;
+            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>() );
             return line;
         }
 
+        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
+        {
+            yield return Point;
+            yield return Vector;
+        }
+
     }
 }
 

StgSharp.Model/Step/Items/StepLoop.cs

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

StgSharp.Model/Step/Items/StepOrientedEdge.cs

@@ -28,31 +28,28 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using Microsoft.Win32.SafeHandles;
-
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepOrientedEdge : StepEdge, IExpConvertableFrom<StepOrientedEdge>
+    public class StepOrientedEdge : StepEdge
     {
 
         private StepEdge _edgeElement;
 
-        private StepOrientedEdge( StepModel model ) : base( model ) { }
+        private StepOrientedEdge() { }
 
         public StepOrientedEdge(
-               StepModel model,
+               string name,
                StepVertex edgeStart,
                StepVertex edgeEnd,
                StepEdge edgeElement,
                bool orientation )
-            : base( model, edgeStart, edgeEnd )
+            : base( name, edgeStart, edgeEnd )
         {
             EdgeElement = edgeElement;
             Orientation = orientation;
@@ -75,24 +72,31 @@ namespace StgSharp.Model.Step
 
         public override StepItemType ItemType => StepItemType.OrientedEdge;
 
-        public void FromInstance( StepOrientedEdge entity )
+        internal static StepOrientedEdge CreateFromSyntaxList(
+                                         StepBinder binder,
+                                         ExpNode syntaxList )
         {
-            base.FromInstance( entity );
-            EdgeElement = entity.EdgeElement;
-            Orientation = entity.Orientation;
+            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;
         }
 
-        internal static StepOrientedEdge FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
         {
-            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;
+            foreach( StepRepresentationItem item in base.GetReferencedItems() ) {
+                yield return item;
+            }
+
+            yield return EdgeElement;
         }
 
     }

StgSharp.Model/Step/Items/StepPlacement.cs

@@ -28,47 +28,15 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-using System;
-
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepPlacement : StepGeometricRepresentationItem, IExpConvertableFrom<StepPlacement>
+    public abstract class StepPlacement : StepGeometricRepresentationItem
     {
 
-        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";
-        }
+        protected StepPlacement( string name ) : base( name ) { }
 
     }
 }

StgSharp.Model/Step/Items/StepPlane.cs

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

StgSharp.Model/Step/Items/StepPoint.cs

@@ -28,30 +28,15 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-using System;
-
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepPoint : StepGeometricRepresentationItem, IExpConvertableFrom<StepPoint>
+    public abstract class StepPoint : StepGeometricRepresentationItem
     {
 
-        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";
-        }
+        protected StepPoint( string name ) : base( name ) { }
 
     }
 }

StgSharp.Model/Step/Items/StepRepresentationItem.cs

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

StgSharp.Model/Step/Items/StepRepresentationItem_FromTypedParameter.cs

@@ -0,0 +1,127 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,26 +28,15 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepSurface : StepGeometricRepresentationItem, IExpConvertableFrom<StepSurface>
+    public abstract class StepSurface : StepGeometricRepresentationItem
     {
 
-        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";
-        }
+        public StepSurface( string name ) : base( name ) { }
 
     }
 }

StgSharp.Model/Step/Items/StepTopologicalRepresentationItem.cs

@@ -28,29 +28,15 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
-using System;
-
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepTopologicalRepresentationItem : StepRepresentationItem, IExpConvertableFrom<StepTopologicalRepresentationItem>
+    public abstract class StepTopologicalRepresentationItem : StepRepresentationItem
     {
 
-        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";
-        }
+        protected StepTopologicalRepresentationItem( string name ) : base( name ) { }
 
     }
 }

StgSharp.Model/Step/Items/StepTriple.cs

@@ -1,52 +1,51 @@
 //-----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-// 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.Mathematics;
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Math;
 
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public abstract class StepTriple : StepPoint, IExpConvertableFrom<StepTriple>
+    public abstract class StepTriple : StepPoint
     {
 
         private Vec3 _coord;
 
-        protected StepTriple(StepModel model) : this(model, 0.0f, 0.0f, 0.0f) { }
+        protected StepTriple() : this( string.Empty, 0.0f, 0.0f, 0.0f ) { }
 
-        protected StepTriple(StepModel model, float x, float y, float z)
-            : base(model)
+        protected StepTriple( string name, float x, float y, float z )
+            : base( name )
         {
             X = x;
             Y = y;
@@ -73,28 +72,19 @@ namespace StgSharp.Model.Step
 
         protected abstract int MinimumValueCount { get; }
 
-        public bool Equals(StepTriple other)
+        public bool Equals( StepTriple other )
         {
-            if (other is null) {
+            if( ( object )other == 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);
-        }
-
-        public void FromInstance(StepTriple entity)
-        {
-            base.FromInstance(entity);
-            _coord = entity._coord;
+            return ( obj is StepTriple triple ) && Equals( triple );
         }
 
         public override int GetHashCode()
@@ -102,38 +92,35 @@ namespace StgSharp.Model.Step
             return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode();
         }
 
-        public override bool IsConvertableTo(string entityName)
+        internal static StepTriple AssignTo( StepTriple triple, ExpNode values )
         {
-            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]);
+            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 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 (left is null || right is null) {
+            if( ( object )left == null || ( object )right == null ) {
                 return false;
             }
 
-            return left.Equals(right);
+            return left.Equals( right );
         }
 
     }

StgSharp.Model/Step/Items/StepVector.cs

@@ -28,24 +28,23 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepVector : StepGeometricRepresentationItem, IExpConvertableFrom<StepVector>
+    public class StepVector : StepGeometricRepresentationItem
     {
 
         private StepDirection _direction;
 
-        private StepVector( StepModel model ) : base( model ) { }
+        private StepVector() : base( string.Empty ) { }
 
-        public StepVector( StepModel model, StepDirection direction, double length )
-            : base( model )
+        public StepVector( string name, StepDirection direction, double length )
+            : base( name )
         {
             Direction = direction;
             Length = length;
@@ -58,7 +57,9 @@ namespace StgSharp.Model.Step
             get { return _direction; }
             set
             {
-                ArgumentNullException.ThrowIfNull( value );
+                if( value == null ) {
+                    throw new ArgumentNullException();
+                }
 
                 _direction = value;
             }
@@ -66,21 +67,21 @@ namespace StgSharp.Model.Step
 
         public override StepItemType ItemType => StepItemType.Vector;
 
-        public void FromInstance( StepVector entity )
+        internal static StepVector CreateFromSyntaxList( StepBinder binder, ExpNode syntaxList )
         {
-            base.FromInstance( entity );
-            _direction = entity.Direction;
+            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;
         }
 
-        internal static StepVector FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
         {
-            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;
+            yield return Direction;
         }
 
     }

StgSharp.Model/Step/Items/StepVertex.cs

@@ -1,52 +1,42 @@
 //-----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-// 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.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepVertex : StepTopologicalRepresentationItem, IExpConvertableFrom<StepVertex>
+    public abstract class StepVertex : StepTopologicalRepresentationItem
     {
 
-        public StepVertex(StepModel model) : base(model) { }
-
-        public Vec3 Vertex { get; set; }
-
-        public void FromInstance(StepVertex entity)
-        {
-            base.FromInstance(entity);
-            Vertex = entity.Vertex;
-        }
+        protected StepVertex( string name ) : base( name ) { }
 
     }
 }

StgSharp.Model/Step/Items/StepVertexPoint.cs

@@ -28,24 +28,23 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
 using System;
 using System.Collections.Generic;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Items
 {
-    public class StepVertexPoint : StepVertex, IExpConvertableFrom<StepVertexPoint>
+    public class StepVertexPoint : StepVertex
     {
 
         private StepCartesianPoint _location;
 
-        public StepVertexPoint( StepModel model ) : base( model ) { }
+        private StepVertexPoint() : base( string.Empty ) { }
 
-        public StepVertexPoint( StepModel model, StepCartesianPoint location )
-            : base( model )
+        public StepVertexPoint( string name, StepCartesianPoint location )
+            : base( name )
         {
             Location = location;
         }
@@ -55,27 +54,32 @@ namespace StgSharp.Model.Step
             get { return _location; }
             set
             {
-                ArgumentNullException.ThrowIfNull( value );
+                if( value == null ) {
+                    throw new ArgumentNullException();
+                }
+
                 _location = value;
             }
         }
 
         public override StepItemType ItemType => StepItemType.VertexPoint;
 
-        public void FromInstance( StepVertexPoint entity )
+        internal static StepVertexPoint CreateFromSyntaxList(
+                                        StepBinder binder,
+                                        ExpNode syntaxList )
         {
-            base.FromInstance( entity );
-            this.Location = entity.Location;
+            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;
         }
 
-        internal static StepVertexPoint FromSyntax( StepModel binder, ExpSyntaxNode syntaxList )
+        internal override IEnumerable<StepRepresentationItem> GetReferencedItems()
         {
-            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;
+            yield return Location;
         }
 
     }

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

@@ -0,0 +1,290 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,56 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,184 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,85 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,145 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,90 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,143 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,95 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,112 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,57 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,112 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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

@@ -0,0 +1,158 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,193 +1,94 @@
 //-----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-// 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 Microsoft.CodeAnalysis.CSharp.Syntax;
-
-using StgSharp.Mathematics;
-using StgSharp.Script.Express;
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Math;
 
 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Text.RegularExpressions;
-using System.Xml.Linq;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.STEP
 {
-    internal static partial class StepDataParser
+    public static class StepDataParser
     {
 
-        private static Regex _stringParser = GetStringParser();
-        private static Regex _vectorParser = GetVectorParser();
-        private static Type _implementorInterface = typeof(IExpConvertableFrom<>);
+        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 );
 
-        public static StepRepresentationItem Implement(
-                                             StepRepresentationItem left,
-                                             StepRepresentationItem right)
+        public static DateTime ToDateTime( string source )
         {
-            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);
+            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(ExpNodePresidentEnumerator enumerator)
+        public static Vec3 ToVector3D( string source )
         {
-            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();
+            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 ) );
             }
-            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;
+            return Vec3.Zero;
         }
 
-        public static Vec3 ToVector3D(ExpSyntaxNode node)
+        public static (int, int?) ToVersion( string source )
         {
-            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]));
+            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,104 +30,36 @@
 //-----------------------------------------------------------------------
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
-using StgSharp.Mathematics;
-using StgSharp.Model.Step;
+using StgSharp.Math;
+using StgSharp.Modeling.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.Model.Step
+namespace StgSharp.Modeling.Step
 {
-    public abstract class StepEntityBase : IExpConvertableFrom<StepEntityBase>
+    public abstract class StepEntityBase : IExpMarshalType<StepUninitializedEntity>
     {
 
-        public IEnumerable<int> Dependencies { get; private protected set; }
-
-        public int Id
+        protected StepEntityBase( string name )
         {
-            get => Label.Id;
-            protected set { Label = new StepEntityLabel( value ); }
+            Name = name;
         }
 
-        public StepEntityLabel Label { get; protected set; }
+        public int Id { get; protected set; }
 
         public abstract StepItemType ItemType { get; }
 
-        public StepModel Context { get; init; }
-
         public string Name { get; protected set; }
 
-        protected string ExpEntityTypeName { get; set; }
-
-        public void FromInstance( StepEntityBase entity )
+        public static StepUninitializedEntity Create( string name, ExpSyntaxNode node )
         {
-            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;
+            return new StepUninitializedEntity( name, 0 );
         }
 
     }
-}
+}

StgSharp.Model/Step/StepEntityLabel.cs

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

StgSharp.Model/Step/StepHeader.cs

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

StgSharp.Model/Step/StepItemType.cs

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

StgSharp.Model/Step/StepModel.cs

@@ -29,170 +29,51 @@
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
 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.Model.Step
+namespace StgSharp.Modeling.Step
 {
     public class StepModel
     {
 
-        private Dictionary<int, StepEntityBase> _nodes
-            = new Dictionary<int, StepEntityBase>();
-
-        private PipelineScheduler _builder;
-
-        private PipelineScheduler _initScheduler = new PipelineScheduler();
+        private BlueprintScheduler _builder;
+        private Dictionary<int, StepUncertainEntity> _nodes 
+            = new Dictionary<int, StepUncertainEntity>();
         private StepInfo _header;
 
         internal StepModel( StepInfo header )
         {
             _header = header;
-            _builder = new PipelineScheduler();
+            _builder = new BlueprintScheduler();
         }
 
-        public StepEntityBase? this[ int id ]
+        public StepUncertainEntity this[ int id ]
         {
             get
             {
-                if( id == 0 ) {
-                    return null;
-                }
-                if( _nodes.TryGetValue( id, out StepEntityBase? node ) )
-                {
-                    if( node is StepUnsupportedEntity ) {
-                        throw new StepEntityUnsupportedException();
-                    }
+                if( _nodes.TryGetValue( id, out StepUncertainEntity? node ) ) {
                     return node;
                 }
-                node = new StepUninitializedEntity( this, id );
-                _nodes.Add( id, node );
+                node = StepUncertainEntity.Create( id );
                 return node;
             }
-            private set { _nodes[ id ] = value!; }
         }
 
-        internal StepEntityBase? this[ ExpSyntaxNode node ]
+        public void AddUncertainEntity( int id, StepUncertainEntity entity )
         {
-            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;
+            if( _nodes.ContainsKey( id ) ) {
+                throw new InvalidOperationException(
+                    "Attempt to add entity with same id more than once" );
             }
+            _nodes.Add( id, entity );
         }
 
-        public void BindValue( ExpSyntaxNode node, Action<StepEntityBase> action ) { }
-
-        public StepUninitializedEntity FromInitSequence( StepEntityDefineSequence sequence )
+        public void OrganizeNode()
         {
-            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();
+            foreach( KeyValuePair<int, StepUncertainEntity> node in _nodes ) { }
         }
 
     }

StgSharp.Model/Step/StepObjectConstructor.cs

@@ -0,0 +1,101 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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="StepReader.DataSectionReader.cs"
+//     file="StepDataReader.cs"
 //     Project: StgSharp
 //     AuthorGroup: Nitload Space
 //     Copyright (c) Nitload Space. All rights reserved.
@@ -28,8 +28,8 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
-using StgSharp.Model.Step;
+using StgSharp.Modeling.Step;
+using StgSharp.Modeling.Step;
 using StgSharp.Script;
 
 using System;
@@ -43,7 +43,7 @@ using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Step
 {
     public partial class StepReader
     {
@@ -51,16 +51,15 @@ namespace StgSharp.Model.Step
         public StepDataSectionTransmitter DataTransmitter { get; } = new StepDataSectionTransmitter(
             );
 
-        internal async void ReadDataSection()
+        public async void ReadDataSection()
         {
             using( MemoryMappedViewStream ms = _memoryFile.CreateViewStream(
                 0, _size, MemoryMappedFileAccess.Read ) )
             {
                 StreamReader sr = new StreamReader( ms );
-                ms.Position = _dataStart;
-                DataTransmitter.Begin = _dataBeginLine;
+                long pos = _headStart;
                 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="StepReader.HeadReader.cs"
+//     file="StepHeadReader.cs"
 //     Project: StgSharp
 //     AuthorGroup: Nitload Space
 //     Copyright (c) Nitload Space. All rights reserved.
@@ -37,12 +37,13 @@ using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Modeling.Step
 {
     public partial class StepReader
     {
 
-        private static Regex expressionSplitter = GetStepHeadExpressionParser();
+        private static Regex expressionSplitter = new Regex(
+            @"^(?<CALLER>[A-Z_]+)\s?\((?<PARAM>.+)\)\;", RegexOptions.Compiled );
         /**/
         private StepInfo _info;
 
@@ -52,7 +53,7 @@ namespace StgSharp.Model.Step
                 return _info;
             }
             StepInfo info = new StepInfo();
-            List<StepHeaderLineConstructor> constructorList = new List<StepHeaderLineConstructor>();
+            List<StepObjectConstructor> constructorList = new List<StepObjectConstructor>();
             using( MemoryMappedViewStream ms = _memoryFile.CreateViewStream(
                 0, _size, MemoryMappedFileAccess.Read ) )
             {
@@ -75,10 +76,10 @@ namespace StgSharp.Model.Step
 
                         GroupCollection match = expressionSplitter.Match( token ).Groups;
                         constructorList.Add(
-                            new StepHeaderLineConstructor(
+                            new StepObjectConstructor(
                                 0, match[ "CALLER" ].ToString(), match[ "PARAM" ].ToString() ) );
                     }
-                    foreach( StepHeaderLineConstructor constructor in constructorList )
+                    foreach( StepObjectConstructor constructor in constructorList )
                     {
                         switch( constructor.Caller )
                         {
@@ -104,9 +105,6 @@ namespace StgSharp.Model.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.Model.Step
+namespace StgSharp.Modeling.Step
 {
     public partial class StepReader
     {
@@ -66,19 +66,20 @@ namespace StgSharp.Model.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 StepEntityDefineSequence? statement ) ||
-                   !anTask.IsCompleted )
+            while( initStatements.TryDequeue( out ExpSyntaxNode? statement ) || !anTask.IsCompleted )
             {
                 if( statement is null )
                 {
                     Thread.Sleep( 0 );
                     continue;
                 }
-                StepUninitializedEntity entity = Model.FromInitSequence( statement );
+                StepUninitializedEntity entity = StepUninitializedEntity.FromSyntax(
+                    Model, statement );
+                Model.AddUncertainEntity( entity.Id, entity );
             }
             Task.WaitAll( secTask, anTask );
             return Model;
@@ -92,35 +93,6 @@ namespace StgSharp.Model.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.Model.Step
+namespace StgSharp.Modeling.Step
 {
     public partial class StepReader : IDisposable
     {
@@ -52,7 +52,6 @@ namespace StgSharp.Model.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

@@ -0,0 +1,197 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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;
 
-        private StepComplexEntityNode( ExpSyntaxNode node )
+        public 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 => StepEntityType.Source;
+        public override IExpElementSource EqualityTypeConvert => throw new NotImplementedException();
 
-        public static StepComplexEntityNode FromTuple( ExpSyntaxNode node )
+        public 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,6 +30,7 @@
 //-----------------------------------------------------------------------
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
+using StgSharp.Modeling.Step;
 using StgSharp.Script;
 using StgSharp.Script.Express;
 
@@ -40,7 +41,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Model.Step
+namespace StgSharp.Model.Step.SyntaxNode
 {
     public class StepEntityInitCaller : ExpFunctionSource
     {

StgSharp.Model/Step/SyntaxNode/StepEntityInstanceNode.cs

@@ -28,78 +28,37 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Model.Step;
+using StgSharp.Modeling.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.Model.Step
+namespace StgSharp.Modeling.Step
 {
     public class StepEntityInstanceNode : ExpSyntaxNode
     {
 
-        private StepEntityInstanceNode( Token source ) : base( source ) { }
+        private int id;
+        private StepModel _model;
+
+        public StepEntityInstanceNode( Token source, StepModel model ) : base( source ) { }
 
         public override ExpSyntaxNode Left => Empty;
 
         public override ExpSyntaxNode Right => Empty;
 
-        public override IExpElementSource EqualityTypeConvert => StepEntityType.Source;
+        public override IExpElementSource EqualityTypeConvert => throw new NotImplementedException();
 
-        public int Id { get; init; }
-
-        public static StepEntityInstanceNode Register( Token t )
+        private void GetInstance()
         {
-            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;
+            _model 
+
         }
 
-        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.Model.Step
+namespace StgSharp.Modeling.Step
 {
     internal class StepExpEnumValueNode : ExpSyntaxNode
     {

StgSharp.Model/StgSharp.Model.csproj

@@ -4,7 +4,7 @@
     <TargetFramework>net8.0</TargetFramework>
     <Nullable>enable</Nullable>
       <LangVersion>preview</LangVersion>
-      <Platforms>x64;ARM64</Platforms>
+      <Platforms>AnyCPU;x64</Platforms>
       <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
   </PropertyGroup>