Dynamic display system and method for expressive control of semiconductor design form

Abstract

The invention discloses an expressive control dynamic display system and method for a semiconductor design form, and the system comprises an expression configuration module which is used for receiving a logic expression inputted by a user, and prompting available variables in the form in real time; the variable dependency analysis module is used for identifying dynamic variable reference in the logic expression; the change monitoring and scheduling module is used for monitoring a form data change event, acquiring an affected control set when variable value change is detected, and merging and optimizing expression calculation requests; the expression analysis service module is used for performing grammar check and dangerous operation filtering on the logic expression, processing an expression calculation request and returning an analysis result; and the state updating execution module is used for comparing the difference between the analysis result and the current control state according to the analysis result, and judging whether the current control needs to be updated or not according to the difference. According to the method, the problem of performance waste caused by global monitoring data change is effectively solved.

Description

TECHNICAL FIELD

[0001] The present application belongs to the field of semiconductor design, and particularly relates to a dynamic display system and method for expression control of a semiconductor design form. BACKGROUND

[0002] In the field of semiconductor design, forms are often used to configure and dynamically adjust chip design parameters (such as transistor size, material properties, or logic rules). However, existing technical solutions generally use static rule configuration methods, such as the graphical rule configuration method disclosed on page 45 of the June 2022 issue of the journal "Low-Code Platform Development Practice". Although this solution provides a visual interface to simplify rule setting, it has significant drawbacks in the context of semiconductor design. Because semiconductor parameters change frequently and involve complex logic (such as arithmetic operations, logical judgments, or string processing), existing methods cannot efficiently handle dynamic expressions (such as {voltage threshold} > 1.2V && {material type} =='silicon'), and rely on a full-data listening mechanism - whenever any data in the form changes, the system will trigger the recalculation and update of all controls globally, resulting in unnecessary computational overhead, a surge in network traffic, and response delays. This performance waste problem is particularly pronounced in large semiconductor design projects, severely affecting the dynamic response capability and user experience of the form. For example, during the process of adjusting semiconductor parameters, frequent global listening can cause interface lag and resource waste, making it impossible to meet real-time design requirements. Therefore, the main problem in existing technology is the performance waste caused by global listening to data changes. SUMMARY

[0003] The technical problem to be solved by the present application is to provide a dynamic display system and method for expression control of a semiconductor design form, which effectively solves the problem of performance waste caused by global listening to data changes.

[0004] The first aspect of the present application discloses a dynamic display system for expression control of a semiconductor design form, comprising: An expression configuration module for receiving a logical expression input by a user through an expression editor, and providing a variable prompt component to prompt available variables in the form in real time, wherein the logical expression includes arithmetic operations, logical judgments, or string processing; A variable dependency analysis module for identifying dynamic variable references in the logical expression through a regular parsing engine, and establishing a binding relationship between variables and controls to form a dependency graph; A change listening and scheduling module for listening to form data change events, querying the dependency graph to obtain a set of affected controls when a variable value change is detected, and merging and optimizing expression calculation requests through a batch processing queue; The expression parsing service module is configured to perform syntax checking and dangerous operation filtering on a logical expression submitted by a user through a secure sandbox, and to perform parallel processing on expression calculation requests through a distributed computing node in a multi-threaded manner, and return a parsing result. The state updating execution module is configured to compare the parsing result with a difference in a current control state through a difference comparison module according to the parsing result, determine whether the current control needs an updating operation according to the difference, and trigger the updating operation if the current control needs the updating operation, wherein the updating operation includes adding a smooth transition effect to a control visible state change through an animation transition controller.

[0005] The system, the expression editor in the expression configuration module is embedded in a form control attribute configuration panel, a code structured input interface is provided, and a user is allowed to write a composite logical expression; the variable prompt component analyzes all available variables in a current form in real time, and automatically prompts to complete variable references in an expression when the user inputs.

[0006] The system, the regular expression parsing engine in the variable dependency analysis module identifies dynamic variable references in an expression through a preset variable matching rule, the variable matching rule matches variable names based on a regular expression pattern; the dependency graph construction module establishes a bidirectional index relationship between form variables and associated controls, and forms a mesh binding relationship graph.

[0007] The system, the event proxy module in the change listening and scheduling module listens to form data change events, event types include input changes, selection changes or programmed assignments; the batch processing queue combines expression calculation requests of multiple associated controls.

[0008] The system, the secure sandbox in the expression parsing service module performs syntax checking on a logical expression submitted by a user, including verifying whether an expression structure is legal, and filtering dangerous operations, wherein the dangerous operations include infinite loops, system calls or file access; the distributed computing node supports expression types that can be parsed, including Boolean expressions, numerical expressions and string expressions.

[0009] The system, the logical expression includes a conditional expression, which is in the form of: if a condition is true, return true, otherwise return false; elements in the conditional expression include variables, constants and operators, the operators include arithmetic operators (+, -, *, / ), logical operators (&&, ||,!) and comparison operators (>, <, ==).

[0010] The system, the difference comparison module in the state updating execution module compares a difference between an expression calculation result and a current control state, the calculation result is a Boolean value, indicating whether a control should be displayed or hidden; the updating operation includes setting a control visibility, an enabled or disabled state.

[0011] The system, the animation transition controller adds a smooth transition effect to the control visible state change, the transition effect includes fade-in and fade-out, sliding or zooming, the transition duration is configurable, the range is 0.1 seconds to 2 seconds.

[0012] The system, the system further includes a configuration saving module for saving the user-configured logical expression and binding relationship as a configuration file in JSON format, loaded in preview mode or runtime, the configuration file includes an expression string, a variable list and a control identifier.

[0013] The system, the system is applied to a form development scene in a low-code platform, wherein the form variables include user input fields, system variables or calculation fields, and the closed-loop control process is implemented through a server interface call, the interface request includes an expression and current data, and the interface response includes a parsing result.

[0014] The second aspect of the present application discloses a dynamic display method of expression control of a semiconductor design form, comprising the following steps: Receiving a logical expression input by a user through an expression editor, and providing a variable prompt component to prompt available variables in the form in real time, wherein the logical expression includes arithmetic operations, logical judgments or string processing; Identifying dynamic variable references in the logical expression through a regular parsing engine, and establishing a binding relationship between variables and controls to form a dependency graph; Listening to form data change events, when detecting variable value changes, querying the dependency graph to obtain an affected control set, and merging and optimizing expression calculation requests through a batch processing queue; Through a security sandbox, the user-submitted logical expression is subjected to syntax checking and dangerous operation filtering, and through a distributed computing node, the expression calculation request is processed in a multithreaded manner in parallel, and the parsing result is returned; According to the parsing result, the difference comparison module compares the difference between the parsing result and the current control state, judges whether the current control needs to be updated according to the difference, if yes, triggers an update operation, and the update operation includes: adding a smooth transition effect to the control visible state change through an animation transition controller.

[0015] The third aspect of the present application discloses an electronic device, comprising a memory and a processor, the processor and the memory are connected; The memory is used for storing programs; The processor calls the program stored in the memory to execute the method provided in the second aspect of the embodiment.

[0016] The fourth aspect of the present application discloses a computer readable storage medium, which stores a computer program, and the computer program is executed by a computer to perform the method provided in the second aspect.

[0017] Compared with the prior art, the present application has the following advantages: in the semiconductor design form scenario, such as chip parameter configuration (for example, voltage threshold or material type adjustment), the present application significantly reduces unnecessary computing overhead and network transmission volume. First, the variable dependency analysis module accurately identifies dynamic variable references (such as voltage thresholds) in logical expressions through a regular parsing engine, and establishes a dependency graph of "variables- controls", ensuring that only when a specific variable (such as {voltage threshold}) changes, subsequent processing is triggered, avoiding indiscriminate response to all data under the traditional global monitoring mechanism, thereby greatly reducing computing redundancy. For example, when the semiconductor parameters are changed, the system focuses on the related controls rather than recalculating the entire form. Second, the change monitoring and scheduling module monitors form data change events, and when a variable value change is detected (such as user modification of material type), the affected control set is obtained by querying the dependency graph, and multiple expression calculation requests are combined and optimized through a batch processing queue, which reduces the number of network requests and server load, and improves response efficiency. At the same time, the expression parsing service module uses a secure sandbox for syntax checking and dangerous operation filtering, and parallel processing of requests through distributed computing nodes ensures efficient and safe parsing of complex expressions (such as logical judgment {voltage threshold} > 1.2V), preventing risks such as XSS attacks, enhancing system reliability and scalability. In addition, the state update execution module compares the parsing results with the current control state through the difference comparison module, and only triggers the update operation (such as control visibility change) when there is an actual difference, and adds a smooth effect through an animation transition controller, avoiding user discomfort caused by interface mutation, which is particularly important in frequent parameter adjustment of semiconductor design, reducing interface lag and resource waste. Overall, these features work together to achieve a closed-loop control of "data change-expression recalculation-interface update", such as performing calculation only on bound variables after monitoring field changes, significantly improving the dynamic response capability and user experience of semiconductor design forms. Finally, the system reduces unnecessary recalculation and update operations, reduces performance bottlenecks, optimizes resource consumption, and supports real-time design requirements.

[0018] The technical solutions of the present application will be further described in detail below with the aid of the accompanying drawings and examples. BRIEF DESCRIPTION OF DRAWINGS

[0019] Figure 1 The system module diagram of the present application embodiment 1.

[0020] Figure 2 The method flowchart of the present application embodiment 2. DETAILED DESCRIPTION

[0021] Embodiment 1 The following technical implementation details are based on a common scenario embodiment: in a semiconductor design form, there is an "operating voltage" field (operating_voltage) and a "high voltage warning" control (high_voltage_warning), which is displayed when the operating voltage is greater than 5.0. The expression is ${operating_voltage} > 5.0.

[0022] As shown in Figure 1 A dynamic display system of expression-based controls of a semiconductor design form includes: An expression configuration module configured to receive a logical expression input by a user through an expression editor, and provide a variable prompt component to prompt available variables in the form in real time, wherein the logical expression includes arithmetic operations, logical judgments, or string processing; A variable dependency analysis module configured to identify dynamic variable references in the logical expression through a regular analysis engine, and establish a binding relationship between variables and controls to form a dependency graph; A change listening and scheduling module configured to listen to form data change events, query an affected control set from the dependency graph when a variable value change is detected, and merge and optimize expression calculation requests through a batch processing queue; An expression analysis service module configured to perform syntax checking and dangerous operation filtering on a logical expression submitted by a user through a secure sandbox, and perform parallel processing of expression calculation requests through a distributed computing node in a multi-threaded manner, and return an analysis result; A state update execution module configured to compare the analysis result with a current control state through a difference comparison module according to the analysis result, determine whether the current control needs an update operation according to the difference, and if so, trigger an update operation, including adding a smooth transition effect to a control visibility state change through an animation transition controller.

[0023] It is to be noted that in implementation, the expression configuration module lets the user select the high voltage warning control in the design form, and finds the expression editor in the property panel. When the user starts to input the expression, the editor provides a text input area with syntax highlighting. When the user inputs the dollar sign and the curly braces, the variable hint component immediately analyzes all fields in the current form, extracts variable names such as operating_voltage, and displays them in a drop-down list. The user selects the variable by keyboard or mouse, and the system automatically completes the variable reference insertion, such as automatically completing operating_voltage. The user continues to input the comparison operator and the numerical value, and completes the expression {operating_voltage} > 5.0. This process significantly reduces manual coding errors and time through intuitive interface and real-time assistance, and improves development efficiency.

[0024] The variable dependency analysis module uses a regular parsing engine to process the user input expression. The engine predefines variable matching patterns, such as recognizing strings starting and ending with the dollar sign as variable references. It scans the expression, extracts the operating_voltage variable, and then the dependency graph construction module creates a data structure that records the association between the variable and the high voltage warning control. For example, it maintains a mapping table where the operating_voltage key corresponds to a control list including high_voltage_warning, and the control also reversely references the variable. This bidirectional indexing ensures that when the variable value changes, the system can quickly query all affected controls, avoiding global listening to the entire form data, thereby optimizing performance. The change listening and scheduling module registers to listen to data change events in the form, such as the onChange event of the input box or the assignment operation through the API. When the user modifies the value of the operating voltage field, for example, from 4.0 to 6.0, the event agent detects this change, obtains the variable name operating_voltage, and queries the dependency graph. The graph returns the associated control set, such as only high_voltage_warning.

[0025] The system adds the expression calculation request to a batch processing queue that uses deduplication and merging strategies, such as collecting all requests based on the same variable within a short time window and generating only one calculation call. This reduces the number of network requests, reduces server load, and improves response speed.

[0026] The expression parsing service module receives the request sent by the batch queue, containing the expression string and the current form data. The security sandbox first parses the expression syntax, checks the structure legality, such as ensuring that the parentheses match and the operators are used correctly, and filters dangerous operations, such as attempting to execute system commands or infinite loops. After passing, the distributed computing node allocates multiple threads to process the request in parallel, for example, a thread processes the expression {operating_voltage}>5.0, and the data {operating_voltage: 6.0} is substituted, and the calculation result is true. This parallel processing and security check ensures efficient and safe expression parsing, preventing malicious code injection.

[0027] The difference comparison module of the state update execution module receives the parsing result true and compares it with the current state of the high voltage warning control. If the control was originally in a hidden state and the difference comparison determines that an update is needed, the update operation is triggered. The animation transition controller applies a smooth effect, such as gradually increasing the control's transparency from 0 to 100 through CSS gradient, with a duration of 0.5 seconds, causing the control to fade in. If there is no change in state, the update is skipped, avoiding unnecessary rendering. This achieves fine-grained interface control, improving user experience and system performance.

[0028] The entire process forms a closed loop from data changes to interface updates, thereby improving development efficiency, optimizing performance by reducing invalid listening, enhancing security by intercepting all dangerous operations, and improving user experience through smooth transitions.

[0029] In this embodiment, the expression editor in the expression configuration module is embedded in the form control property configuration panel, providing a code structured input interface that allows users to write complex logical expressions; the variable prompt component analyzes all available variables in the current form in real time and automatically prompts to complete variable references in the expression when the user inputs.

[0030] It should be noted that the expression editor of the expression configuration module is directly integrated in the form control property configuration panel as an embedded component. It provides a code structured input interface, supports syntax highlighting and error prompts, such as displaying a red underline when the user inputs an invalid operator. The variable prompt component scans the form definition in real time, extracts all available variables such as operating_voltage and other field variables, and dynamically pops up prompts during user input. For example, when the user types ${op, the component immediately displays a list of matching variables, and after the user selects operating_voltage with the arrow key and presses enter, the system automatically inserts the complete variable reference. This allows users to quickly write complex logical expressions, such as combining multiple conditions, reducing manual memory and input errors, and improving configuration efficiency.

[0031] In this embodiment, the regular parsing engine in the variable dependency analysis module identifies dynamic variable references in expressions by using a pre-set variable matching rule based on regular expression pattern matching variable names; the dependency graph construction module establishes a bidirectional index relationship between form variables and associated controls to form a mesh binding relationship graph.

[0032] It should be noted that the regular parsing engine of the variable dependency analysis module uses a pre-set regular expression pattern, such as / ${(\w+)} / g, to identify dynamic variable references in expressions. When analyzing the expression ${operating_voltage} > 5.0, the engine matches operating_voltage as the variable name. The dependency graph construction module then establishes a bidirectional index relationship, such as creating a graph structure in which nodes represent variables and controls and edges represent dependency relationships. The variable operating_voltage points to the control high_voltage_warning, and the control records the variables it depends on. This mesh binding relationship graph ensures that the system can efficiently track the impact range of variable changes and only trigger the recalculation of related controls, avoiding the performance bottleneck caused by full data listening.

[0033] In this embodiment, the event proxy module in the change listening and scheduling module listens to form data change events, and the event types include input changes, selection changes, or programmatic assignments; the batch processing queue merges expression calculation requests for multiple associated controls.

[0034] It should be noted that the event proxy module of the change listening and scheduling module listens to specific types of data change events, including input changes (such as keyboard input), selection changes (such as drop-down selection), or programmatic assignments (through API calls). When the value of the operating voltage field changes, the event proxy captures event details, extracts variable names, and queries the dependency graph to obtain the affected control set. The batch processing queue then merges expression calculation requests for these controls, such as collecting all requests based on operating_voltage within a 50-millisecond time window, sending only one calculation request to the server containing the expression and the latest data. This optimizes network utilization, reduces latency, and improves overall performance.

[0035] In this embodiment, the security sandbox in the expression parsing service module performs syntax checking on user-submitted logical expressions, including verifying whether the expression structure is legal and filtering dangerous operations, where dangerous operations include infinite loops, system calls, or file access; the distributed computing node supports expression types that include Boolean expressions, numerical expressions, and string expressions.

[0036] Note that the security sandbox of the expression parsing service module performs syntax checking on user-submitted logical expressions, including verifying that the expression structure is legal, such as checking operator order and parentheses nesting, and filtering dangerous operations, such as infinite loops (by detecting recursive patterns), system calls (such as the eval function), or file access. The distributed computing nodes employ a multi-threaded architecture, such as using a thread pool to handle multiple expression requests in parallel. Supported types of expressions include Boolean expressions (such as returning true / false), numeric expressions (such as arithmetic operations), and string expressions (such as concatenation operations). When processing the expression ${operating_voltage} > 5.0, the sandbox ensures that there are no dangerous operations, the node quickly computes and returns the result, improving processing capacity and security.

[0037] In this embodiment, the logical expression includes a conditional expression, which returns true if the condition is true, and false otherwise; elements in the conditional expression include variables, constants, and operators, including arithmetic operators (+, -, *, / ), logical operators (&&, ||,!), and comparison operators (>, <, ==).

[0038] Note that the logical expression includes a conditional expression, which returns true if the condition is true, and false otherwise. Elements in the expression include variables (such as operating_voltage), constants (such as 5.0), and operators, which encompass arithmetic operators (such as +, -, *, / for calculation), logical operators (such as &&, ||,! for combining conditions), and comparison operators (such as >, <, == for judgment). For example, a user can write the expression {operating_voltage} * 2 > 10 && {status} == 'active', and the system parses it first to calculate the arithmetic part, and then applies the logical comparison. This enables the processing of complex business logic, enhancing the dynamic nature and flexibility of the form.

[0039] In this embodiment, the difference comparison module in the state update execution module compares the difference between the expression calculation result and the current control state, and the calculation result is a Boolean value indicating whether the control should be displayed or hidden; the update operation includes setting the control visibility, enabling or disabling the state.

[0040] It should be noted that the state update execution module's difference comparison module calculates the expression result as a boolean value, such as true indicating that the control should be displayed and false indicating that it should be hidden. The module compares this result with the current state of the control; for example, if the high voltage warning control is currently hidden and the result is true, it is determined that an update is needed, triggering an operation to set the control's visibility. If the states are the same, the update is skipped. The update operation includes changing the control's visibility, enabling or disabling state, ensuring that interface changes are only performed when there is an actual difference, reducing unnecessary DOM operations and improving rendering efficiency.

[0041] In this embodiment, the animation transition controller adds a smooth transition effect to the control's visible state change, including fade-in and fade-out, sliding, or scaling; the transition duration is configurable, ranging from 0.1 seconds to 2 seconds.

[0042] It should be noted that the animation transition controller adds a smooth transition effect to the control's visible state change. When the high voltage warning control changes from hidden to displayed, the controller applies a fade-in effect by gradually increasing the transparency from 0% to 100% over a configurable duration, such as 0.5 seconds. The transition effect also includes sliding (the control slides in from one side) or scaling (the control is enlarged from small), with a duration that can be set between 0.1 seconds and 2 seconds, for example, by user configuration selection. This makes the interface change more natural, avoiding jarring visual jumps and improving the user experience.

[0043] In this embodiment, the system also includes a configuration saving module for saving the user-configured logical expressions and binding relationships as a JSON-formatted configuration file, which is loaded in preview mode or at runtime; the configuration file includes expression strings, variable lists, and control identifiers.

[0044] It should be noted that the system also includes a configuration saving module that saves the user-configured logical expressions and binding relationships as a JSON-formatted configuration file. For example, the expression ${operating_voltage}>5.0, the variable list ["operating_voltage"], and the control identifier "high_voltage_warning" are serialized into a JSON object and stored in a file or database. In preview mode or at runtime, the system loads this configuration file and directly applies the saved configuration without the need to re-enter it. This facilitates the persistence, version control, and reuse of configurations, improving development efficiency.

[0045] In this embodiment, the system is applied to the form development scenario in a low-code platform, where the form variables include user input fields, system variables, or calculated fields; the closed-loop control process is implemented through server-side interface calls, with interface requests including expressions and current data and interface responses including parsing results.

[0046] It should be noted that the system is applied to the form development scenario in the low-code platform, wherein the form variables include user input fields (such as operating_voltage), system variables (such as current time) or calculation fields (such as derived values). The closed-loop control process is implemented through a server interface call; for example, the client sends an HTTP POST request to the / evaluate endpoint, the request body contains an expression string and the current form data, and the server returns the parsing result (such as true or false) after processing. The interface response drives the interface update, ensuring reliability and scalability, suitable for enterprise application scenarios.

[0047] Embodiment 2 As shown in Figure 2 A dynamic display method of expression control of a semiconductor design form, characterized in that it comprises the following steps: Receiving a logical expression input by a user through an expression editor, and providing a variable prompt component to prompt available variables in the form in real time, wherein the logical expression includes arithmetic operations, logical judgments or string processing; Identifying dynamic variable references in the logical expression through a regular parsing engine, and establishing a binding relationship between variables and controls to form a dependency graph; Listening to form data change events, when detecting variable value changes, querying the dependency graph to obtain the affected control set, and merging and optimizing expression calculation requests through a batch processing queue; Through a security sandbox, the user-submitted logical expression is subjected to syntax checking and dangerous operation filtering, and through a distributed computing node, the expression calculation request is processed in a multi-threaded manner in parallel, and the parsing result is returned; According to the parsing result, the difference comparison module compares the difference between the parsing result and the current control state, and judges whether the current control needs to be updated according to the difference, if yes, triggers the update operation, which includes: adding a smooth transition effect to the control visibility state change through an animation transition controller.

[0048] The semiconductor design form expression control dynamic display method provided in this embodiment has the same implementation principle and technical effects as the system embodiment in Embodiment 1. For brevity, the part not mentioned in the method embodiment can be referred to the corresponding content in Embodiment 1.

[0049] Embodiment 3 A computer readable storage medium having a computer program stored thereon, wherein the computer program is run by a computer to execute the semiconductor design form expression control dynamic display method described in Embodiment 2.

[0050] Embodiment 4 An electronic device, comprising: a memory and a processor, the processor and the memory are connected; The memory is used to store a program; The processor invokes the program stored in the memory to execute a dynamic display method of an expression control of a semiconductor design form as described in Embodiment 2.

[0051] It should be noted that the electronic device can be, but is not limited to, a personal computer (PC), a tablet computer, a mobile internet device (MID), and the like.

[0052] It should be noted that the processor, the memory and other components that can appear in the electronic device are directly or indirectly electrically connected to each other to realize the transmission or interaction of data. For example, the processor, the memory and other components can be electrically connected to each other through one or more communication buses or signal lines.

[0053] It should be noted that each embodiment in the specification is described in a progressive manner, and each embodiment focuses on the difference from other embodiments. The same or similar parts of each embodiment can be referred to each other.

[0054] In several embodiments provided in the present application, it should be understood that the disclosed system and method can also be implemented in other ways. The system embodiments described above are only schematic. For example, the flowchart and block diagram in the drawings show the possible implementation architecture, function and operation of the system, method and computer program product according to the embodiments of the present application. In this regard, each block in the flowchart or block diagram can represent a module, a program segment or a part of code, which contains one or more executable instructions for implementing the specified logic function. It should also be noted that in some alternative implementations, the functions noted in the blocks can occur in different orders than that shown in the figure. For example, two consecutive blocks can actually be executed substantially in parallel, and sometimes they can be executed in reverse order, depending on the function involved. It should also be noted that each block in the block diagram and / or flowchart, and the combination of blocks in the block diagram and / or flowchart, can be implemented by a dedicated hardware-based system for executing the specified function or action, or can be implemented by a combination of special-purpose hardware and computer instructions.

[0055] In addition, each functional module in each embodiment of the present application can be integrated together to form an independent part, or each module can exist independently, or two or more modules can be integrated to form an independent part.

[0056] If the functions are implemented in the form of software function modules and sold or used as independent products, they can be stored in a computer readable storage medium. Based on this understanding, the technical solutions of the present application or the parts that essentially contribute to the prior art or the parts of the technical solutions can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes a plurality of instructions for causing a computer device (which can be a personal computer, a notebook computer, a server, a mobile phone, or a network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present application. The aforementioned storage medium includes a U disk, a mobile hard disk, a read-only memory (ROM, Read-Only Memory), a random access memory (RAM, Random Access Memory), a magnetic disk or an optical disk, and various media that can store program codes.

[0057] The above is only a preferred embodiment of the present application, not any limitation on the present application, and any simple modification, change, and equivalent structural change made to the above embodiment according to the technical essence of the present application are still within the protection scope of the technical solutions of the present application.

Claims

1. A dynamic display system for expression-based controls in semiconductor design forms, characterized in that, include: The expression configuration module is used to receive logical expressions entered by the user through the expression editor and to provide a variable prompt component to provide real-time prompts for available variables in the form, wherein the logical expressions include arithmetic operations, logical judgments or string processing; The variable dependency analysis module is used to identify dynamic variable references in the logical expression through a regular expression parsing engine, and to establish the binding relationship between variables and controls to form a dependency graph. The change monitoring and scheduling module is used to monitor form data change events. When a change in variable value is detected, it queries the dependency graph to obtain the set of affected controls and optimizes the expression calculation requests by merging them through a batch processing queue. The expression parsing service module is used to perform syntax checks and filter dangerous operations on user-submitted logical expressions through a security sandbox, and to process expression calculation requests in parallel using a multi-threaded approach through distributed computing nodes, and return the parsing results. The state update execution module is used to compare the parsing result with the current control state through the difference comparison module, and determine whether the current control needs to be updated based on the difference. If so, the update operation is triggered. The update operation includes adding a smooth transition effect to the change of the control's visible and hidden states through the animation transition controller.

2. The semiconductor design form expression-based dynamic display system according to claim 1, characterized in that, The expression editor in the expression configuration module is embedded in the form control property configuration panel, providing a structured code input interface and allowing users to write compound logical expressions; The variable suggestion component analyzes all available variables in the current form in real time and automatically suggests and completes variable references in expressions as the user enters them.

3. The expression-based dynamic display system for semiconductor design forms according to claim 1, characterized in that, The regular expression parsing engine in the variable dependency analysis module identifies dynamic variable references in expressions through preset variable matching rules, which match variable names based on regular expression patterns; the dependency graph construction module establishes a bidirectional index relationship between form variables and associated controls, forming a network binding relationship graph.

4. The expression-based dynamic display system for semiconductor design forms according to claim 1, characterized in that, The event proxy module in the change monitoring and scheduling module listens for form data change events, and the event types include input change, selection change, or programmatic assignment; the batch processing queue merges expression calculation requests for multiple related controls.

5. The expression-based dynamic display system for semiconductor design forms according to claim 1, characterized in that, The security sandbox in the expression parsing service module performs syntax checks on the logical expressions submitted by users, including verifying whether the expression structure is valid and filtering dangerous operations, such as infinite loops, system calls, or file access. The distributed computing nodes support parsing Boolean expressions, numeric expressions, and string expressions.

6. The expression-based dynamic display system for semiconductor design forms according to claim 5, characterized in that, The logical expression includes a conditional expression, which takes the form: if the condition is true, return true; otherwise, return false. The elements in the conditional expression include variables, constants, and operators, and the operators include arithmetic operators, logical operators, and comparison operators.

7. The expression-based dynamic display system for semiconductor design forms according to claim 1, characterized in that, The difference comparison module in the state update execution module compares the difference between the calculated expression and the current control state. The calculated result is a Boolean value, indicating whether the control should be shown or hidden. The update operation includes setting the control's visibility and enabling or disabling its state.

8. A method for dynamically displaying expression-based controls in a semiconductor design form, characterized in that, Includes the following steps: It receives logical expressions entered by users through an expression editor and provides a variable suggestion component to suggest available variables in the form in real time, wherein the logical expressions include arithmetic operations, logical judgments, or string processing; The regular expression parsing engine identifies dynamic variable references in the logical expression and establishes binding relationships between variables and controls, forming a dependency graph. Listen for form data change events. When a change in variable value is detected, query the dependency graph to obtain the set of affected controls, and optimize the expression calculation requests by merging them through a batch processing queue. The system uses a security sandbox to perform syntax checks and filter dangerous operations on user-submitted logical expressions, and uses distributed computing nodes to process expression calculation requests in parallel using multi-threading, and returns the parsing results. Based on the analysis results, the difference comparison module compares the analysis results with the current control state. Based on the difference, it is determined whether the current control needs to be updated. If so, the update operation is triggered. The update operation includes adding a smooth transition effect to the change of the control's visibility state through the animation transition controller.

9. An electronic device, characterized in that, include: A memory and a processor, wherein the processor and the memory are connected; The memory is used to store programs; The processor invokes a program stored in the memory to execute the method of claim 8.

10. A computer-readable storage medium, characterized in that, It stores a computer program, which is executed by a computer to perform the method of claim 8.

Images