WO2022234675A1 - プログラム修正装置、プログラム修正方法及びプログラム - Google Patents

プログラム修正装置、プログラム修正方法及びプログラム Download PDF

Info

Publication number
WO2022234675A1
WO2022234675A1 PCT/JP2021/017569 JP2021017569W WO2022234675A1 WO 2022234675 A1 WO2022234675 A1 WO 2022234675A1 JP 2021017569 W JP2021017569 W JP 2021017569W WO 2022234675 A1 WO2022234675 A1 WO 2022234675A1
Authority
WO
WIPO (PCT)
Prior art keywords
program
migration
api
post
source code
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Ceased
Application number
PCT/JP2021/017569
Other languages
English (en)
French (fr)
Japanese (ja)
Inventor
大輔 山口
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
NTT Inc
Original Assignee
Nippon Telegraph and Telephone Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Nippon Telegraph and Telephone Corp filed Critical Nippon Telegraph and Telephone Corp
Priority to PCT/JP2021/017569 priority Critical patent/WO2022234675A1/ja
Priority to US18/558,251 priority patent/US20240220239A1/en
Priority to JP2023518603A priority patent/JP7513204B2/ja
Publication of WO2022234675A1 publication Critical patent/WO2022234675A1/ja
Anticipated expiration legal-status Critical
Ceased legal-status Critical Current

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/70—Software maintenance or management
    • G06F8/76—Adapting program code to run in a different environment; Porting
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/36—Prevention of errors by analysis, debugging or testing of software
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/42—Syntactic analysis
    • G06F8/427—Parsing
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/51—Source to source
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/60—Software deployment
    • G06F8/65—Updates
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/70—Software maintenance or management
    • G06F8/72—Code refactoring

Definitions

  • the present invention relates to a program correction device, a program correction method and a program.
  • an API is deprecated or deleted when a new version of the library is released, it will be necessary to migrate the API (change the API to be called) for the program (client code) that uses the API.
  • the user of the library can know the specific code editing operations required for migrating the API by means of the migration cases shown in the migration guide or the like, or the technology that enables the collection of such cases.
  • the API cannot be migrated by applying the edit operation to the client code as it is.
  • FIG. 1 shows a migration case where api() that returns a value of type Rectangle is deprecated or deleted. Since there is api '() that returns a value of type Shape (Shape is a supertype of Rectangle) as a migration destination, as a code editing operation, replace the call part of api () with api '() showing good things.
  • api that returns a value of type Rectangle
  • Shape Shape is a supertype of Rectangle
  • Update example analysis has been proposed as a technique for automatically applying editing operations to client code (Non-Patent Document 1).
  • the purpose of Update example analysis is to discover client code editing operations that are commonly performed in all migration cases and apply those editing operations to the client code. Therefore, a large number of migration cases are collected and common parts are extracted for their editing operations.
  • Non-Patent Document 1 uses only the editing operation of the client code that is commonly performed in any migration case, so it does not edit the client code more than necessary, but the calculation after calling the API Even if editing is necessary, the common part of the editing operations of multiple migration cases is extracted, so that the editing operations cannot be applied to the client code (migration will fail).
  • anotherCalculation(api()); is modified to anotherCalculation(api'().getRectangle());
  • the common part of them is only the part where api() is rewritten to api'() put away. As a result, the aforementioned migration failure cannot be avoided.
  • the present invention has been made in view of the above points, and aims to increase the success rate of API migration.
  • the program modification device parses the source code including the API that needs to be migrated, and extracts the type and expression of the first element that constitutes the calculation after calling the API. and any second element having a common type with any one of the first elements constituting a source code difference between a pre-migration program and a post-migration program in the API migration example. and a specifying unit that specifies a portion corresponding to one element as a portion that needs to be rewritten in the source code.
  • FIG. 4 is a flowchart for explaining an example of a processing procedure executed by the program correction device 10;
  • FIG. 11 is a flowchart for explaining an example of a processing procedure of post-calculation analysis;
  • FIG. 4 is a diagram showing an example of client code;
  • FIG. 4 is a diagram showing an example of an abstract syntax tree;
  • FIG. 10 is a flowchart for explaining an example of a post-computation comparison processing procedure;
  • FIG. FIG. 11 is a diagram for explaining an example of expected rewriting;
  • This embodiment discloses a technique for automatically correcting client code to be corrected using collected migration examples.
  • the type program used in the computation after calling the API is reconstructed from the migration example. That is, if the return value type of an API after migration is different from that before migration, there will be a type inconsistency between the type of the value obtained by calling the API and the type of the program used in the calculation after calling the API. Occur.
  • a program is required that implements conversion from the type of the value obtained by calling the API to the type of the program used in the calculation after calling the API.
  • "Reconstruction" means such transformation.
  • restructuring is realized by extracting a part of the code editing in the migration example and reflecting it in the client code.
  • the number of collected cases does not affect the success or failure of migration.
  • Client code refers to the source code of the program that uses the API, and is a term used to distinguish it from the source code of the library that provides the API.
  • API migration refers to changing the API called by the client code.
  • a piece of client code, or the term "program” as used with respect to migration cases means a syntactic definition of a program.
  • the syntax definition of a program refers to a statement, an expression, and a sequence of statements or expressions composed of them, and each statement and expression has a recursive structure.
  • FIG. 2 is a diagram showing a hardware configuration example of the program correction device 10 according to the embodiment of the present invention.
  • 2 includes a drive device 100, an auxiliary storage device 102, a memory device 103, a CPU 104, an interface device 105, a display device 106, an input device 107, etc., which are connected to each other via a bus B, respectively.
  • a program that implements processing in the program correction device 10 is provided by a recording medium 101 such as a CD-ROM.
  • a recording medium 101 such as a CD-ROM.
  • the program is installed from the recording medium 101 to the auxiliary storage device 102 via the drive device 100 .
  • the program does not necessarily need to be installed from the recording medium 101, and may be downloaded from another computer via the network.
  • the auxiliary storage device 102 stores installed programs, as well as necessary files and data.
  • the memory device 103 reads and stores the program from the auxiliary storage device 102 when a program activation instruction is received.
  • the CPU 104 implements functions related to the program correction device 10 according to the programs stored in the memory device 103 .
  • the interface device 105 is used as an interface for connecting to a network.
  • a display device 106 displays a program-based GUI (Graphical User Interface) or the like.
  • the input device 107 is composed of a keyboard, a mouse, etc., and is used to input various operational instructions.
  • FIG. 3 is a diagram showing a functional configuration example of the program correction device 10 according to the embodiment of the present invention.
  • the program correction device 10 has a post-calculation analysis section 11 , a post-calculation comparison section 12 , a variable translation section 13 and a code rewriting section 14 . These units are implemented by one or more programs installed in the program correction device 10 causing the CPU 104 to execute them.
  • the post-calculation analysis unit 11 analyzes the calculation after calling the API (hereinafter referred to as “post-calculation”) in the client code to be modified, and builds a model described later (hereinafter referred to as “post-calculation model”). and extracts from the client code the types used in post-computation in the client code. Note that the calculation is defined in the client code.
  • the post-computation comparing unit 12 compares the post-computation of each of the collected migration cases with the post-computation of the client code, identifies the portion that needs to be rewritten in the client code, and compares the difference before and after the migration in the migration case. among the calculation elements (formulas and types) that make up the client code, identify the elements (hereinafter referred to as "common elements") whose types match those of the post-calculation elements of the client code.
  • the variable translation unit 13 takes correspondence between the variables in the code and the variables in the client code for the post-migration program in the migration example.
  • the code rewriting unit 14 rewrites the client code using the common elements obtained by the post-computation comparing unit 12.
  • FIG. 4 is a flowchart for explaining an example of a processing procedure executed by the program correction device 10. As shown in FIG.
  • step S101 the post-calculation analysis unit 11 inputs a client code.
  • the entered client code is hereinafter referred to as the "target client code”.
  • the post-computation analysis unit 11 constructs a post-computation model by executing post-computation analysis on the target client code (S102).
  • the post-computation model obtained (extracted) as a result of the post-computation analysis is a list of expressions declared in the post-computation of the client code and their types, and what types are used in the post-computation. show.
  • the post-calculation comparison unit 12 determines whether or not there is an unprocessed migration case among the plurality of input migration cases (S103).
  • the post-calculation comparison unit 12 selects one of the unprocessed migration cases as a process target (hereinafter referred to as a "target case") ( S104).
  • the post-computation comparing unit 12 identifies portions that need to be rewritten in the target client code by comparing the target case with the post-computation model of the client code obtained by the post-computation analysis. , and the post-computation of the target client code are identified (S105). If there is no corresponding common element (No in S106), the process returns to step S103. Therefore, in this case, code rewriting using the target case is not executed.
  • the program modification device 10 reflects the rewriting of the code according to the target case in the client code in steps S107 and S108.
  • variable translation unit 13 converts the variables declared in the program of the target case after migration (more precisely, the variables in the common elements) to the variables declared in the target client code. By replacing with variables, the program after the migration is changed. Such changes are hereinafter referred to as "variable translations".
  • the code rewriting unit 14 rewrites the copy of the target client code according to the migration example translated into variables, thereby generating the corrected client code (S108).
  • Such rewriting is realized by replacing the locations identified in step S105 with common elements (translated into variables) in the target client code.
  • the code rewriting unit 14 outputs the corrected client code. That is, each modified client code is generated and output for each migration instance determined to have common elements.
  • FIG. 5 is a flowchart for explaining an example of a processing procedure for post-calculation analysis.
  • the post-computation analysis takes the target client code as input and outputs a post-computation model.
  • step S201 the post-calculation analysis unit 11 parses the target client code and generates an abstract syntax tree as_whole.
  • the post-calculation analysis unit 11 acquires the API call location error_ast that requires migration from ast_whole (S202).
  • error_ast is a subtree below the node corresponding to the location in the abstract syntax tree ast_whole.
  • API call points that require migration may be identified by compiling the client code and based on the inspection results at the time of compilation, or may be identified by other methods.
  • FIG. 5 the processing procedure will be described based on the assumption that there is one location. When there are a plurality of locations, step S202 and subsequent steps may be executed for the plurality of locations.
  • the post-calculation analysis unit 11 initializes the model, which is a list-format variable, to an empty state (S203).
  • the post-computation analysis unit 11 acquires the program usage using error_ast from the code block containing error_ast in the target client code (S204).
  • a code block is a range enclosed in parentheses.
  • a "program that uses error_ast” refers to a program that uses the result of calling the "API that requires migration”.
  • the post-computation analysis unit 11 acquires the parent node as a program using error_ast.
  • • return statement • method call • field access • constructor call • assignment statement Note that the method call is not an API call but an arbitrary method call.
  • a field access refers to a reference to a field held by a value of a certain data type. For example, in the C language, a pointer to a member of a structure corresponds to field access.
  • the post-calculation analysis unit 11 adds the pair of usage type and expression to model as one element (S205). Subsequently, the post-calculation analysis unit 11 sets usage as a new error_ast (S206). That is, the node pointed to by error_ast moves to the root node side in ast_whole. However, when usage is an assignment statement, the post-computation analysis unit 11 exceptionally sets the node corresponding to the assignment destination in the assignment statement as a new error_ast.
  • the post-calculation analysis unit 11 determines whether the parent node of usage in ast_whole (the parent node of the root node of the subtree usage) is a code block (S207). For example, for a program ⁇ return g(f(x)); ⁇ , if usage is return g(f(x)); (however, it is actually converted to an abstract syntax tree), usage Since the parent node of is ⁇ return(f(x)); ⁇ , the parent node of usage corresponds to the code block in this case.
  • the post-calculation analysis unit 11 repeats step S204 and subsequent steps. If the parent node is a code block (Yes in S207), the post-computation analysis unit 11 outputs model as a post-computation model (S208). Finally, model will have a list of programs that recursively use error_ast.
  • node n1 in FIG. 7 is acquired as error_ast in step S202.
  • step S204 node n2 in FIG. 7 is acquired as usage. This is because node n2 corresponds to an assignment statement. Therefore, in step S205, the expression and type of node n2 (Rectangle, var) are added to model.
  • step S206 usage is an assignment statement, so in FIG. 7, node n3, which is the assignment destination of node n2, is set as new error_ast.
  • step S204 of the second round executed for the new error_ast node n4 in FIG. 7 is obtained as usage. This is because node n4 corresponds to field access. Therefore, in step S205 of the second round, the expression and type of node n4 (int, var.numberOfEdges) are added to model. As a result, model becomes [(Rectangle, var), (int, var.numberOfEdges)].
  • step S206 of the second round node n4 is set as a new error_ast.
  • step S204 of the third round node n5 in FIG. 7 is acquired as usage. This is because the node n5 corresponds to the return statement. Therefore, in step S205 of the third round, the expression and type of node n5 (int, var.numberOfEdges) is added to model, but since the same element is already in model, it is simply overwritten. Therefore, the contents of model do not change.
  • step S206 of the third round node n5 is set as a new error_ast.
  • step S207 of the third round since the parent node of usage (node n5) is a code block, in step S208, the content of model at this time [(Rectangle, var), (int, var.numberOfEdges)] is output.
  • FIG. 8 is a flowchart for explaining an example of a post-calculation comparison processing procedure.
  • the post-computation comparison receives the model of the post-computation of the target client code and the target case as input, identifies the portions that need to be rewritten in the client code, and identifies the common elements with the target client code for the target case.
  • step S301 the post-calculation comparison unit 12 acquires the post-calculation model model of the target client code. Subsequently, the post-calculation comparison unit 12 acquires the program "before" before migration from the target case (S302). Subsequently, the post-calculation comparison unit 12 acquires the post-migration program after from the target case (S303). Subsequently, the post-computation comparing unit 12 acquires the code difference between before and after (difference between before and after (difference)) diff in the form of an abstract syntax tree (S304).
  • a code difference in the abstract syntax tree format can be obtained using Update example analysis in Non-Patent Document 1.
  • the code differences in the abstract syntax tree format are as follows. [(T, calc(api'().getRectangle())), [(Rectangle, api'().getRectangle()), [(Shape, api'())] ] ]
  • the post-calculation comparison unit 12 executes loop processing L1 for each node (T d , ed ) of diff.
  • a node to be processed in loop processing L1 is hereinafter referred to as a "target node".
  • the target nodes are selected in descending order from the root element of diff. Note that Td indicates the type of the target node, and ed indicates the expression of the target node.
  • the post-computation comparing unit 12 substitutes the element including the same type as the type Td of the target node in the model into the list same (S305).
  • the post-calculation comparison unit 12 determines whether or not same is empty (S306). If same is empty (No in S306), steps S307 and subsequent steps are not executed for the target node.
  • step S306 If same is not empty (if an element containing the same type as the type Td of the target node is found) (Yes in S306), the top element of same is treated as a portion that needs to be rewritten by the client code in step S108 of FIG. Identify (S307). That is, in step S108, the portion corresponding to the head element is rewritten.
  • the order of the elements is in the depth direction of the abstract syntax tree from the "API call site requiring migration". That is, when model has two adjacent elements a and b, the positional relationship between a and b on the abstract syntax tree is that b is a child node of a.
  • the post-calculation comparison unit 12 outputs (T d , ed ) for the target case as a common element with the target client code (S308), and ends the processing in FIG.
  • the reason why there is a possibility of exiting in the middle of the loop is that it suffices if at least one common element is found.
  • the (T d , ed ) corresponds to the closest element to the “API call site requiring migration” in the positional relationship in the depth direction of diff. By doing so, type mismatch resolution is performed at the closest element.
  • variable translation unit 13 adds a new declaration to the post-migration program of the target case.
  • take correspondence between the variables accessed in the migration example and the variables declared in the client code means “variables of the same type are defined in both, but the variable names are different” ” is the processing performed when Compare the set of variables defined in the client code with the variable that needs to be newly defined (color in the previous example), and select the variables that can be judged to be the same according to a certain standard from the set of variables defined in the client code. Refers to the process of extracting. A certain criterion differs depending on the method of variable translation. For example, in Non-Patent Document 1, a criterion is adopted in which variables having the same type are regarded as the same variable.
  • client code is migrated based on migration cases that have common elements with post-computation of client code. Therefore, the success rate of API migration can be increased.
  • the post-computation analysis unit 11 identifies the type used in the post-computation of the client code
  • the post-computation comparison unit 12 determines the value of the type used in the post-computation of the client code from the type used in the migration example.
  • the client code can reflect any code edits necessary to perform calculations after calling the API.
  • the post-calculation analysis unit 11 is an example of an analysis unit.
  • the post-calculation comparison unit 12 is an example of an identification unit.
  • the variable translation unit 13 is an example of a translation unit.
  • the code rewriting section 14 is an example of a rewriting section.

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Computer Hardware Design (AREA)
  • Quality & Reliability (AREA)
  • Computer Security & Cryptography (AREA)
  • Stored Programmes (AREA)
  • Debugging And Monitoring (AREA)
PCT/JP2021/017569 2021-05-07 2021-05-07 プログラム修正装置、プログラム修正方法及びプログラム Ceased WO2022234675A1 (ja)

Priority Applications (3)

Application Number Priority Date Filing Date Title
PCT/JP2021/017569 WO2022234675A1 (ja) 2021-05-07 2021-05-07 プログラム修正装置、プログラム修正方法及びプログラム
US18/558,251 US20240220239A1 (en) 2021-05-07 2021-05-07 Program correcting apparatus, program correcting method and program
JP2023518603A JP7513204B2 (ja) 2021-05-07 2021-05-07 プログラム修正装置、プログラム修正方法及びプログラム

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
PCT/JP2021/017569 WO2022234675A1 (ja) 2021-05-07 2021-05-07 プログラム修正装置、プログラム修正方法及びプログラム

Publications (1)

Publication Number Publication Date
WO2022234675A1 true WO2022234675A1 (ja) 2022-11-10

Family

ID=83932044

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/JP2021/017569 Ceased WO2022234675A1 (ja) 2021-05-07 2021-05-07 プログラム修正装置、プログラム修正方法及びプログラム

Country Status (3)

Country Link
US (1) US20240220239A1 (cg-RX-API-DMAC7.html)
JP (1) JP7513204B2 (cg-RX-API-DMAC7.html)
WO (1) WO2022234675A1 (cg-RX-API-DMAC7.html)

Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPH10154079A (ja) * 1996-09-30 1998-06-09 Hitachi Software Eng Co Ltd プログラム変換装置および記憶媒体
US20200192662A1 (en) * 2018-12-12 2020-06-18 Sap Se Semantic-aware and self-corrective re-architecting system

Family Cites Families (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US10956242B1 (en) * 2017-12-06 2021-03-23 Amazon Technologies, Inc. Automating the migration of web service implementations to a service provider system
US10509642B2 (en) * 2018-03-30 2019-12-17 International Business Machines Corporation Intelligent discovery and application of API changes for application migration
CN109614083A (zh) * 2018-10-19 2019-04-12 北京大学 一种基于迁移学习的api辅助代码概要生成方法
US11544054B2 (en) * 2021-03-22 2023-01-03 Wind River Systems, Inc. Determination of API changes

Patent Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPH10154079A (ja) * 1996-09-30 1998-06-09 Hitachi Software Eng Co Ltd プログラム変換装置および記憶媒体
US20200192662A1 (en) * 2018-12-12 2020-06-18 Sap Se Semantic-aware and self-corrective re-architecting system

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
FAZZINI, M. ET AL.: "Automated API-usage update for Android apps", PROCEEDINGS OF THE 28TH ACM SIGSOFT INTERNATIONAL SYMPOSIUM ON SOFTWARE TESTING AND ANALYSIS, 10 July 2019 (2019-07-10), pages 204 - 215, XP058701904, Retrieved from the Internet <URL:https://dl.acm.org/doi/10.1145/3293882.3330571> [retrieved on 20210628], DOI: 10.1145/3293882.3330571 *

Also Published As

Publication number Publication date
JPWO2022234675A1 (cg-RX-API-DMAC7.html) 2022-11-10
US20240220239A1 (en) 2024-07-04
JP7513204B2 (ja) 2024-07-09

Similar Documents

Publication Publication Date Title
US8813047B2 (en) Yet another transformation language (YATL)
US8645932B2 (en) Control flow analysis methods and computing devices for converting COBOL-sourced programs to object-oriented program structures
US7346897B2 (en) System for translating programming languages
CN102222039B (zh) 使用dsl来调用api以测试软件
CN104866369B (zh) 一种数据处理的方法以及装置
JPH0667868A (ja) アルゴリズムを記号評価する方法およびアルゴリズムをトランスレートする装置
CN102696026B (zh) 一种用于创建数据结构的系统和方法
EP2829970A1 (en) A method and apparatus for porting source code
CN111880777A (zh) 程序信息下发方法、装置、电子设备
US20190171426A1 (en) Program compiler and linker, and method
CN108549535B (zh) 一种基于文件依赖关系的高效程序解析方法和系统
Galindo et al. Program slicing of Java programs
Ikeshita et al. Test suite reduction in idempotence testing of infrastructure as code
US20110296373A1 (en) Command line shell command generation based on schema
Zhang et al. Automated extraction of grammar optimization rule configurations for metamodel-grammar co-evolution
CN115826968B (zh) 基于vue的动态编译跨平台组件的方法、装置及应用
JP2022119668A (ja) コード変更方法及びコード変更プログラム
Greenberg Word expansion supports POSIX shell interactivity
WO2022123763A1 (ja) コールグラフ作成装置、コールグラフ作成方法及びプログラム
JP7513204B2 (ja) プログラム修正装置、プログラム修正方法及びプログラム
CN115098158A (zh) Sdk打包方法和装置、计算机设备及存储介质
JP5600301B2 (ja) システム表現およびハンドリング技術
JP7059757B2 (ja) Api処理方法、端末、api処理プログラム
Fülöp et al. A framework for C++ exception handling assistance
JP3266097B2 (ja) 非リエントラントプログラムの自動リエントラント化方法及びシステム

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 21939865

Country of ref document: EP

Kind code of ref document: A1

WWE Wipo information: entry into national phase

Ref document number: 2023518603

Country of ref document: JP

WWE Wipo information: entry into national phase

Ref document number: 18558251

Country of ref document: US

NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 21939865

Country of ref document: EP

Kind code of ref document: A1