A Dynamic Display System and Method for Expression-Based Controls in Semiconductor Design Forms

Abstract

This invention discloses a system and method for dynamically displaying expression-based controls in semiconductor design forms. The system includes an expression configuration module for receiving logical expressions input by the user and providing real-time suggestions of available variables in the form; a variable dependency analysis module for identifying dynamic variable references in the logical expressions; a change monitoring and scheduling module for monitoring form data change events, obtaining a set of affected controls when a variable value change is detected, and merging and optimizing expression calculation requests; an expression parsing service module for performing syntax checks and filtering of dangerous operations on the logical expressions, processing expression calculation requests, and returning parsing results; and a state update execution module for comparing the parsing results with the current control state and determining whether the current control needs an update operation based on the difference. This invention effectively solves the performance waste problem caused by global monitoring of data changes.

Description

Technical Field

[0001] This invention belongs to the field of semiconductor design, and in particular relates to a dynamic display system and method for expression-based controls in semiconductor design forms. Background Technology

[0002] In the field of semiconductor design, forms are commonly used to configure and dynamically adjust chip design parameters (such as transistor size, material properties, or logic rules). However, existing technologies generally employ 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*. While this approach provides a visual interface to simplify rule settings, it has significant drawbacks in semiconductor design scenarios. Due to the frequent changes in semiconductor parameters and the involvement of 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 monitoring mechanism—whenever any data in the form changes, the system globally triggers the recalculation and update of all controls, leading to unnecessary computational overhead, a surge in network traffic, and response latency. This performance waste is particularly prominent in large-scale semiconductor design projects, severely impacting the dynamic responsiveness of forms and user experience. For example, during semiconductor parameter adjustment, frequent global monitoring can cause interface lag and resource waste, failing to meet real-time design requirements. Therefore, the main performance waste problem in existing technologies stems from changes in globally monitored data. Summary of the Invention

[0003] The technical problem to be solved by the present invention is to provide a dynamic display system and method for expression-based controls of semiconductor design forms, which effectively solves the performance waste caused by changes in global monitoring data, in order to address the shortcomings of the prior art.

[0004] The first aspect of this invention discloses a dynamic display system for expression-based controls of semiconductor design forms, comprising:

[0005] The expression configuration module is used to receive logical expressions entered by users 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;

[0006] 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.

[0007] 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.

[0008] 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.

[0009] 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.

[0010] In the aforementioned system, the expression editor in the expression configuration module is embedded in the form control property configuration panel, providing a structured code input interface that allows users to write complex 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 the expression when the user inputs.

[0011] In the aforementioned system, 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.

[0012] In the aforementioned system, the event proxy module in the change monitoring and scheduling module monitors form data change events, and the event types include input changes, selection changes, or programmatic assignments; the batch processing queue merges expression calculation requests from multiple related controls.

[0013] In the aforementioned system, the security sandbox in the expression parsing service module performs syntax checks on the logical expressions submitted by users, including verifying the validity of the expression structure 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.

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

[0015] In the above system, 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 visibility of the control and enabling or disabling its state.

[0016] In the above system, the animation transition controller adds a smooth transition effect to the change of the visibility state of the control. The transition effect includes fade-in / fade-out, sliding, or scaling. The transition duration is configurable and ranges from 0.1 seconds to 2 seconds.

[0017] The system further includes a configuration saving module, which saves 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.

[0018] The aforementioned system is applied to form development scenarios in low-code platforms, where form variables include user input fields, system variables, or calculated fields; the closed-loop control flow is implemented through server-side interface calls, where the interface request includes an expression and current data, and the interface response includes the parsing result.

[0019] The second aspect of this invention discloses a method for dynamically displaying expression-based controls in a semiconductor design form, comprising the following steps:

[0020] 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;

[0021] 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.

[0022] 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.

[0023] 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.

[0024] 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.

[0025] A third aspect of the present invention discloses an electronic device, comprising: a memory and a processor, wherein the processor and the memory are connected;

[0026] The memory is used to store programs;

[0027] The processor invokes a program stored in the memory to execute the method provided in the second aspect embodiment described above.

[0028] The fourth aspect of the present invention discloses a computer-readable storage medium having a computer program stored thereon, the computer program being executed by a computer to perform the method provided in the second aspect embodiment.

[0029] Compared with existing technologies, this invention has the following advantages: In semiconductor design form scenarios, such as chip parameter configuration (e.g., voltage threshold or material type adjustment), this invention significantly reduces unnecessary computational 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 expression parsing engine and establishes a dependency graph of "variable-controls," ensuring that subsequent processing is triggered only when a specific variable (such as {voltage threshold}) changes. This avoids the indiscriminate response to all data under the traditional global monitoring mechanism, thereby significantly reducing computational redundancy. For example, when semiconductor parameters change, the system only focuses on the relevant controls, rather than recalculating the entire form. Second, the change monitoring and scheduling module listens for form data change events. When a change in variable value is detected (e.g., user modification of material type), it immediately queries the dependency graph to obtain the set of affected controls and optimizes multiple expression calculation requests by merging them through a batch processing queue. This reduces the number of network requests and server load, improving response efficiency. Meanwhile, the expression parsing service module utilizes a security sandbox for syntax checking and dangerous operation filtering, and processes requests in parallel through distributed computing nodes. This ensures efficient and secure parsing of complex expressions (such as the logical judgment {voltage threshold}>1.2V), preventing risks such as XSS attacks and enhancing system reliability and scalability. Furthermore, the state update execution module compares the parsed results with the current control state through a difference comparison module, triggering update operations only when actual differences exist (such as changes in control visibility). A smoothing effect is added through an animation transition controller, avoiding user discomfort caused by abrupt interface changes. This is particularly important in semiconductor design where frequent parameter adjustments reduce interface lag and resource waste. Overall, these features work together to achieve closed-loop control of "data change - expression recalculation - interface update." For example, after a monitored field change, calculations are only performed on the bound variables, significantly improving the dynamic responsiveness of semiconductor design forms and user experience. Ultimately, by reducing unnecessary recalculation and update operations, the system lowers performance bottlenecks, optimizes resource consumption, and supports real-time design requirements.

[0030] The technical solution of the present invention will be further described in detail below with reference to the accompanying drawings and embodiments. Attached Figure Description

[0031] Figure 1 This is a system module diagram of Embodiment 1 of the present invention.

[0032] Figure 2 This is a flowchart of the method in Embodiment 2 of the present invention. Detailed Implementation

[0033] Example 1

[0034] The following technical implementation details are based on a common scenario: In a semiconductor design form, there is an "operating_voltage" field and a "high_voltage_warning" control. The warning control is displayed when the operating voltage is greater than 5.0. The expression is ${operating_voltage}>5.0.

[0035] like Figure 1 As shown, a dynamic display system for expression-based controls in semiconductor design forms includes:

[0036] The expression configuration module is used to receive logical expressions entered by users 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;

[0037] 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.

[0038] 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.

[0039] 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.

[0040] 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.

[0041] It's worth noting that during implementation, the expression configuration module allows users to select the high-voltage warning control when designing forms and locate the expression editor in the properties panel. When the user begins entering an expression, the editor provides a text input area with syntax highlighting. As the user enters a dollar sign and curly braces, the variable suggestion 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 a variable using the keyboard or mouse, and the system automatically inserts the variable reference, for example, auto-completion to `operating_voltage`. The user continues to enter comparison operators and values ​​to complete the expression `{operating_voltage}>5.0`. This process, through an intuitive interface and real-time assistance, significantly reduces manual coding errors and time, improving development efficiency.

[0042] The variable dependency analysis module uses a regular expression parsing engine to process user-input expressions. The engine predefines variable matching patterns, such as recognizing strings that begin or end with a variable reference. 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 this variable and high-voltage warning controls. For example, it maintains a mapping table where the `operating_voltage` key corresponds to a list of controls, including `high_voltage_warning`, while the controls also backreference 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, thus optimizing performance. The change monitoring scheduling module's event delegate module registers to listen for data change events in the form, such as the `onChange` event of an input field or assignment operations set via the API. When the user modifies the value of the operating voltage field, for example, from 4.0 to 6.0, the event delegate detects this change, retrieves the variable name `operating_voltage`, and queries the dependency graph. The graph returns a set of associated controls, such as those containing only `high_voltage_warning`.

[0043] The system adds expression evaluation requests 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 evaluation call. This reduces the number of network requests, lowers server load, and improves response speed.

[0044] The expression parsing service module receives requests from a batch queue, containing expression strings and current form data. The security sandbox first parses the expression syntax, checking structural validity, such as ensuring matching parentheses and correct operator usage, and filtering dangerous operations, such as attempts to execute system commands or infinite loops. After passing these checks, distributed computing nodes allocate multiple threads to process the request in parallel. For example, one thread processes the expression `{operating_voltage}>5.0`, substituting the data `{operating_voltage: 6.0}`, and calculates the result as `true`. This parallel processing and security checks ensure efficient and secure expression parsing, preventing malicious code injection.

[0045] The state update execution module's difference comparison module receives the parsed result "true" and compares it with the current state of the high-pressure warning control. If the control was originally hidden and the difference comparison determines that an update is needed, then an update operation is triggered. The animation transition controller applies a smoothing effect, such as gradually increasing the control's opacity from 0 to 100% using a CSS gradient with a duration of 0.5 seconds, causing the control to fade into view. If the state remains unchanged, the update is skipped to avoid unnecessary rendering. This achieves fine-grained interface control, improving user experience and system performance.

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

[0047] In this embodiment, the expression editor in the expression configuration module is embedded in the form control property configuration panel, providing a structured code input interface that allows 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 the expression when the user inputs.

[0048] It's worth noting that the expression editor in the expression configuration module is directly integrated into the form control property configuration panel as a built-in component. It provides a structured code input interface, supports syntax highlighting and error suggestions, such as displaying a red underline when the user enters an invalid operator. The variable suggestion component scans the form definition in real time, extracts all available variables, such as operating_voltage and other field variables, and dynamically pops up suggestions during user input. For example, when the user types ${op, the component immediately displays a list of matching variables; after the user selects operating_voltage using the arrow keys and presses Enter, the system automatically inserts the complete variable reference. This allows users to quickly write complex logical expressions, such as those combining multiple conditions, reducing manual memorization and input errors, and improving configuration efficiency.

[0049] In this embodiment, 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.

[0050] It's important to note that the regular expression parsing engine in the variable dependency analysis module uses a preset 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 bidirectional index relationships, for example, creating a graph structure where nodes represent variables and controls, and edges represent dependencies. The variable `operating_voltage` points to the control `high_voltage_warning`, while the control records the variables it depends on. This mesh-like binding graph ensures that the system can efficiently track the impact of variable changes, triggering only recalculation of relevant controls and avoiding performance bottlenecks caused by full data monitoring.

[0051] In this embodiment, the event proxy module in the change monitoring and scheduling module monitors 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.

[0052] It's important to note that the event broker module of the change monitoring and scheduling module listens for specific types of data change events, including input changes (such as keyboard input), selection changes (such as dropdown selections), or programmatic assignments (via API calls). When the value of the operating_voltage field changes, the event broker captures the event details, extracts the variable name, and queries the dependency graph to obtain the set of affected controls. The batch processing queue then merges expression calculation requests for these controls. For example, within a 50-millisecond time window, it collects all requests based on operating_voltage and sends only one calculation request to the server, containing the expression and the latest data. This optimizes network utilization, reduces latency, and improves overall performance.

[0053] In this embodiment, 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, including infinite loops, system calls, or file access; the distributed computing nodes support parsing Boolean expressions, numeric expressions, and string expressions.

[0054] It's important to note that the security sandbox of the expression parsing service module performs syntax checks on user-submitted logical expressions, including verifying the validity of the expression structure (e.g., checking operator order and nested parentheses) and filtering dangerous operations such as infinite loops (by detecting recursive patterns), system calls (e.g., the `eval` function), or file access. The distributed computing nodes employ a multi-threaded architecture, using thread pools to process multiple expression requests in parallel. Supported expression types include Boolean expressions (e.g., returning true / false), numeric expressions (e.g., arithmetic operations), and string expressions (e.g., concatenation operations). When processing the expression `${operating_voltage}>5.0`, after the sandbox ensures there are no dangers, the node quickly calculates and returns the result, improving both processing capacity and security.

[0055] In this embodiment, 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. The operators include arithmetic operators (+, -, *, / ), logical operators (&&, ||, !), and comparison operators (>, <, ==).

[0056] It's important to note that logical expressions include conditional expressions, which return 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. Operators cover arithmetic operators (such as +, -, *, / for calculation), logical operators (such as &&, ||, ! for combining conditions), and comparison operators (such as >, <, == for comparison). For example, a user could write the expression `{operating_voltage} * 2>10&&{status} == 'active'`. The system will first calculate the arithmetic part and then apply the logical comparison. This enables the handling of complex business logic and enhances the dynamism and flexibility of the form.

[0057] 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. The calculation result is a Boolean value, indicating whether the control should be shown or hidden. The update operation includes setting the control visibility and enabling or disabling the state.

[0058] It's important to note that the difference comparison module in the state update execution module calculates a boolean value for the expression, such as `true` indicating the control should be displayed, and `false` indicating it should be hidden. The module compares this result with the control's current state. For example, if the high-pressure warning control is currently hidden and the result is `true`, an update is required, triggering the operation to set the control's visibility. If the states are the same, the update is skipped. Update operations include changing control visibility and enabling or disabling states, ensuring that UI changes are only performed when actual differences exist, reducing unnecessary DOM operations and improving rendering efficiency.

[0059] In this embodiment, the animation transition controller adds a smooth transition effect to the change of the visibility state of the control. The transition effect includes fade-in / fade-out, sliding, or scaling. The transition duration is configurable and ranges from 0.1 seconds to 2 seconds.

[0060] It's worth noting that the animation transition controller adds a smooth transition effect to the changes in the visibility of controls. When the high-pressure warning control changes from hidden to visible, the controller applies a fade-in effect, with the duration configurable by gradually increasing the transparency from 0% to 100% over, such as 0.5 seconds. Transition effects also include sliding (the control slides in from one side) or scaling (the control enlarges from small to large), with durations set between 0.1 and 2 seconds, for example, through user configuration. This makes the interface changes more natural, avoids abrupt visual jumps, and improves the user experience.

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

[0062] It's worth noting that the system also includes a configuration saving module, which saves 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 JSON objects and stored in a file or database. In preview mode or runtime, the system loads this configuration file and directly applies the saved configuration without requiring re-entry. This facilitates configuration persistence, version control, and reuse, improving development efficiency.

[0063] In this embodiment, the system is applied to a form development scenario in a low-code platform, where form variables include user input fields, system variables, or calculated fields; the closed-loop control flow is implemented through server-side interface calls, where the interface request includes an expression and current data, and the interface response includes the parsing result.

[0064] It should be noted that the system is applied to form development scenarios in low-code platforms, where form variables include user input fields (such as operating_voltage), system variables (such as current time), or calculated fields (such as derived values). The closed-loop control flow is implemented through server-side interface calls; for example, the client sends an HTTP POST request to the / evaluate endpoint, the request body containing an expression string and the current form data, and the server processes it and returns the parsed result (such as true or false). Interface responses drive UI updates, ensuring reliability and scalability, making it suitable for enterprise-level application scenarios.

[0065] Example 2

[0066] like Figure 2 As shown, a method for dynamically displaying expression-based controls in a semiconductor design form is characterized by the following steps:

[0067] 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;

[0068] 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.

[0069] 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.

[0070] 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.

[0071] 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.

[0072] The method for dynamically displaying expression-based controls in semiconductor design forms provided in this embodiment has the same implementation principle and technical effect as the system embodiment in Embodiment 1. For the sake of brevity, any parts not mentioned in the method embodiment can be referred to the corresponding content in Embodiment 1.

[0073] Example 3

[0074] A computer-readable storage medium having a computer program stored thereon, the computer program being executed by a computer during runtime, as described in Embodiment 2 above, a method for dynamically displaying an expression-based control of a semiconductor design form.

[0075] Example 4

[0076] An electronic device includes: a memory and a processor, wherein the processor and the memory are connected;

[0077] The memory is used to store programs;

[0078] The processor calls a program stored in the memory to execute a method for dynamically displaying an expression-based control of a semiconductor design form as described in Embodiment 2.

[0079] It should be noted that the electronic device mentioned may be, but is not limited to, personal computers (PCs), tablet computers, mobile internet devices (MIDs), etc.

[0080] It should be noted that processors, memory, and other components that may be present in electronic devices are electrically connected to each other, directly or indirectly, to enable data transmission or interaction. For example, processors, memory, and other components may be electrically connected to each other via one or more communication buses or signal lines.

[0081] It should be noted that the various embodiments in this specification are described in a progressive manner, with each embodiment focusing on the differences from other embodiments. The same or similar parts between the various embodiments can be referred to each other.

[0082] In the several embodiments provided in this application, it should be understood that the disclosed systems and methods can also be implemented in other ways. The system embodiments described above are merely illustrative. For example, the flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions marked in the blocks may occur in a different order than those marked in the drawings. For example, two consecutive blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in a block diagram and / or flowchart, and combinations of blocks in block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or action, or using a combination of dedicated hardware and computer instructions.

[0083] In addition, the functional modules in the various embodiments of this 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.

[0084] If the aforementioned functions are implemented as software functional modules and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, laptop, server, mobile phone, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0085] The above description is merely a preferred embodiment of the present invention and does not constitute any limitation on the present invention. Any simple modifications, alterations, or equivalent structural changes made to the above embodiments based on the technical essence of the present invention shall still fall within the protection scope of the present invention.

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 users 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 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. 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 event proxy module in the change monitoring and scheduling module monitors 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; 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 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, including infinite loops, system calls, or file access; the distributed computing nodes support parsing Boolean expressions, numeric expressions, and string expressions. 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 visibility state through the animation transition controller. The difference comparison module in the state update execution module compares the difference between the expression calculation result and the current control state. The calculation result is a Boolean value, indicating whether the control should be shown or hidden. The update operation includes setting the control visibility and enabling or disabling the state. The animation transition controller adds a smooth transition effect to the changes in the visibility state of controls. The transition effect includes fade-in / fade-out, sliding, or scaling. The transition duration is configurable, ranging from 0.1 seconds to 2 seconds. The system also includes a configuration saving module, which saves 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.

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 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.

4. 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 a binding relationship between variables and controls, forming a dependency graph. The regular expression parsing engine identifies dynamic variable references in the expression through preset variable matching rules, which are based on matching variable names according to regular expression patterns. Establish a two-way index relationship between form variables and associated controls to form a network binding relationship diagram; The system listens for 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 merges and optimizes expression calculation requests through a batch processing queue. Event types include input change, selection change, or programmatic assignment. The batch processing queue merges expression calculation requests for multiple related controls. 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. The security sandbox performs syntax checks on the logical expressions submitted by users, including verifying the validity of the expression structure 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. 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. The difference comparison module compares the result of the expression calculation with the current control state. The calculation 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. The animation transition controller adds a smooth transition effect to the changes in the visibility state of controls. The transition effect includes fade-in / fade-out, sliding, or scaling. The transition duration is configurable, ranging from 0.1 seconds to 2 seconds. The user-configured logical expressions and binding relationships are saved 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.

5. 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 4.

6. 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 4.

Images