cddl 0.15.0 → 0.17.0

package/src/ast.ts

@@ -1,180 +0,0 @@
-/**
- * a group definition
- * ```
- * person = {
- *     age: int,
- *     name: tstr,
- *     employer: tstr,
- * }
- * ```
- */
-export type Group = {
-    Type: 'group'
-    Name: string
-    IsChoiceAddition: boolean
-    Properties: (Property|Property[])[]
-    Comments: Comment[]
-}
-
-/**
- * an array definition
- * ```
- * Geography = [
- *     city: tstr
- * ]
- * ```
- */
-export type Array = {
-    Type: 'array'
-    Name: string
-    Values: (Property|Property[])[]
-    Comments: Comment[]
-}
-
-/**
- * a tag definition
- * ```
- * #6.32(tstr)
- * ```
- */
-export type Tag = {
-    NumericPart: number
-    TypePart: string
-}
-
-/**
- * a variable assignment
- * ```
- * device-address = byte
- * ```
- */
-export type Variable = {
-    Type: 'variable'
-    Name: string
-    IsChoiceAddition: boolean
-    PropertyType: PropertyType | PropertyType[]
-    Operator?: Operator
-    Comments: Comment[]
-}
-
-/**
- * a comment statement
- * ```
- * ; This is a comment
- * ```
- */
-export type Comment = {
-    Type: 'comment'
-    Content: string
-    Leading: boolean
-}
-
-export type Occurrence = {
-    n: number
-    m: number
-}
-
-export type Property = {
-    HasCut: boolean
-    Occurrence: Occurrence
-    Name: PropertyName
-    Type: PropertyType | PropertyType[]
-    Comments: Comment[]
-    Operator?: Operator
-}
-
-export enum Type {
-    /**
-     * any types
-     */
-    ANY = 'any',
-
-    /**
-     * boolean types
-     */
-    // Boolean value (major type 7, additional information 20 or 21).
-    BOOL = 'bool',
-
-    /**
-     * numeric types
-     */
-    // An unsigned integer or a negative integer.
-    INT = 'int',
-    // An unsigned integer (major type 0).
-    UINT = 'uint',
-    // A negative integer (major type 1).
-    NINT = 'nint',
-    // One of float16, float32, or float64.
-    FLOAT = 'float',
-    // A number representable as an IEEE 754 half-precision float
-    FLOAT16 = 'float16',
-    // A number representable as an IEEE 754 single-precision
-    FLOAT32 = 'float32',
-    // A number representable as an IEEE 754 double-precision
-    FLOAT64 = 'float64',
-
-    /**
-     * string types
-     */
-    // A byte string (major type 2).
-    BSTR = 'bstr',
-    // A byte string (major type 2).
-    BYTES = 'bytes',
-    // Text string (major type 3)
-    TSTR = 'tstr',
-    // Text string (major type 3)
-    TEXT = 'text',
-
-    /**
-     * null types
-     */
-    NIL = 'nil',
-    NULL = 'null'
-}
-
-/**
- * can be a number, e.g. "foo = 0..10"
- * ```
- * {
- *   Type: "int",
- *   Value: 6
- * }
- * ```
- * or a literal, e.g. "foo = 0..max-byte"
- * ```
- * {
- *   Type: "literal",
- *   Value: "max-byte"
- * }
- * ```
- */
-export type RangePropertyReference = number | string
-
-export type Range = {
-    Min: RangePropertyReference
-    Max: RangePropertyReference
-    Inclusive: boolean
-}
-
-export type OperatorType = 'default' | 'size' | 'regexp' | 'bits' | 'and' | 'within' | 'eq' | 'ne' | 'lt' | 'le' | 'gt' | 'ge'
-export interface Operator {
-    Type: OperatorType
-    Value: PropertyType
-}
-
-export type PropertyReferenceType = 'literal' | 'group' | 'group_array' | 'array' | 'range' | 'tag'
-export type PropertyReference = {
-    Type: PropertyReferenceType
-    Value: string | number | boolean | Group | Array | Range | Tag
-    Unwrapped: boolean
-    Operator?: Operator
-}
-
-export interface NativeTypeWithOperator {
-    Type: Type | PropertyReference
-    Operator?: Operator
-}
-
-export type Assignment = Group | Array | Variable
-export type PropertyType = Assignment | Array | PropertyReference | string | NativeTypeWithOperator
-export type PropertyName = string

package/src/cli/commands/repl.ts

@@ -1,33 +0,0 @@
-import repl from 'node:repl'
-import type { Argv } from 'yargs'
-
-import { CLI_EPILOGUE } from '../constants.js'
-import Lexer from '../../lexer.js'
-import { Tokens } from '../../tokens.js'
-
-export const command = 'repl'
-export const desc = 'Run CDDL repl'
-export const builder = (yargs: Argv<{}>) => {
-    return yargs
-        .epilogue(CLI_EPILOGUE)
-        .help()
-}
-
-export const handler = () => {
-    repl.start({
-        prompt: '> ',
-        eval: evaluate
-    })
-}
-
-export function evaluate (evalCmd: string, _: any, _file: string, callback: (err: Error | null, result: any) => void) {
-    if (!evalCmd) {
-        return callback(new Error('No input'), null)
-    }
-
-    const l = new Lexer(evalCmd)
-    for (let tok = l.nextToken(); tok.Type !== Tokens.EOF; tok = l.nextToken()) {
-        console.log(tok)
-    }
-    return callback(null, null)
-}

package/src/cli/commands/validate.ts

@@ -1,44 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import type { Argv, ArgumentsCamelCase } from 'yargs'
-
-import { CLI_EPILOGUE } from '../constants.js'
-import { parse } from '../../index.js'
-
-interface ValidateArguments {
-    filePath: string
-}
-
-export const command = 'validate <filePath>'
-export const desc = 'Validate a *.cddl file'
-export const builder = (yargs: Argv<{}>) => {
-    return yargs
-        .epilogue(CLI_EPILOGUE)
-        .help()
-}
-
-export const handler = (argv: ArgumentsCamelCase<ValidateArguments>) => {
-    const filePath = argv.filePath.startsWith('/')
-        ? argv.filePath
-        : path.resolve(process.cwd(), argv.filePath)
-
-    if (!fs.existsSync(filePath)) {
-        console.error(`Couldn't find CDDL file at ${filePath}`)
-        return process.exit(1)
-    }
-
-    try {
-        parse(filePath)
-
-
-        /**
-         * ToDo check for
-         *  - missing group declarations
-         */
-
-        console.log('✅ Valid CDDL file!')
-    } catch (err: unknown) {
-        console.error(`⚠️  Invalid CDDL file (${filePath})\n\n${(err as Error).stack}`)
-        process.exit(1)
-    }
-}

package/src/cli/constants.ts

@@ -1 +0,0 @@
-export const CLI_EPILOGUE = `Copyright 2023 - Christian Bromann`

package/src/cli/index.ts

@@ -1,18 +0,0 @@
-import yargs from 'yargs/yargs'
-import { hideBin } from 'yargs/helpers'
-
-import * as replCommand from './commands/repl.js'
-import * as validateCommand from './commands/validate.js'
-import { CLI_EPILOGUE } from './constants.js'
-
-export default async function () {
-    const argv = yargs(hideBin(process.argv))
-        .command(replCommand)
-        .command(validateCommand as any)
-        .example('$0 repl', 'Start CDDL repl')
-        .epilogue(CLI_EPILOGUE)
-        .demandCommand()
-        .help()
-
-    return argv.argv
-}

package/src/constants.ts

@@ -1,16 +0,0 @@
-export const WHITESPACE_CHARACTERS = [' ', '\t', '\n', '\r']
-export const BOOLEAN_LITERALS = ['true', 'false']
-
-/**
- * as defined in Appendix D
- * https://tools.ietf.org/html/draft-ietf-cbor-cddl-08#appendix-D
- */
-export const PREDEFINED_IDENTIFIER = [
-    'any', 'uint', 'nint', 'int', 'bstr', 'bytes', 'tstr', 'text',
-    'tdate', 'time', 'number', 'biguint', 'bignint', 'bigint',
-    'integer', 'unsigned', 'decfrac', 'bigfloat', 'eb64url',
-    'eb64legacy', 'eb16', 'encoded-cbor', 'uri', 'b64url',
-    'b64legacy', 'regexp', 'mime-message', 'cbor-any', 'float16',
-    'float32', 'float64', 'float16-32', 'float32-64', 'float',
-    'false', 'true', 'bool', 'nil', 'null', 'undefined'
-]

package/src/index.ts

@@ -1,12 +0,0 @@
-import Lexer from './lexer.js'
-import Parser from './parser.js'
-
-export function parse (filePath: string) {
-    const parser = new Parser(filePath)
-    return parser.parse()
-}
-
-export default { parse }
-export { Lexer, Parser }
-export * from './ast.js'
-export * from './utils.js'

package/src/lexer.ts

@@ -1,238 +0,0 @@
-import { Token, Tokens } from './tokens.js';
-import { isLetter, isAlphabeticCharacter, isDigit, hasSpecialNumberCharacter } from './utils.js'
-import { WHITESPACE_CHARACTERS } from './constants.js';
-
-export default class Lexer {
-    input: string
-    position: number = 0
-    readPosition: number = 0
-    ch: number = 0
-
-    constructor (source: string) {
-        this.input = source
-
-        this.readChar()
-    }
-
-    private readChar (): void {
-        if (this.readPosition >= this.input.length) {
-            this.ch = 0
-        } else {
-            this.ch = this.input[this.readPosition].charCodeAt(0)
-        }
-        this.position = this.readPosition
-        this.readPosition++
-    }
-
-    getLocation () {
-        const position = this.position - 2
-        const sourceLines = this.input.split('\n')
-        const sourceLineLength = sourceLines.map((l) => l.length)
-        let i = 0
-
-        for (const [line, lineLength] of Object.entries(sourceLineLength)) {
-            i += lineLength + 1
-            if (i > position) {
-                const lineBegin = i - lineLength
-                return {
-                    line: parseInt(line, 10),
-                    position: position - lineBegin + 1
-                }
-            }
-        }
-
-        return { line: 0, position: 0 }
-    }
-
-    getLine (lineNumber: number) {
-        return this.input.split('\n')[lineNumber]
-    }
-
-    getLocationInfo () {
-        const loc = this.getLocation()
-        const line = loc ? this.getLine(loc.line) : ''
-        let locationInfo = line + '\n'
-        locationInfo += ' '.repeat(loc?.position || 0) + '^\n'
-        locationInfo += ' '.repeat(loc?.position || 0) + '|\n'
-        return locationInfo
-    }
-
-    nextToken (): Token {
-        let token: Token
-        this.skipWhitespace()
-
-        const Literal = String.fromCharCode(this.ch)
-        switch (this.ch) {
-            case '='.charCodeAt(0):
-                token = { Type: Tokens.ASSIGN, Literal }
-                break
-            case '('.charCodeAt(0):
-                token = { Type: Tokens.LPAREN, Literal }
-                break
-            case ')'.charCodeAt(0):
-                token = { Type: Tokens.RPAREN, Literal }
-                break
-            case '{'.charCodeAt(0):
-                token = { Type: Tokens.LBRACE, Literal }
-                break
-            case '}'.charCodeAt(0):
-                token = { Type: Tokens.RBRACE, Literal }
-                break
-            case '['.charCodeAt(0):
-                token = { Type: Tokens.LBRACK, Literal }
-                break
-            case ']'.charCodeAt(0):
-                token = { Type: Tokens.RBRACK, Literal }
-                break
-            case '<'.charCodeAt(0):
-                token = { Type: Tokens.LT, Literal }
-                break
-            case '>'.charCodeAt(0):
-                token = { Type: Tokens.GT, Literal }
-                break
-            case '+'.charCodeAt(0):
-                token = { Type: Tokens.PLUS, Literal }
-                break
-            case ','.charCodeAt(0):
-                token = { Type: Tokens.COMMA, Literal }
-                break
-            case '.'.charCodeAt(0):
-                token = { Type: Tokens.DOT, Literal }
-                break
-            case ':'.charCodeAt(0):
-                token = { Type: Tokens.COLON, Literal }
-                break
-            case '?'.charCodeAt(0):
-                token = { Type: Tokens.QUEST, Literal }
-                break
-            case '/'.charCodeAt(0):
-                token = { Type: Tokens.SLASH, Literal }
-                break
-            case '*'.charCodeAt(0):
-                token = { Type: Tokens.ASTERISK, Literal }
-                break
-            case '^'.charCodeAt(0):
-                token = { Type: Tokens.CARET, Literal }
-                break
-            case '#'.charCodeAt(0):
-                token = { Type: Tokens.HASH, Literal }
-                break
-            case '~'.charCodeAt(0):
-                token = { Type: Tokens.TILDE, Literal }
-                break
-            case '"'.charCodeAt(0):
-                token = { Type: Tokens.STRING, Literal: this.readString() }
-                break
-            case ';'.charCodeAt(0):
-                token = { Type: Tokens.COMMENT, Literal: this.readComment() }
-                break
-            case 0:
-                token = { Type: Tokens.EOF, Literal: '' }
-                break
-            default: {
-                if (isAlphabeticCharacter(Literal)) {
-                    return { Type: Tokens.IDENT, Literal: this.readIdentifier() }
-                } else if (
-                    // positive number
-                    isDigit(Literal) ||
-                    // negative number
-                    (this.ch === Tokens.MINUS.charCodeAt(0) && isDigit(this.input[this.readPosition]))
-                ) {
-                    const numberOrFloat = this.readNumberOrFloat()
-                    return {
-                        Type: numberOrFloat.includes(Tokens.DOT) ? Tokens.FLOAT : Tokens.NUMBER,
-                        Literal: numberOrFloat
-                    }
-                }
-                token = { Type: Tokens.ILLEGAL, Literal: '' }
-            }
-        }
-
-        this.readChar()
-        return token
-    }
-
-    private readIdentifier (): string {
-        const position = this.position
-
-        /**
-         * an identifier can contain
-         * see https://tools.ietf.org/html/draft-ietf-cbor-cddl-08#section-3.1
-         */
-        while (
-            // a letter (a-z, A-Z)
-            isLetter(String.fromCharCode(this.ch)) ||
-            // a digit (0-9)
-            isDigit(String.fromCharCode(this.ch)) ||
-            // and special characters (-, _, @, ., $)
-            [
-                Tokens.MINUS.charCodeAt(0),
-                Tokens.UNDERSCORE.charCodeAt(0),
-                Tokens.ATSIGN.charCodeAt(0),
-                Tokens.DOT.charCodeAt(0),
-                Tokens.DOLLAR.charCodeAt(0)
-            ].includes(this.ch)
-        ) {
-            this.readChar()
-        }
-
-        return this.input.slice(position, this.position)
-    }
-
-    private readComment (): string {
-        const position = this.position
-
-        while (this.ch && String.fromCharCode(this.ch) !== '\n') {
-            this.readChar()
-        }
-
-        return this.input.slice(position, this.position).trim()
-    }
-
-    private readString (): string {
-        const position = this.position
-
-        this.readChar() // eat "
-        while (this.ch && String.fromCharCode(this.ch) !== Tokens.QUOT) {
-            this.readChar() // eat any character until "
-        }
-
-        return this.input.slice(position + 1, this.position).trim()
-    }
-
-    private readNumberOrFloat (): string {
-        const position = this.position
-        let foundSpecialCharacter = false
-
-        /**
-         * a number of float can contain
-         */
-        while (
-            // a number
-            isDigit(String.fromCharCode(this.ch)) ||
-            // a special character, e.g. ".", "x" and "b"
-            hasSpecialNumberCharacter(this.ch)
-        ) {
-            /**
-             * ensure we respect ranges, e.g. 0..10
-             * so break after the second dot and adjust read position
-             */
-            if (hasSpecialNumberCharacter(this.ch) && foundSpecialCharacter) {
-                this.position--
-                this.readPosition--
-                break
-            }
-
-            foundSpecialCharacter = hasSpecialNumberCharacter(this.ch)
-            this.readChar() // eat any character until a non digit or a 2nd dot
-        }
-
-        return this.input.slice(position, this.position).trim()
-    }
-
-    private skipWhitespace () {
-        while (WHITESPACE_CHARACTERS.includes(String.fromCharCode(this.ch))) {
-            this.readChar()
-        }
-    }
-}