DEV Community

SameX
SameX

Posted on

HarmonyOS Next DSL Kit: A Guide to Domain Specific Language Development

In the development ecosystem of HarmonyOS Next, domain-specific language (DSL) development is the key to achieving highly customized and efficient programming.However, traditional DSL development is difficult, and the Cangjie language DSL Kit provides developers with a powerful solution.As a technician with rich practical experience in this field, I will introduce in detail the usage methods and advantages of DSL Kit based on actual cases.

1. DSL development pain points and Cangjie plan

(I) Manually write parser vs BNF automatic generation (complexity comparison)

In traditional DSL development, writing a syntax parser manually is a challenging task.Developers need to deeply understand the compilation principles and deal with complex processes such as lexical analysis and grammatical analysis.This not only takes a lot of time and effort, but also makes mistakes prone.Once the syntax of DSL changes, the maintenance cost of the parser will also rise sharply.

The DSL Kit of Cangjie Language greatly simplifies this process by introducing an automatic generation mechanism based on the Bacos Paradigm (BNF).Developers only need to specify the BNF grammar in a declarative manner, and DSL Kit can automatically generate the corresponding syntax parser.This approach not only reduces the workload of manually writing code, but also improves the reliability and maintainability of the parser.

Taking a simple mathematical expression DSL as an example, writing a parser manually can require hundreds or even thousands of lines of code, and it needs to deal with various boundary cases and syntax errors.When using DSL Kit, you only need to define the following BNF grammar:

expression ::= number | expression "+" expression | expression "-" expression | expression "*" expression | expression "/" expression
number ::= [0-9]+
Enter fullscreen mode Exit fullscreen mode

DSL Kit can automatically generate a fully functional syntax parser based on this definition, greatly reducing the difficulty of development.

2. DSL Kit core functions

(I) Declarative syntax definition and attribute syntax check (Example: JSON DSL)

DSL Kit supports declarative syntax definitions, allowing developers to define the syntax structure of DSL in an intuitive way.At the same time, it also introduces an attribute syntax checking mechanism, further enhancing the reliability of DSL.

Taking the custom JSON DSL as an example, suppose we want to define a simplified JSON syntax for data description in a specific scenario.The syntax can be defined like this:

jsonValue ::= jsonObject | jsonArray | string | number | "true" | "false" | "null"
jsonObject ::= "{" (jsonPair ("," jsonPair)*)? "}"
jsonPair ::= string ":" jsonValue
jsonArray ::= "[" (jsonValue ("," jsonValue)*)? "]"
string ::= "\"" [^"]* "\""
number ::= [0-9]+ ( "." [0-9]+ )?
Enter fullscreen mode Exit fullscreen mode

In this definition, we clearly describe the various types and structures of JSON data.DSL Kit will syntax check the input DSL code based on this definition.

At the same time, with the help of attribute syntax, we can attach semantic information to syntax elements.For example, in jsonObject, we can add properties to check the uniqueness of the key:

jsonObject ::= "{" (jsonPair ("," jsonPair)*)? "}" {
    checkUniqueKeys(jsonPair.key)
}
jsonPair ::= string ":" jsonValue
Enter fullscreen mode Exit fullscreen mode

In this way, duplicate key errors can be found during the compilation period, avoiding problems that are difficult to debug at runtime.

3. Static optimization during compilation period

(I) Semantic appendix and error premature interception mechanism

DSL Kit performs semantic appends and early error intercepts during the compilation period, which is an important means for optimizing DSL development.By appending semantic information to declarative syntax, the compiler can perform more in-depth inspections and optimizations during the compilation phase.

For example, in a DSL used to describe database queries, we can attach semantic information to the query conditions to check whether the query conditions are reasonable.Suppose the following DSL is defined for querying user data:

query ::= "select" fields "from" table ("where" condition)?
fields ::= field ("," field)*
field ::= string
table ::= string
condition ::= expression
expression ::= field "=" value | field ">" value | field "<" value
value ::= string | number
Enter fullscreen mode Exit fullscreen mode

We can add semantic checks for condition to make sure that the fields in the query conditions do exist in the table:

query ::= "select" fields "from" table ("where" condition)? {
    checkFieldsExist(table, condition.fields)
}
fields ::= field ("," field)*
field ::= string
table ::= string
condition ::= expression
expression ::= field "=" value | field ">" value | field "<" value
value ::= string | number
Enter fullscreen mode Exit fullscreen mode

In this way, when the query conditions written by the developer contain non-existent fields, the compiler will report an error during the compilation period, avoiding the discovery of errors at runtime, and improving development efficiency and code quality.

The DSL Kit of Cangjie Language provides comprehensive and powerful support for the DSL development of HarmonyOS Next.By automatically generating syntax parsers, declarative syntax definitions, attribute syntax checking, and compile-time static optimization, developers can more easily create and use domain-specific languages ​​to improve development efficiency and code reliability.In actual projects, the rational use of DSL Kit can significantly reduce development costs and achieve more efficient and flexible programming.

Top comments (0)