Integer code scanning method and its device, equipment and medium

Abstract

The present application discloses an integer code scanning method and its device, equipment, and medium, the method comprising: responding to a low-order integer scanning instruction acting on a code file set to be scanned, obtaining a target low-order integer library acting on the code file set to be scanned, wherein the target low-order integer library stores a plurality of low-order integer data; calling a preset low-order integer scanning rule, and scanning out low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library; encapsulating each of the low-order integer code statements and its corresponding code file name into print mapping data, and generating a print file containing each of the print mapping data for output. The present application can efficiently scan out code statements having low-order integer data in a code file to print them out, replacing manual code retrieval, and effectively improving the efficiency of application development and repair.

Description

Technical Field

[0001] The present application relates to the field of program development, and in particular to an integer code scanning method, and also to corresponding devices, equipment and non-volatile storage media of the method. Background Art

[0002] When developing existing Internet platform applications, 32-bit integer data is generally used to define the unique user identifier of the platform user, or 32-bit integer data is used to define the attributes and parameters associated with the unique user identifier of the platform user to develop related functions in the platform. For example, for applications on online live broadcast platforms, 32-bit integer data is usually used to define the unique user identifiers of the anchor users and audience users in the platform, and when developing functions that require the use of unique user identifiers, it is often necessary to use 32-bit integer data to define related attributes and parameters to ensure the stability of the function's operation.

[0003] As the platform develops, the maximum value of data that can be represented by 32-bit integer data cannot meet the growing number of users on the platform. Therefore, the platform developers retrieve the code statements using 32-bit integer data in the platform applications to modify the 32-bit integer data to integer data of other bits that can represent a higher amount of data. However, it takes a lot of time and has high costs for developers to manually retrieve the code statements using 32-bit integer data, and the coverage rate is low, which makes it impossible for the new version of the application to be quickly launched for use by platform users or the new version of the application often has problems in running, affecting the user experience of the platform users and even forcing the platform to stop opening new user registrations, so that Internet users who are not platform users cannot use the platform applications.

[0004] In view of the problems existing in manual low-order integer data retrieval, the applicant has made corresponding explorations in order to solve the problem. Summary of the invention

[0005] The purpose of the present application is to provide an integer code scanning method to meet user needs, and also relates to corresponding devices, equipment, non-volatile storage media and computer program products of the method.

[0006] In order to achieve the purpose of this application, the following technical solutions are adopted:

[0007] An integer code scanning method proposed for the purpose of this application comprises the following steps:

[0008] In response to a low-order integer scanning instruction acting on a code file set to be scanned, a target low-order integer library acting on the code file set to be scanned is obtained, wherein a plurality of low-order integer data are stored in the target low-order integer library;

[0009] Calling a preset low-order integer scanning rule, and scanning the low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library;

[0010] Each of the low-order integer code statements and its corresponding code file name are encapsulated as print mapping data, and a print file containing each of the print mapping data is generated for output.

[0011] In a further embodiment, the step of calling a preset low-order integer scanning algorithm and scanning out low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library comprises the following steps:

[0012] Calling a low-order integer variable scanner to scan the current code text that needs to be scanned in the code file set to be scanned;

[0013] Acquire multiple low-order integer keyword data in the target low-order integer library;

[0014] According to the variable matching algorithm of the low-order integer variable scanner, code statements in the current code file that use any of the low-order integer keyword data to define variables are scanned out.

[0015] In a further embodiment, the step of calling a preset low-order integer scanning algorithm and scanning out low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library comprises the following steps:

[0016] Calling a low-bit integer attribute scanner to scan the current code text that needs to be scanned in the code file set to be scanned;

[0017] Acquire multiple low-order integer keyword data and low-order integer type data in the target low-order integer library;

[0018] According to the attribute matching algorithm of the low-order integer attribute scanner, code statements that use any of the low-order integer keyword data and low-order integer type data to define attributes in the current code file are scanned.

[0019] In a further embodiment, calling a preset low-order integer scanning algorithm, the step of calling the preset low-order integer scanning algorithm, scanning out the low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library, comprises the following steps:

[0020] Calling a low-bit integer transformation scanner to scan the current code text that needs to be scanned in the code file set to be scanned;

[0021] Acquire a plurality of low-order integer keyword data, low-order integer type data and low-order integer conversion data in the target low-order integer library;

[0022] According to the first transformation matching algorithm of the low-order integer transformation scanner, code statements using any of the low-order integer keyword data or low-order integer type data transformation attributes in the current code file are scanned;

[0023] According to the second transformation matching algorithm of the low-order integer transformation scanner, code statements using any of the low-order integer keyword data and low-order integer conversion data transformation attributes in the current code file are scanned out.

[0024] In a further embodiment, the step of calling a preset low-order integer scanning algorithm and scanning out low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library comprises the following steps:

[0025] Calling a low-order integer container scanner to scan the current code text that needs to be scanned in the code file set to be scanned;

[0026] Acquire multiple low-order integer keyword data in the target low-order integer library;

[0027] According to the container matching algorithm of the low-order integer container scanner, code statements in the current code file that use the low-order integer keyword data to define containers are scanned out.

[0028] In a further embodiment, after the step of generating a print file containing each of the print mapping data for output, the following steps are included:

[0029] In response to an erroneous printing instruction acting on the print file, determining one or more print mapping data corresponding to the erroneous printing instruction;

[0030] removing each of the print mapping data from the print file to update the print file;

[0031] Reprinting will complete the updated print file output.

[0032] In a further embodiment, the method comprises the following synchronization steps:

[0033] In response to a data adding instruction acting on the target low-order integer library, obtaining low-order integer data corresponding to the data adding instruction;

[0034] Stop the scanning process acting on the current code file, and store the low-order integer data in the target low-order integer library;

[0035] After the low-order integer data is stored in the target low-order integer library, the scanning process acting on the current code file is restarted.

[0036] An integer code scanning device proposed for the purpose of this application includes:

[0037] A scanning instruction response module, used to respond to a low-order integer scanning instruction acting on a code file set to be scanned, and obtain a target low-order integer library acting on the code file set to be scanned, wherein the target low-order integer library stores a plurality of low-order integer data;

[0038] A code file scanning module, used for calling a preset low-order integer scanning rule, and scanning the low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library;

[0039] The print file output module is used to encapsulate each of the low-order integer code statements and its corresponding code file name into print mapping data, and generate a print file containing each of the print mapping data for output.

[0040] In a further embodiment, the code file scanning module includes:

[0041] The variable scanner calling submodule is used to call the low-order integer variable scanner to scan the current code text that needs to be scanned in the code file set to be scanned;

[0042] A low-order integer data acquisition submodule, used for acquiring a plurality of low-order integer keyword data in the target low-order integer library;

[0043] The variable code statement scanning submodule is used to scan the code statement that uses any of the low-order integer keyword data to define a variable in the current code file according to the variable matching algorithm of the low-order integer variable scanner.

[0044] In a preferred embodiment, the code file scanning module further includes:

[0045] The attribute scanner calling submodule is used to call the low-bit integer attribute scanner to scan the current code text that needs to be scanned in the code file set to be scanned;

[0046] A low-order integer data acquisition submodule, used to acquire a plurality of low-order integer keyword data and low-order integer type data in the target low-order integer library;

[0047] The attribute code statement scanning submodule is used to scan the code statement that uses any of the low-order integer keyword data and low-order integer type data to define attributes in the current code file according to the attribute matching algorithm of the low-order integer attribute scanner.

[0048] In a preferred embodiment, the code file scanning module further includes:

[0049] The transformation scanner calling submodule is used to call the low-bit integer transformation scanner to scan the current code text that needs to be scanned in the code file set to be scanned;

[0050] A low-order integer data acquisition submodule is used to acquire a plurality of low-order integer keyword data, low-order integer type data and low-order integer conversion data in the target low-order integer library;

[0051] A first transformation statement scanning submodule is used to scan the code statements using any of the low-order integer keyword data or low-order integer type data transformation attributes in the current code file according to the first transformation matching algorithm of the low-order integer transformation scanner;

[0052] The second transformation statement scanning submodule is used to scan the code statements using any of the low-order integer keyword data and low-order integer conversion data transformation attributes in the current code file according to the second transformation matching algorithm of the low-order integer transformation scanner.

[0053] In a preferred embodiment, the code file scanning module further includes:

[0054] The container scanner calling submodule is used to call the low-order integer container scanner to scan the current code text that needs to be scanned in the code file set to be scanned;

[0055] A low-order integer data acquisition submodule is used to acquire a plurality of low-order integer keyword data in the target low-order integer library;

[0056] The container code statement scanning submodule is used to scan the code statements in the current code file that use the low-order integer keyword data to define the container according to the container matching algorithm of the low-order integer container scanner.

[0057] Compared with the prior art, the advantages of this application are as follows:

[0058] The present application can automatically scan out code statements with low-order integer data in each code file of the application, and print out these code statements with low-order integer data to a graphical user interface; by obtaining a code file set to be scanned and a target low-order integer library customized by a developer, the code statements with low-order integer data in the target low-order integer library in each code file in the code file set are scanned through a preset low-order integer scanning rule, so as to encapsulate these code statements and their code file names as a print file for printout. Compared with the existing method of manually retrieving code statements with low-order integer data in code files by developers, for example, retrieving code statements with 32-bit integer data. The code statements of the data, the automatic scanning and output function of the low-order integer data of the present application can save the time consumed by manual retrieval, greatly improve the development efficiency of developers, and the target low-order integer library can be customized and edited by the developer to adaptively scan out the code statements of the low-order integer data that the developer needs to scan in the code file, and then facilitate the developer to modify the low-order integer data in these code statements into high-order integer data, so that the application can meet the growing number of users of the platform and improve the application experience of the platform users, especially for platforms such as online live broadcast platforms with a large number of audience users and live broadcast users, which can greatly improve the experience of users of such platforms in using the application. BRIEF DESCRIPTION OF THE DRAWINGS

[0059] The above and / or additional aspects and advantages of the present application will become apparent and easily understood from the following description of the embodiments in conjunction with the accompanying drawings, in which:

[0060] Figure 1 A schematic diagram of a typical network deployment architecture related to implementing the technical solution of this application;

[0061] Figure 2 This is a flowchart of a typical embodiment of the integer code scanning method of the present application;

[0062] Figure 3 A flowchart diagram of a specific implementation method of calling a low-order integer variable scanner to scan a code file in this application;

[0063] Figure 4 A flowchart of a specific implementation method of calling a low-order integer attribute scanner to scan a code file in this application;

[0064] Figure 5 A flowchart of a specific implementation method of calling a low-order integer transformation scanner to scan a code file in this application;

[0065] Figure 6A flowchart diagram of a specific implementation method of calling a low-order integer container scanner to scan a code file in this application;

[0066] Figure 7 A flowchart of a specific implementation method for updating a print file in response to an erroneous print instruction in this application;

[0067] Figure 8 A flowchart diagram of a specific implementation method for updating a target low-order integer library in response to a data adding instruction in this application;

[0068] Fig. 9 This is a principle block diagram of a typical embodiment of an integer code scanning device of the present application;

[0069] Fig.10 This is a basic structural block diagram of a computer device according to an embodiment of the present application. DETAILED DESCRIPTION

[0070] The embodiments of the present application are described in detail below, and examples of the embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals throughout represent the same or similar elements or elements having the same or similar functions. The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain the present application, and cannot be interpreted as limiting the present application.

[0071] It will be understood by those skilled in the art that, unless expressly stated, the singular forms "one", "said", and "the" used herein may also include plural forms. It should be further understood that the term "comprising" used in the specification of the present application refers to the presence of the features, integers, steps, operations, elements and / or components, but does not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components and / or groups thereof. It should be understood that when we refer to an element as being "connected" or "coupled" to another element, it may be directly connected or coupled to the other element, or there may be an intermediate element. In addition, the "connection" or "coupling" used herein may include wireless connection or wireless coupling. The term "and / or" used herein includes all or any unit and all combinations of one or more associated listed items.

[0072] It will be understood by those skilled in the art that, unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as generally understood by those skilled in the art to which this application belongs. It should also be understood that terms such as those defined in common dictionaries should be understood to have meanings consistent with the meanings in the context of the prior art, and will not be interpreted with idealized or overly formal meanings unless specifically defined as here.

[0073] It will be understood by those skilled in the art that the "client", "terminal" and "terminal device" used herein include both devices with wireless signal receivers, which are devices with only wireless signal receivers without transmission capabilities, and devices with receiving and transmitting hardware, which are devices with receiving and transmitting hardware capable of two-way communication on a two-way communication link. Such devices may include: cellular or other communication devices such as personal computers, tablet computers, which have single-line displays or multi-line displays or cellular or other communication devices without multi-line displays; PCS (Personal Communications Service, personal communication system), which can combine voice, data processing, fax and / or data communication capabilities; PDA (Personal Digital Assistant, personal digital assistant), which may include a radio frequency receiver, pager, Internet / intranet access, web browser, notepad, calendar and / or GPS (Global Positioning System, global positioning system) receiver; traditional laptop and / or palmtop computers or other devices, which have and / or include radio frequency receivers. The "client", "terminal" and "terminal device" used herein may be portable, transportable, installed in a vehicle (air, sea and / or land), or suitable and / or configured to run locally, and / or in a distributed form, at any other location on the earth and / or in space. The "client", "terminal" and "terminal device" used herein may also be a communication terminal, an Internet terminal, a music / video playback terminal, such as a PDA, a MID (Mobile Internet Device) and / or a mobile phone with a music / video playback function, or a smart TV, a set-top box and other devices.

[0074] The hardware referred to by the names such as "server", "client", and "working node" in this application is essentially an electronic device with capabilities equivalent to those of a personal computer. It is a hardware device that has the necessary components revealed by the von Neumann principle, such as a central processing unit (including an arithmetic unit and a controller), a memory, an input device, and an output device. Computer programs are stored in its memory, and the central processing unit calls the program stored in the external memory into the internal memory for execution, executes the instructions in the program, and interacts with the input and output devices to complete specific functions.

[0075] It should be pointed out that the concept of "server" referred to in this application can also be extended to the case of server clusters. According to the network deployment principle understood by those skilled in the art, the servers should be logically divided. In physical space, these servers can be independent of each other but can be called through interfaces, or integrated into a physical computer or a set of computer clusters. Those skilled in the art should understand this flexibility, and should not use it to restrict the implementation of the network deployment method of this application.

[0076] See also Figure 1 , the hardware foundation required for the implementation of the relevant technical solutions of this application can be deployed according to the architecture shown in the figure. The server 80 referred to in this application is deployed in the cloud. As an online server, it can be responsible for further connecting relevant data servers and other servers that provide relevant support, etc., so as to form a logically related service cluster to provide services for relevant terminal devices such as the smartphone 81 and personal computer 82 shown in the figure or a third-party server (not shown). The smartphone and personal computer can access the Internet through a well-known network access method and establish a data communication link with the server 80 in the cloud to run terminal applications related to the services provided by the server.

[0077] For the server, the application is usually constructed as a service process, opening the corresponding program interface for remote calls by applications running on various terminal devices. The relevant technical solutions suitable for running on the server in this application can be implemented in the server in this way.

[0078] The application described herein refers to an application running on a server or terminal device. This application implements the relevant technical solutions of the present application in a programming manner. Its program code can be stored in a non-volatile storage medium recognizable by a computer in the form of computer executable instructions, and can be loaded into the memory by the central processing unit for execution. The relevant device of the present application is constructed by the operation of the application on the computer.

[0079] For the server, the application is usually constructed as a service process, opening the corresponding program interface for remote calls by applications running on various terminal devices. The relevant technical solutions suitable for running on the server in this application can be implemented in the server in this way.

[0080] Those skilled in the art should be aware that, although the various methods of the present application are described based on the same concept and thus present commonality to each other, unless otherwise specified, these methods can be independently executed. Similarly, for each embodiment disclosed in the present application, they are all proposed based on the same inventive concept, therefore, concepts with the same expression, and concepts that are appropriately changed for convenience despite different expressions, should be understood as equivalent.

[0081] See also Figure 2 , an integer code scanning method of the present application, in its typical embodiment, comprises the following steps:

[0082] Step S11, in response to a low-order integer scanning instruction acting on a code file set to be scanned, a target low-order integer library acting on the code file set to be scanned is obtained, wherein the target low-order integer library stores a plurality of low-order integer data:

[0083] The code file set to be scanned includes multiple code files, which generally work on the same application. Each code file contains a code statement for implementing a certain function of the application. Each code statement is edited by a high-level language, and some of the code statements have low-bit integer data to implement the corresponding function.

[0084] The target low-order integer library generally stores the target low-order integer data in the code file set, and the low-order integer data include low-order integer type data, low-order integer keyword data and low-order integer conversion data; wherein the low-order integer type data is generally an integer type of 32-bit integer data, for example, for a development environment of IOS (a mobile operating system developed by Apple), the 32-bit integer type data generally includes integer types such as int, int32_t, uint32_t, long, NSInteger or NSUInteger; the low-order integer keyword data is generally a keyword defined using the low-order integer type data, for example, for applications applied to flat The low-order integer keyword data is the unique identifier of the user of the platform. The low-order integer keyword data can be set to keywords such as uid, xx_uid, imid, aid, etc. The technical personnel in this field can flexibly design the low-order integer keyword data according to the actual application scenario; the low-order integer conversion data is generally a conversion method or conversion function for converting non-low-order integer data such as string type data, digital type data and character type data into low-order integer type data. For example, for the development program of IOS, the low-order integer conversion data generally includes intValue, integerValue, unsignerIntValue, unsignedIntegerValue, etc.

[0085] The low-order integer scanning instruction is used to trigger a low-order integer scanning process acting on the code file set to be scanned, so that the current device triggers the low-order integer scanning instruction, processes each code file in the code file set, scans out the code statements with the low-order integer data in each of the code files, and encapsulates these code statements as low-order integer code statements and the file names of their code files into print files for print output, so that developers can quickly determine the low-order integer code statements with low-order integer data in each of the code files by browsing the print files, and then modify these low-order integer code statements accordingly, and modify the low-order integer data to high-order integer data (such as 64-bit integer data) to solve the problem of insufficient data resources for unique user identification caused by the surge in users of the application platform.

[0086] The low-order integer scanning instruction can be pushed from the terminal where the developer is located to the server to drive the server to perform the low-order integer scanning processing of the code file set to be scanned, or trigger a response in the terminal for the developer to perform the low-order integer scanning processing of the code file set to be scanned.

[0087] Step S12, calling the preset low-order integer scanning rule, and scanning the low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library:

[0088] After the current device obtains the target low-order integer library, it calls the preset low-order integer scanning rule to scan each code file in the code files to be scanned to scan out the low-order integer code statements having the low-order integer data in these code files.

[0089] The low-order integer scanning rule has multiple scanners to respectively scan out the low-order integer code statements with low-order integer keyword data, low-order integer type data or low-order integer conversion data in the code file; the scanner generally includes a low-order integer variable scanner, a low-order integer attribute scanner, a low-order integer transformation scanner and a low-order integer output scanner, wherein the low-order integer variable scanner is used to scan out the low-order integer code statements that use the low-order integer keyword data to define variables in the code file, and the low-order integer attribute scanner is used to scan out the low-order integer code statements that use the low-order integer keyword data and the low-order integer type data to define attributes in the code file. The low-order integer type code statement is used to scan out the low-order integer code statements in the code file that use the low-order integer keyword data and the low-order integer type data transformation attributes, and scan out the low-order integer code statements in the code file that use the low-order integer keyword data and the low-order integer conversion data transformation attributes, and the low-order integer output scanner is used to scan out the low-order integer code statements in the code file that use the format specifier to specify any low-order integer keyword data for output; as described in step S11, the low-order integer type data, the low-order integer keyword data and the low-order integer conversion data are the low-order integer data possessed by the target low-order integer library.

[0090] When performing low-order integer scanning processing on the code file set to be scanned, the target low-order integer library can be modified in real time. Specifically, the current device responds to the data addition instruction acting on the target low-order integer library, obtains the low-order integer data corresponding to the data addition instruction, and stops the scanning processing acting on the current code file. After storing the low-order integer data in the target low-order integer library, the scanning processing acting on the current code file is restarted.

[0091] Step S13, encapsulating each of the low-order integer code statements and the corresponding code file name into print mapping data, and generating a print file containing each of the print mapping data for output:

[0092] After the current device scans the low-order integer code statements of each of the code files in the to-be-scanned code file set, the low-order integer code statements and the code file names of the code files to which they belong are packaged into the corresponding print mapping data.

[0093] The print mapping data is composed of any of the low-order integer code statements and the code file name of the code file. After the low-order integer code statements are scanned out from the code file to be scanned through the low-order integer scanning rule to generate the corresponding print mapping data, the print mapping data are encapsulated into the print file, and the print file is printed and output.

[0094] When the server is responsible for performing low-order integer scanning processing on the code file to be scanned, the print file is generally also generated by the server. After the server generates the print file, it pushes the print file to the terminal that pushes the low-order integer scanning instruction, so that the terminal prints the print file to its graphical user interface for output display for browsing by the developer at the terminal; if the terminal where the developer is located is responsible for performing low-order integer scanning processing on the code file to be scanned, the terminal generates the print file and prints it to its graphical user interface for output display.

[0095] In one embodiment, in addition to including the corresponding low-order integer code statements and the code file name of the code file, the print mapping data may also include the storage path of the code file, so that when the print mapping data is printed out and displayed to the terminal, the developer at the terminal can determine the storage location of the code file in the terminal, and then quickly make corresponding integer data modifications to the low-order integer code statements in the code file.

[0096] After the print file is printed out and displayed in the graphical user interface of the terminal, the developer at the terminal can manually review the print mapping data in the print file, and remove the code statements and their print mapping data that do not have low-order integer data from the print file. Specifically, in response to an erroneous print instruction triggered by the developer and acting on the print file, one or more print mapping data corresponding to the erroneous print instruction are determined, each of the print mapping data is removed from the print file, and then the print file with the print mapping data removed is reprinted and output to the graphical user interface for display.

[0097] It can be seen from the typical embodiments of the method that the method can automatically scan out the code statements with low-order integer data in each code file of the application, and print out the code statements with low-order integer data to the graphical user interface; by obtaining the code file set to be scanned and the target low-order integer library customized by the developer, the code statements with low-order integer data in the target low-order integer library in each code file in the code file set are scanned according to the preset low-order integer scanning rules, so as to encapsulate these code statements and their code file names as a print file for printout. Compared with the existing method of manually retrieving code statements with low-order integer data in code files by developers, the method can retrieve, for example, The method has a code statement with 32-bit integer data, and the automatic scanning and output function of low-order integer data can save the time consumed by manual retrieval, greatly improve the development efficiency of developers, and the target low-order integer library can be customized and edited by developers to adaptively scan out code statements with low-order integer data that developers need to scan in code files, thereby facilitating developers to modify the low-order integer data in these code statements into high-order integer data, so that the application can meet the growing number of users of the platform and improve the application experience of platform users, especially for platforms such as online live broadcast platforms with a large number of audience users and live broadcast users, which can greatly improve the experience of users of such platforms in using the application.

[0098] The above typical embodiments and their variations fully disclose the implementation scheme of the integer code scanning method of the present application. However, various variations of the method can still be derived by transforming and amplifying some technical means. Other embodiments are briefly described as follows:

[0099] In one embodiment, please refer to Figure 3 The step of calling a preset low-order integer scanning algorithm and scanning out the low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library comprises the following steps:

[0100] Step S121, calling a low-order integer variable scanner to scan the current code text to be scanned in the code file set to be scanned:

[0101] The low-order integer variable scanner is used to scan out code statements in a code file that use low-order integer keyword data in a target low-order integer library to define variables. The low-order integer variable scanner has a variable matching algorithm to scan out code statements that use the low-order integer keyword data.

[0102] Step S122, obtaining multiple low-order integer keyword data in the target low-order integer library:

[0103] The target low-order integer library is provided with each of the low-order integer keyword data so as to scan out a code statement that uses any of the low-order integer keyword data to define a variable from a current code file.

[0104] Step S123, according to the variable matching algorithm of the low-order integer variable scanner, scan out the code statements in the current code file that use any of the low-order integer keyword data to define variables:

[0105] The regular expression of the variable matching algorithm is as follows:

[0106] [a-zA-Z_0-9]* +[a-zA-Z_]*uidKey[a-zA-Z_]* *=

[0107] Among them, "uidKey" refers to the low-order integer keyword data possessed by the target low-order integer library. The regular expression matches the code statement with the variable name "uidKey" in the code file, and uses "=" to represent the use of "uidKey" for assignment in the matched code statement. Each of the low-order integer keyword data obtained from the target low-order integer library is assigned to "uidKey" for matching, so as to traverse each of the low-order integer keyword data, and then scan out the code statement in the current code file that uses any of the low-order integer keyword data to define a variable; the code statements matched by the variable matching algorithm are generally as follows:

[0108] int uid = xxx; Extra space version: int uid = xxx;

[0109] Among them, uid is the low-order integer keyword data, namely "uidKey".

[0110] In this embodiment, a low-order integer variable scanner is used to scan out code statements in a code file that use low-order integer keyword data in a target low-order integer library to define variables, so that these code statements are printed out as low-order integer code statements, thereby improving the developer's integer modification efficiency without the need for manual retrieval by the developer.

[0111] In one embodiment, please refer to Figure 4 The step of calling a preset low-order integer scanning algorithm and scanning out the low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library comprises the following steps:

[0112] Step S121', calling a low-order integer attribute scanner to scan the current code text to be scanned in the code file set to be scanned:

[0113] The low-order integer attribute scanner is used to scan out the code statements in the current code text that use the integer keyword data and low-order integer type data in the target low-order integer library to define attributes, and the low-order integer attribute scanner has an attribute matching algorithm to match the code statements that use the integer keyword data and low-order integer type data to define attributes.

[0114] Step S122', obtaining a plurality of low-order integer keyword data and low-order integer type data in the target low-order integer library:

[0115] The low-order integer keyword data and low-order integer type data in the target low-order integer library are obtained to scan out a code statement that uses any of the low-order integer keyword data and low-order integer type data to define an attribute from a current code file.

[0116] Step S123', according to the attribute matching algorithm of the low-order integer attribute scanner, scan out the code statements in the current code file that use any of the low-order integer keyword data and low-order integer type data to define attributes:

[0117] The regular expression of the attribute matching algorithm is as follows:

[0118] Sub-regular expression a: [a-zA-Z_]*uidKey[a-zA-Z_]*; Sub-regular expression b: intType +uidKey;

[0119] Among them, "uidKey" refers to the low-order integer keyword data of the target low-order integer library, and "intType" refers to the low-order integer type data of the target low-order integer library. When using sub-regular expression a and sub-regular expression b, each of the low-order integer keyword data and low-order integer type data will be traversed to replace the "uidKey" and "intType" for matching. First, sub-regular expression a is used to match the code statement with "uidKey" as the variable name, and then sub-regular expression b is used to determine whether "intType" is used to define the variable "uidKey" in the code statement. If so, it indicates that the code statement is a code statement that uses the low-order integer keyword data and low-order integer type data to define attributes. The code statements matched by the attribute matching algorithm are generally as follows:

[0120] int _uid;@property(nonatomic, assign) int xxUid;int uid; Version with extra spaces: int uid;

[0121] @property(nonatomic, assign) int xxUid;

[0122] Among them, "xxUid" and "uid" are both the low-order integer keyword data, and "int" is the low-order integer type data.

[0123] In this embodiment, a low-order integer attribute scanner is used to scan out code statements in a code file that use integer keyword data and low-order integer type data definition attributes in the target low-order integer library, so that these code statements are printed out as low-order integer code statements, thereby improving the integer modification efficiency of developers without the need for developers to perform manual retrieval.

[0124] In one embodiment, please refer to Figure 5 , calling a preset low-order integer scanning algorithm, wherein the step of calling the preset low-order integer scanning algorithm and scanning out the low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library comprises the following steps:

[0125] Step S121'', calling a low-order integer transformation scanner to scan the current code text that needs to be scanned in the code file set to be scanned:

[0126] The low-order integer transformation scanner is used to scan out the code statements in the current code text that use the low-order integer keyword data or the low-order integer type data transformation attributes in the target low-order integer library, and the code statements that use the low-order integer keyword data and the low-order integer conversion data transformation attributes in the target low-order integer library, and the low-order integer transformation scanner has a first transformation matching algorithm and a second transformation matching algorithm to respectively match the code statements that use the low-order integer keyword data or the low-order integer type data transformation attributes and the code statements that use the low-order integer keyword data and the low-order integer conversion data transformation attributes in the target low-order integer library.

[0127] Step S122'', obtaining a plurality of low-order integer keyword data, low-order integer type data and low-order integer conversion data in the target low-order integer library:

[0128] Obtain each of the low-order integer keyword data, low-order integer type data and low-order integer conversion data in the target low-order integer library, so as to scan out from the current code file the code statements that use any of the low-order integer keyword data and low-order integer type data to define attributes, and the code statements that use any of the low-order integer keyword data and low-order integer conversion data to transform attributes.

[0129] Step S123'', according to the first transformation matching algorithm of the low-order integer transformation scanner, scan out the code statements using any of the low-order integer keyword data or low-order integer type data transformation attributes in the current code file:

[0130] The first transformation matching algorithm has three types of regular expressions, where the first regular expression is:

[0131] = *\([a-zA-Z0-9_]*\) *[a-zA-Z\.]*uidKey[a-zA-Z\.]*;

[0132] Among them, "uidKey" refers to the low-order integer keyword data of the target low-order integer library. When the first regular expression is used, each low-order integer keyword data will be traversed to replace the "uidKey" for matching. When there are "=" and "( )" in the code statement, and there are characters in "( )", and there is "uidKey" after "( )", it indicates that the code statement is a code statement using the transformation attribute of the low-order integer keyword data. The code statements matched by the first regular expression are as follows:

[0133] replyInfo.targetId = (uint32_t)message.inviteeUserInfo.uid; notifyInfo.targetId = (uint32_t)myUid; Extra space version: notifyInfo.targetId = (uint32_t) myUid;

[0134] Among them, "myUid" and "uid" are both the low-order integer keyword data, and "uint32_t" is the low-order integer type data.

[0135] The second regular expression of the first transformation matching algorithm is:

[0136] Sub-regular expression a:: *\([a-zA-Z0-9_]*\) *[a-zA-Z_]*uidKey[a-zA-Z_]*Sub-regular expression b: \(intType\) +uidKey;

[0137] Among them, "uidKey" refers to the low-order integer keyword data possessed by the target low-order integer library, and "intType" refers to the low-order integer type data possessed by the target low-order integer library. When using sub-regular expressions a and b, each of the low-order integer keyword data and low-order integer type data will be traversed to replace the "uidKey" and "intType" for matching. First, expression a is used to match the code statement with ":" and "uidKey" after the ":". Sub-regular expression b is used to determine whether the code statement uses "( )" and "intType" exists in "( )", and has "uidKey" after "(intType)". If so, the code statement is a code statement that uses the low-order integer keyword data and the transformation attribute of the low-order integer type data. The code statement matched by the second regular expression is as follows:

[0138] -(void)xxxxx:(int)uid xxx:(int)anchorUid yyyy:(int)reportUid;[selfxxx:(int)rUid yyy:(int)xxUid hhh:(int)anchorUid];

[0139] Among them, "reportUid" and "anchorUid" are both the low-order integer keyword data, and "int" is the low-order integer type data.

[0140] The third regular expression of the first transformation matching algorithm is:

[0141] Sub-regular expression a: = *\([a-zA-Z0-9_]*\)\[.* [a-zA-Z_]*uidKey[a-zA-Z_]*\] Sub-regular expression b: \(intType\)

[0142] Among them, "uidKey" refers to the low-order integer keyword data possessed by the target low-order integer library, and "intType" refers to the low-order integer type data possessed by the target low-order integer library. When using sub-regular expressions a and b, each of the low-order integer keyword data and low-order integer type data will be traversed to replace the "uidKey" and "intType" for matching. First, expression a is used to match the code statement with "=" and "uidKey" after "=". The sub-regular expression b is used to determine whether the code statement uses "()" and "intType" in "()". If it exists, the code statement is a code statement that uses the low-order integer keyword data and the transformation attribute of the low-order integer type data. The code statement matched by the third regular expression is as follows:

[0143] self.uid = (uint32_t)[YYGetCoreI(IAuthCore) getUserId]; self.uid = (uint32_t)[xxx anchorId];

[0144] Among them, "getUserId" and "anchorUid" are both the low-order integer keyword data, and "uint32_t" is the low-order integer type data.

[0145] Step S124'', according to the second transformation matching algorithm of the low-order integer transformation scanner, scan out the code statements using any of the low-order integer keyword data and the low-order integer conversion data transformation attributes in the current code file:

[0146] The regular expression of the first transformation matching algorithm is:

[0147] Sub-regular expression a: [a-zA-Z_]*uidKey[a-zA-Z_]*Sub-regular expression b: uidKeyvalueType

[0148] Subregular expression c:uidKey\.valueType

[0149] Among them, "uidKey" refers to the low-order integer keyword data possessed by the target low-order integer library, and "valueType" refers to the low-order integer conversion data possessed by the target low-order integer library. When using sub-regular expression a and sub-regular expression b, each of the low-order integer keyword data and low-order integer conversion data will be traversed to replace the "uidKey" and "valueType" for matching. First, sub-regular expression a is used to match the code statement with the variable name "uidKey", and then sub-regular expression b or sub-regular expression c is used to match whether "uidKey" and "valueType" exist in the code statement. For sub-regular expression b, code statements with space characters in "uidKey" and "valueType" can be matched. For sub-regular expression c, code statements with "." characters in "uidKey" and "valueType" can be matched. The code statements matched by the third regular expression are as follows:

[0150] long long uid = self.xxUid.intValue; long long uid =[self.obj.xxx.anchorUid intValue];

[0151] Among them, "xxUid" and "anchorUid" are both the low-order integer keyword data, and "intValue" is the low-order integer conversion data.

[0152] In this embodiment, a low-order integer transformation scanner is used to scan out code statements in a code file that use the low-order integer keyword data or low-order integer type data transformation attributes in the target low-order integer library, as well as code statements that use the low-order integer keyword data and low-order integer conversion data transformation attributes in the target low-order integer library, so that these code statements are printed out as low-order integer code statements, thereby improving the integer modification efficiency of developers without the need for developers to perform manual retrieval.

[0153] In one embodiment, please refer to Figure 6 The step of calling a preset low-order integer scanning algorithm and scanning out the low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library comprises the following steps:

[0154] Step S121''', calling the low-order integer container scanner to scan the current code text that needs to be scanned in the code file set to be scanned:

[0155] The low-order integer container scanner is used to scan out code statements in a code file that use low-order integer keyword data in a target low-order integer library to define a container. The low-order integer container scanner has a container matching algorithm to scan out code statements that use the low-order integer keyword data.

[0156] Step S122''', obtaining multiple low-order integer keyword data in the target low-order integer library:

[0157] The target low-order integer library is provided with each of the low-order integer keyword data so as to scan out a code statement that uses any of the low-order integer keyword data to define a container from the current code file.

[0158] Step S123''', according to the container matching algorithm of the low-order integer container scanner, scan out the code statements in the current code file that use the low-order integer keyword data to define the container:

[0159] The regular expressions related to the container matching algorithm are as follows:

[0160] Sub-regular expression a: <.+> *[0-9a-zA-Z_]+ Sub-regular expression b: <.+> *[0-9a-zA-Z_]*uidKey[0-9a-zA-Z_]*

[0161] Among them, the sub-regular expression a can match the existence of angle brackets: <xxx>yyy, the string starts to match from the left angle bracket of the code statement, and also matches the variable name defined in "< >". Then, the sub-regular expression b is used to continue matching based on the matching result of expression a to determine whether the low-order integer keyword data "uidKey" is included after "< >". For example, the code statement that can be matched to define the container using the low-order integer keyword data is as follows:

[0162] map<string, uint32_t> anchorList; set<uint32_t> uids;list<uint32_t> uidlist;

[0163] Among them, "anchorList", "uids" and "uidlist" are all low-order integer keyword data in the target low-order integer library.

[0164] In this embodiment, a low-order integer container scanner is used to scan out code statements in a code file that use the low-order integer keyword data in the target low-order integer library to define a container, so that these code statements are printed out as low-order integer code statements, thereby improving the integer modification efficiency of developers without the need for developers to perform manual retrieval.

[0165] In one embodiment, please refer to Figure 7 , after the step of generating a print file containing each of the print mapping data for output, the following steps are included:

[0166] Step S14, in response to the erroneous printing instruction acting on the print file, determining one or more print mapping data corresponding to the erroneous printing instruction:

[0167] The error printing instruction is generally triggered by the terminal that outputs the print file. The developer at the terminal manually verifies and reviews the print mapping data in the print file displayed on the graphical user interface. When a code statement that does not have the low-bit transformation data is found, the error printing instruction acting on the print mapping data to which the code statement belongs can be triggered, so that the server or terminal that generates the print file responds to the error printing instruction and removes the print mapping data from the print file.

[0168] Step S15, removing each of the print mapping data from the print file to update the print file:

[0169] The current device having the print file determines one or more print mapping data corresponding to the erroneous print instruction, and removes the print mapping data from the print file to perform a removal update process for the print file.

[0170] Step S16, reprinting the updated print file for output:

[0171] If the current device is the terminal where the developer is located, the print file that has completed the removal of the print mapping data will be reprinted and output to the graphical user interface for display; if the current device is a server, the server will push the print file that has completed the removal of the print mapping data to the terminal that pushed the erroneous printing instruction, so that the terminal will reprint the print file and output it to the graphical user interface for display.

[0172] In this embodiment, by implementing the function of removing erroneous print mapping data, developers can review the print files and remove erroneous low-order integer code statements, preventing erroneous low-order integer code statements in the print files from misleading other developers and affecting development efficiency.

[0173] In one embodiment, please refer to Figure 8 , the method comprises the following synchronization steps:

[0174] Step S14', responding to the data adding instruction acting on the target low-order integer library, obtaining the low-order integer data corresponding to the data adding instruction:

[0175] The data adding instruction is generally triggered by printing the print file to a terminal of a graphical user interface, so as to add the low-order integer data newly edited or defined by the developer at the terminal to the target low-order integer library.

[0176] The current device responds to the data adding instruction and obtains the low-order integer data included in the data adding instruction.

[0177] Step S15', stop the scanning process acting on the current code file, and store the low-order integer data in the target low-order integer library:

[0178] If the current device is performing scanning processing on the low-order integer data of any code file in the code file set to be scanned, the scanning processing on the code file will be stopped, and the low-order integer data corresponding to the data addition instruction will be stored in the target low-order integer library; by stopping the scanning processing on the current code file and then updating the target low-order integer library, the scanning processing is prevented from being affected.

[0179] Step S16', after storing the low-order integer data in the target low-order integer library, restart the scanning process acting on the current code file:

[0180] After the current device stores the low-order integer data corresponding to the data adding instruction into the target low-order integer library, it restarts the scanning process on the current code file to re-scan the code file using the low-order integer data.

[0181] In this embodiment, the low-order integer data corresponding to the data addition instruction is stored in the target low-order integer library to update the low-order integer data, so that the developer can adjust the low-order integer data stored in the target low-order integer library, and the code file is rescanned based on the latest low-order integer data to ensure the real-time data of the output print file.

[0182] Furthermore, by functionalizing each step in the method disclosed in the above embodiments, an integer code scanning device of the present application can be constructed. According to this idea, please refer to Fig. 9 In a typical embodiment, the device includes: a scanning instruction response module 11, which is used to respond to a low-order integer scanning instruction acting on a code file set to be scanned, and obtain a target low-order integer library acting on the code file set to be scanned, wherein the target low-order integer library stores a plurality of low-order integer data; a code file scanning module 12, which is used to call a preset low-order integer scanning rule, and scan out low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library; a print file output module 13, which is used to encapsulate each of the low-order integer code statements and its corresponding code file name into print mapping data, and generate a print file containing each of the print mapping data for output.

[0183] In one embodiment, the code file scanning module 12 includes: a variable scanner calling submodule, used to call a low-order integer variable scanner to scan the current code text that needs to be scanned in the code file set to be scanned; a low-order integer data acquisition submodule, used to obtain multiple low-order integer keyword data in the target low-order integer library; a variable code statement scanning submodule, used to scan out the code statement that uses any of the low-order integer keyword data to define variables in the current code file according to the variable matching algorithm of the low-order integer variable scanner.

[0184] In another embodiment, the code file scanning module 12 also includes: an attribute scanner calling submodule, used to call a low-order integer attribute scanner to scan the current code text that currently needs to be scanned in the code file set to be scanned; a low-order integer data acquisition submodule, used to obtain multiple low-order integer keyword data and low-order integer type data in the target low-order integer library; an attribute code statement scanning submodule, used to scan out the code statement in the current code file that uses any of the low-order integer keyword data and low-order integer type data to define attributes according to the attribute matching algorithm of the low-order integer attribute scanner.

[0185] In another embodiment, the code file scanning module 12 also includes: a transformation scanner calling submodule, which is used to call a low-order integer transformation scanner to scan the current code text that needs to be scanned in the code file set to be scanned; a low-order integer data acquisition submodule, which acquires multiple low-order integer keyword data, low-order integer type data and low-order integer conversion data in the target low-order integer library; a first transformation statement scanning submodule, which is used to scan out the code statements in the current code file that use any of the low-order integer keyword data or low-order integer type data transformation attributes according to the first transformation matching algorithm of the low-order integer transformation scanner; a second transformation statement scanning submodule, which is used to scan out the code statements in the current code file that use any of the low-order integer keyword data and low-order integer conversion data transformation attributes according to the second transformation matching algorithm of the low-order integer transformation scanner.

[0186] In another embodiment, the code file scanning module 12 also includes: a container scanner calling submodule, used to call a low-order integer container scanner to scan the current code text that currently needs to be scanned in the code file set to be scanned; a low-order integer data acquisition submodule, used to acquire multiple low-order integer keyword data in the target low-order integer library; a container code statement scanning submodule, used to scan out the code statement in the current code file that uses the low-order integer keyword data to define the container according to the container matching algorithm of the low-order integer container scanner.

[0187] In order to solve the above technical problems, the embodiment of the present application also provides a computer device for running a computer program implemented according to the integer code scanning method. Fig.10 , Fig.10 This is a basic structural block diagram of the computer device in this embodiment.

[0188] like Fig.10 As shown, a schematic diagram of the internal structure of a computer device. The computer device includes a processor, a non-volatile storage medium, a memory, and a network interface connected via a system bus. Among them, the non-volatile storage medium of the computer device stores an operating system, a database, and computer-readable instructions. The database may store a control information sequence. When the computer-readable instructions are executed by the processor, the processor can implement an integer code scanning method. The processor of the computer device is used to provide computing and control capabilities to support the operation of the entire computer device. The memory of the computer device may store computer-readable instructions. When the computer-readable instructions are executed by the processor, the processor can execute an integer code scanning method. The network interface of the computer device is used to connect and communicate with a terminal. Those skilled in the art can understand that Fig.10 The structure shown in the figure is only a block diagram of a part of the structure related to the solution of the present application, and does not constitute a limitation on the computer device to which the solution of the present application is applied. The specific computer device may include more or fewer components than those shown in the figure, or combine certain components, or have a different arrangement of components.

[0189] In this embodiment, the processor is used to execute the specific functions of each module / submodule in the integer code scanning device of the present application, and the memory stores the program code and various data required to execute the above modules. The network interface is used to transmit data between user terminals or servers. The memory in this embodiment stores the program code and data required to execute all modules / submodules in the integer code scanning device, and the server can call the program code and data of the server to execute the functions of all submodules.

[0190] The present application also provides a non-volatile storage medium, wherein the integer code scanning method is written into a computer program and stored in the storage medium in the form of computer-readable instructions. When the computer-readable instructions are executed by one or more processors, it means that the program is run in the computer, thereby causing one or more processors to execute the steps of the integer code scanning method of any of the above-mentioned embodiments.

[0191] Those skilled in the art can understand that all or part of the processes in the above-mentioned embodiments can be implemented by instructing the relevant hardware through a computer program, and the computer program can be stored in a computer-readable storage medium. When the program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, the aforementioned storage medium can be a non-volatile storage medium such as a disk, an optical disk, a read-only memory (ROM), or a random access memory (RAM).

[0192] In summary, the present application can efficiently scan out code statements with low-order integer data in a code file to print them out, replacing manual code retrieval, and effectively improving the development and repair efficiency of the application.

[0193] It should be understood that, although the steps in the flowchart of the accompanying drawings are displayed in sequence as indicated by the arrows, these steps are not necessarily executed in sequence in the order indicated by the arrows. Unless otherwise specified herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least a part of the steps in the flowchart of the accompanying drawings may include multiple sub-steps or multiple stages, and these sub-steps or stages are not necessarily executed at the same time, but can be executed at different times, and their execution order is not necessarily sequential, but can be executed in turn or alternately with other steps or at least a part of the sub-steps or stages of other steps.

[0194] Those skilled in the art will appreciate that the various operations, methods, steps, measures, and schemes in the processes discussed in this application may be alternated, altered, combined, or deleted. Further, other steps, measures, and schemes in the various operations, methods, and processes discussed in this application may also be alternated, altered, rearranged, decomposed, combined, or deleted. Further, the steps, measures, and schemes in the prior art that are similar to those disclosed in this application may also be alternated, altered, rearranged, decomposed, combined, or deleted.

[0195] The above description is only a partial implementation method of the present application. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principles of the present application. These improvements and modifications should also be regarded as the scope of protection of the present application.< / xxx>

Claims

1. A method for scanning an integer code, characterized in that: The steps include: In response to a low-order integer scanning instruction acting on a code file set to be scanned, a target low-order integer library acting on the code file set to be scanned is obtained, wherein the target low-order integer library stores a plurality of low-order integer data, wherein the low-order integer data includes low-order integer type data, low-order integer keyword data and low-order integer conversion data, wherein the low-order integer keyword data is a keyword defined using the low-order integer type data; and the low-order integer conversion data is a conversion method or a conversion function for converting non-low-order integer data into low-order integer type data; Calling a preset low-order integer scanning rule, and scanning the low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library; Encapsulating each of the low-order integer code statements and its corresponding code file name into print mapping data, and generating a print file containing each of the print mapping data for output; The calling of the preset low-order integer scanning rule and scanning the low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library include: Calling a low-order integer variable scanner to scan the current code text to be scanned in the code file set to be scanned; obtaining multiple low-order integer keyword data in the target low-order integer library; and scanning the code statement in the current code file that uses any of the low-order integer keyword data to define a variable according to the variable matching algorithm of the low-order integer variable scanner; Calling a low-order integer attribute scanner to scan the current code text that needs to be scanned in the code file set to be scanned; obtaining multiple low-order integer keyword data and low-order integer type data in the target low-order integer library; and scanning the code statement that uses any of the low-order integer keyword data and low-order integer type data to define attributes in the current code file according to the attribute matching algorithm of the low-order integer attribute scanner; A low-order integer transformation scanner is called to scan the current code text that needs to be scanned in the set of code files to be scanned; a plurality of low-order integer keyword data, low-order integer type data and low-order integer conversion data in the target low-order integer library are obtained; according to a first transformation matching algorithm of the low-order integer transformation scanner, code statements that use any of the low-order integer keyword data or low-order integer type data transformation attributes in the current code file are scanned; according to a second transformation matching algorithm of the low-order integer transformation scanner, code statements that use any of the low-order integer keyword data and low-order integer conversion data transformation attributes in the current code file are scanned.

2. The method according to claim 1, characterized in that After the step of generating a print file containing each of the print mapping data for output, the following steps are included: In response to an erroneous printing instruction acting on the print file, determining one or more print mapping data corresponding to the erroneous printing instruction; removing each of the print mapping data from the print file to update the print file; Reprinting will complete the updated print file output.

3. The method according to claim 1, characterized in that The method includes the following synchronization steps: In response to a data adding instruction acting on the target low-order integer library, obtaining low-order integer data corresponding to the data adding instruction; Stop the scanning process acting on the current code file, and store the low-order integer data in the target low-order integer library; After the low-order integer data is stored in the target low-order integer library, the scanning process acting on the current code file is restarted.

4. The method according to claim 1, characterized in that: The low-order integer scanning instruction is pushed from the terminal to the server to drive the server to execute the low-order integer scanning processing of the code file set to be scanned, or trigger a response in the terminal, and the terminal executes the low-order integer scanning processing of the code file set to be scanned.

5. An integer code scanning device, characterized in that: include: A scanning instruction response module, used for responding to a low-order integer scanning instruction acting on a code file set to be scanned, obtaining a target low-order integer library acting on the code file set to be scanned, wherein the target low-order integer library stores a plurality of low-order integer data, wherein the low-order integer data includes low-order integer type data, low-order integer keyword data and low-order integer conversion data, wherein the low-order integer keyword data is a keyword defined using the low-order integer type data; the low-order integer conversion data is a conversion method or conversion function for converting non-low-order integer data into low-order integer type data; A code file scanning module, used for calling a preset low-order integer scanning rule, and scanning the low-order integer code statements having the low-order integer data in each code file of the code file set to be scanned according to the target low-order integer library; A print file output module, used for encapsulating each of the low-order integer code statements and its corresponding code file name into print mapping data, and generating a print file containing each of the print mapping data for output; The code file scanning module is specifically used to: call a low-order integer variable scanner to scan the current code text that needs to be scanned in the code file set to be scanned; obtain multiple low-order integer keyword data in the target low-order integer library; According to the variable matching algorithm of the low-order integer variable scanner, a code statement that uses any of the low-order integer keyword data to define a variable in the current code file is scanned; The code file scanning module is specifically used to: call a low-order integer attribute scanner to scan the current code text that needs to be scanned in the code file set to be scanned; obtain multiple low-order integer keyword data and low-order integer type data in the target low-order integer library; and scan out the code statement that uses any of the low-order integer keyword data and low-order integer type data to define attributes in the current code file according to the attribute matching algorithm of the low-order integer attribute scanner; The code file scanning module is specifically used to: call a low-order integer transformation scanner to scan the current code text that needs to be scanned in the code file set to be scanned; obtain multiple low-order integer keyword data, low-order integer type data and low-order integer conversion data in the target low-order integer library; according to the first transformation matching algorithm of the low-order integer transformation scanner, scan out the code statements in the current code file that use any of the low-order integer keyword data or low-order integer type data transformation attributes; according to the second transformation matching algorithm of the low-order integer transformation scanner, scan out the code statements in the current code file that use any of the low-order integer keyword data and low-order integer conversion data transformation attributes.

6. The device according to claim 5, characterized in that: The low-order integer scanning instruction is pushed from the terminal to the server to drive the server to execute the low-order integer scanning processing of the code file set to be scanned, or trigger a response in the terminal, and the terminal executes the low-order integer scanning processing of the code file set to be scanned.

7. The device according to claim 5, characterized in that After the print file output module is run, it includes: In response to an erroneous printing instruction acting on the print file, determining one or more print mapping data corresponding to the erroneous printing instruction; removing each of the print mapping data from the print file to update the print file; Reprinting will complete the updated print file output.

8. The device according to claim 5, characterized in that Also includes: In response to a data adding instruction acting on the target low-order integer library, obtaining low-order integer data corresponding to the data adding instruction; Stop the scanning process acting on the current code file, and store the low-order integer data in the target low-order integer library; After the low-order integer data is stored in the target low-order integer library, the scanning process acting on the current code file is restarted.

9. An electronic device, comprising a central processing unit and a memory, characterized in that: The central processing unit is used to call and run a computer program stored in the memory to execute the steps of the method according to any one of claims 1 to 4.

10. A non-volatile storage medium, characterized in that: The computer program implemented according to the method described in any one of claims 1 to 4 is stored in the form of computer-readable instructions, and when the computer program is called and executed by a computer, the steps included in the method are executed.

Images