同步操作将从 OpenHarmony/docs 强制同步,此操作会覆盖自 Fork 仓库以来所做的任何修改,且无法恢复!!!
确定后同步将在后台操作,完成时将刷新页面,请耐心等待。
HCS is the source code that describes the configuration of the HDF using key-value pairs. It decouples the configuration code from driver code, thereby facilitating configuration management.
HDF Configuration Generator (HC-GEN) is a tool for converting a configuration file into a file that can be read by the target software.
The following figure shows the typical application scenario of the HCB mode.
The HCS is compiled using the HC-GEN tool to generate an HCB file. The HCS Parser module in the HDF recreates a configuration tree using the HCB file. Then, the HDF driver modules obtain the configurations using the API provided by the HCS Paser.
The HCS syntax is described as follows:
The keywords listed in the following table below are reserved for HCS configuration files.
Table 1 Reserved keywords for HCS configuration files
This keyword applies only to the configuration tree imported using the include keyword. |
||
During configuration parsing, the keyword value can be used to find the corresponding node. |
The HCS configuration file consists of configurations of attributes and nodes.
Attributes
An attribute, as the minimum configuration unit, is an independent configuration item. Its syntax is as follows:
attribute_name = value;
The value of attribute_name is a case-sensitive string of characters starting with a letter and consisting of letters, digits, and underscores (_).
Available formats of value are as follows:
A binary, octal, decimal, or hexadecimal integer. For details, see Data Types.
A character string. The content should be enclosed in double quotation marks (" ").
A node reference
An attribute key-value pair must end with a semicolon (;) and belong to a node.
Nodes
A node is a set of attributes. Its syntax is as follows:
node_name {
module = "sample";
...
}
The value of node_name is a case-sensitive string of characters starting with a letter and consisting of letters, digits, and underscores (_).
A semicolon (;) is not required after the curly brace (}).
The reserved keyword root is used to declare the root node of a configuration table.
The root node must contain a module attribute that uses a string to represent the module to which the configuration belongs.
The match_attr attribute can be added to a node. Its value is a globally unique character string. During configuration parsing, the query interface can be invoked to query the nodes with the attribute based on the attribute value.
Attributes automatically use built-in data types, including integers, strings, arrays, and booleans. You do not need to explicitly specify the data type for the attribute values.
Integer
An integer can be binary, octal, decimal, or hexadecimal. The minimum space is automatically allocated to the integer based on the actual data length.
Binary: prefixed with 0b, for example, 0b1010
Octal: prefixed with 0, for example, 0664
Decimal: either signed or unsigned, without a prefix, for example, 1024 or +1024. Negative integers can be read only via signed interfaces.
Hexadecimal: prefixed with 0x, for example, 0xff00 and 0xFF
String
A string is enclosed by double quotation marks (" ").
Array
The elements in an array can be integers or strings, but cannot be a combination of both. The combination of uint32_t and uint64_t in an integer array will enable up-casting to uint64. The following is an example of an integer array and a string array:
attr_foo = [0x01, 0x02, 0x03, 0x04];
attr_bar = ["hello", "world"];
Boolean
A Boolean data type has two possible values: true and false.
include
The include keyword is used to import other HCS files. The syntax is as follows:
#include "foo.hcs"
#include "../bar.hcs"
Comments can be formatted as follows:
Single-line comment
// comment
Multi-line comment
/*
comment
*/
NOTE: Multi-line comments cannot be nested.
You can use the following syntax to modify the content of any other node:
node :& source_node
This syntax indicates that the node value is a modification of the source_node value. Example:
root {
module = "sample";
foo {
foo_ :& root.bar{
attr = "foo";
}
foo1 :& foo2 {
attr = 0x2;
}
foo2 {
attr = 0x1;
}
}
bar {
attr = "bar";
}
}
The following configuration tree is generated:
root {
module = "sample";
foo {
foo2 {
attr = 0x2;
}
}
bar {
attr = "foo";
}
}
In the preceding example, the foo.foo_ node changes the value of the referenced bar.attr to "foo", and the foo.foo1 node changes the value of the referenced foo.foo2.attr to 0x2. In the generated configuration tree, foo.foo_ and foo.foo1 are not displayed, but their configuration modifications are presented by their referenced nodes.
The content of a node can be replicated to another node to define the node with similar content. The syntax is as follows:
node : source_node
The preceding statement indicates that the attributes of source_node are replicated to node. Example:
root {
module = "sample";
foo {
attr_0 = 0x0;
}
bar:foo {
attr_1 = 0x1;
}
}
The following configuration tree is generated:
root {
module = "sample";
foo {
attr_0 = 0x0;
}
bar {
attr_1 = 0x1;
attr_0 = 0x0;
}
}
In the preceding example, the bar node configuration includes both the attr_0 and attr_1 values. The modification to attr_0 in the bar node does not affect the foo node.
The path of the foo node is not required if the foo node and the bar node are of the same level. Otherwise, the absolute path must be used. For details, see Modifying a Reference.
You can use the keyword delete to delete unnecessary nodes or attributes in the base configuration tree imported by the include keyword. In the following example, sample1.hcs imports the configuration of sample2.hcs using include, and deletes the attribute2 attribute and the foo_2 node using the delete keyword.
// sample2.hcs
root {
attr_1 = 0x1;
attr_2 = 0x2;
foo_2 {
t = 0x1;
}
}
// sample1.hcs
#include "sample2.hcs"
root {
attr_2 = delete;
foo_2 : delete {
}
}
The following configuration tree is generated:
root {
attr_1 = 0x1;
}
NOTE: The delete keyword cannot be used in the same HCS file. It is recommended that you delete unnecessary attributes directly from the configuration source code.
To quickly locate the associated node during configuration parsing, you can use the node as the value of the attribute and read the attribute to find the corresponding node. The syntax is as follows:
attribute = &node;
This syntax indicates that the attribute value is a reference to node. During code parsing, you can quickly locate the node using this attribute. Example:
node1 {
attributes;
}
node2 {
attr_1 = &node1;
}
The template keyword is used to generate nodes with strictly consistent syntax, thereby facilitating the traverse and management of nodes of the same type.
If a node is defined using the keyword template, its child nodes inherit the node configuration through the double colon operator (::). The child nodes can modify but cannot add or delete attributes in template. The attributes not defined in the child nodes will use the attributes defined in template as the default values. Example:
root {
module = "sample";
template foo {
attr_1 = 0x1;
attr_2 = 0x2;
}
bar :: foo {
}
bar_1 :: foo {
attr_1 = 0x2;
}
}
The following configuration tree is generated:
root {
module = "sample";
bar {
attr_1 = 0x1;
attr_2 = 0x2;
}
bar_1 {
attr_1 = 0x2;
attr_2 = 0x2;
}
}
In the preceding example, the bar and bar_1 nodes inherit the foo node. The structures of the generated configuration tree nodes are the same as that of the foo node, but the attribute values are different.
The HC-GEN tool is used to generate configurations. It checks the HCS configuration syntax and converts HCS source files into HCB files.
Parameter description:
Usage: hc-gen [Options] [File]
options:
-o <file> output file name, default same as input
-a hcb align with four bytes
-b output binary output, default enable
-t output config in C language source file style
-i output binary hex dump in C language source file style
-p <prefix> prefix of generated symbol name
-d decompile hcb to hcs
-V show verbose info
-v show version
-h show this help message
Generate a .c or .h configuration file.
hc-gen -o [OutputCFileName] -t [SourceHcsFileName]
Generate an HCB file.
hc-gen -o [OutputHcbFileName] -b [SourceHcsFileName]
Compile an HCB file to an HCS file:
hc-gen -o [OutputHcsFileName] -d [SourceHcbFileName]
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。