Index

Modules: bropkg/commands/astCommand, bropkg/commands/cCommand, bropkg/commands/docCommand, bropkg/commands/mapCommand, bropkg/commands/reprCommand, bropkg/commands/watchCommand, bropkg/engine/ast, bropkg/engine/compiler, bropkg/engine/eval, bropkg/engine/freemem, bropkg/engine/logging, bropkg/engine/memtable, bropkg/engine/parser, bropkg/engine/properties, bropkg/engine/sourcemap, bropkg/engine/tokens.

API symbols

Absolute:

• LengthType.Absolute

add:

• tokens: add(lex: var Lexer)

addSegment:

• sourcemap: addSegment(info: var SourceInfo; original, generated: int; name: string = "")

ArithmeticOperators:

• ast: ArithmeticOperators

AssignUndeclaredVar:

• Message.AssignUndeclaredVar

BadIndentation:

• Message.BadIndentation

call:

• ast: call(node: Node): Node

CaseCondTuple:

• ast: CaseCondTuple

CH:

• Units.CH

cHex:

• ColorType.cHex

cHSL:

• ColorType.cHSL

cHSLA:

• ColorType.cHSLA

CM:

• Units.CM

cmdEcho:

• CommandType.cmdEcho

cNamed:

• ColorType.cNamed

ColorType:

• ast: ColorType

CommandType:

• ast: CommandType

commaSep:

• Separator.commaSep

Compiler:

• compiler: Compiler

ConfigLoadingError:

• Message.ConfigLoadingError

cRGB:

• ColorType.cRGB

cRGBA:

• ColorType.cRGBA

current:

• tokens: current(lex: var Lexer): char

DeclaredEmptySelector:

• Message.DeclaredEmptySelector

DeclaredVariableUnused:

• Message.DeclaredVariableUnused

Deprecated:

• Status.Deprecated

DuplicateExtendStatement:

• Message.DuplicateExtendStatement

DuplicateObjectKey:

• Message.DuplicateObjectKey

DuplicateSelector:

• Message.DuplicateSelector

DuplicateVarDeclaration:

• Message.DuplicateVarDeclaration

EM:

• Units.EM

encode:

• sourcemap: encode(values: seq[int]): string

error:

• logging: error(logger: Logger; msg: Message; line, col: int; args: varargs[string])
• logging: error(msg: Message; tk: TokenTuple; strFmt: bool; extraLines: seq[string]; extraLabel: string; args: varargs[string])
• logging: error(msg: Message; tk: TokenTuple; strFmt: bool; args: varargs[string])
• logging: error(msg: Message; tk: TokenTuple; args: varargs[string])

errors:

• logging: errors(logger: Logger): Row

evalInfix:

• eval: evalInfix(infixLeft, infixRight: Node; infixOp: InfixOp; scope: ScopeTable): bool

EX:

• Units.EX

Experimental:

• Status.Experimental

ExtendRedundancyError:

• Message.ExtendRedundancyError

freem:

• freemem: freem(obj: untyped)

generateIdentCase:

• tokens: generateIdentCase(lex: var Lexer)

getColor:

• ast: getColor(node: Node): string

getCSS:

• compiler: getCSS(c: Compiler): string

getDefaultToken:

• tokens: getDefaultToken(strtk: string): TokenKind

getError:

• parser: getError(p: Parser): seq[Row]
• tokens: getError(lex: Lexer): string

getInfixOp:

• ast: getInfixOp(kind: TokenKind; isInfixInfix: bool): InfixOp

getMemtable:

• parser: getMemtable(p: Parser): Memtable

getMessage:

• logging: getMessage(log: Log): Message

getProgram:

• parser: getProgram(p: Parser): Program

getString:

• ast: getString(node: Node): string

getToken:

• tokens: getToken(lex: var Lexer): TokenTuple

gInherit:

• GlobalValue.gInherit

gInitial:

• GlobalValue.gInitial

GlobalValue:

• ast: GlobalValue

gRevert:

• GlobalValue.gRevert

gRevertLayer:

• GlobalValue.gRevertLayer

gUnset:

• GlobalValue.gUnset

handleCustomIdent:

• tokens: handleCustomIdent[T: Lexer](lex: var T; kind: TokenKind)

handleSnippets:

• tokens: handleSnippets(lex: var Lexer; kind: TokenKind)

hasError:

• parser: hasError(p: Parser): bool
• tokens: hasError(lex: Lexer): bool

hasLetters:

• tokens: hasLetters(lex: var Lexer; pos: int): bool

hasNumbers:

• tokens: hasNumbers(lex: var Lexer; pos: int): bool

hasStrictValue:

• properties: hasStrictValue(prop: Property; key: string): tuple[exists: bool, status: Status]

hasWarnings:

• parser: hasWarnings(p: Parser): bool

Implemented:

• Status.Implemented

ImportErrorFileNotFound:

• Message.ImportErrorFileNotFound

IN:

• Units.IN

inc:

• tokens: inc(lex: var Lexer; offset = 1)

InfixOp:

• ast: InfixOp

init:

• tokens: init[L: Lexer](lex: typedesc[L]; fileContent: string; allowMultilineStrings = false): L

InternalError:

• Message.InternalError

InvalidIndentation:

• Message.InvalidIndentation

InvalidInfixMissingValue:

• Message.InvalidInfixMissingValue

InvalidInfixOperator:

• Message.InvalidInfixOperator

InvalidNestSelector:

• Message.InvalidNestSelector

InvalidProperty:

• Message.InvalidProperty

InvalidSyntaxCaseStmt:

• Message.InvalidSyntaxCaseStmt

InvalidSyntaxCondStmt:

• Message.InvalidSyntaxCondStmt

InvalidSyntaxLoopStmt:

• Message.InvalidSyntaxLoopStmt

InvalidValueCaseStmt:

• Message.InvalidValueCaseStmt

isEqualBool:

• eval: isEqualBool(a, b: bool): untyped

isEqualFloat:

• eval: isEqualFloat(a, b: float64): untyped

isEqualInt:

• eval: isEqualInt(a, b: int): untyped

isEqualString:

• eval: isEqualString(a, b: string): untyped

isGreaterEqualInt:

• eval: isGreaterEqualInt(a, b: int): untyped

isGreaterInt:

• eval: isGreaterInt(a, b: int): untyped

isLessEqualInt:

• eval: isLessEqualInt(a, b: int): untyped

isLessInt:

• eval: isLessInt(a, b: int): untyped

isNotEqualBool:

• eval: isNotEqualBool(a, b: bool): untyped

isNotEqualFloat:

• eval: isNotEqualFloat(a, b: float64): untyped

isNotEqualInt:

• eval: isNotEqualInt(a, b: int): untyped

isNotEqualString:

• eval: isNotEqualString(a, b: string): untyped

KeyValueTable:

• ast: KeyValueTable

LengthType:

• ast: LengthType

Level:

• logging: Level

Lexer:

• tokens: Lexer

LexerException:

• tokens: LexerException

lexReady:

• tokens: lexReady(lex: var Lexer)

Log:

• logging: Log

Logger:

• logging: Logger

lvlError:

• Level.lvlError

lvlInfo:

• Level.lvlInfo

lvlNotice:

• Level.lvlNotice

lvlWarn:

• Level.lvlWarn

malloc_trim:

• freemem: malloc_trim(size: csize_t): cint

markVarUsed:

• ast: markVarUsed(node: Node)

mathAbs:

• eval: mathAbs(x: float): untyped
• eval: mathAbs(x: int): untyped

mathCeil:

• eval: mathCeil(x: float): untyped

mathClamp:

• eval: mathClamp(x: float; min, max: int): untyped

mathEpsilon:

• eval: mathEpsilon(x: float): untyped

mathFloor:

• eval: mathFloor(x: float): untyped

mathHypot:

• eval: mathHypot(x, y: float64): untyped

mathLog:

• eval: mathLog(x, base: float): untyped

mathRound:

• eval: mathRound(x: float): untyped

mathSin:

• eval: mathSin(x: float): untyped

mathTan:

• eval: mathTan(x: float): untyped

Memtable:

• memtable: Memtable

Message:

• logging: Message

MissingAssignmentToken:

• Message.MissingAssignmentToken

MissingClosingBracketArray:

• Message.MissingClosingBracketArray

MissingClosingObjectBody:

• Message.MissingClosingObjectBody

MM:

• Units.MM

newArray:

• ast: newArray(): Node

newBool:

• ast: newBool(bVal: string): Node

newCall:

• ast: newCall(node: Node): Node

newCaseStmt:

• ast: newCaseStmt(caseIdent: Node): Node

newClass:

• ast: newClass(tk: TokenTuple; props = KeyValueTable(); multipleSelectors = @[""]; concat: seq[Node] = @[]): Node

newColor:

• ast: newColor(cVal: string): Node

newComment:

• ast: newComment(str: string): Node

newCompiler:

• compiler: newCompiler(p: Program; outputPath: string; minify = false): Compiler

newCompilerStr:

• compiler: newCompilerStr(p: Program; outputPath: string): string

newEcho:

• ast: newEcho(cmdValue: Node): Node

newError:

• logging: newError(logger: Logger; msg: Message; line, col: int; useFmt: bool; args: varargs[string])

newErrorMultiLines:

• logging: newErrorMultiLines(logger: Logger; msg: Message; line, col: int; useFmt: bool; extraLines: seq[string]; extraLabel: string; args: varargs[string])

newExtend:

• ast: newExtend(tk: TokenTuple; keyValueTable: KeyValueTable): Node

newFloat:

• ast: newFloat(fVal: string): Node

newForStmt:

• ast: newForStmt(item, items: Node; toPairs = false): Node

newID:

• ast: newID(tk: TokenTuple; props = KeyValueTable(); multipleSelectors = @[""]; concat: seq[Node] = @[]): Node

newIf:

• ast: newIf(infix: Node): Node

newImport:

• ast: newImport(nodes: seq[Node]; importPath: string): Node
• ast: newImport(path: string): Node

newInfix:

• ast: newInfix(infixLeft: Node): Node
• ast: newInfix(infixLeft, infixRight: Node; infixOp: InfixOp): Node

newInfo:

• logging: newInfo(logger: Logger; msg: Message; line, col: int; useFmt: bool; args: varargs[string])

newInt:

• ast: newInt(iVal: string): Node

newJson:

• ast: newJson(jsonVal: JsonNode): Node

newLine:

• sourcemap: newLine(info: var SourceInfo; file: string; line: int)

newNotice:

• logging: newNotice(logger: Logger; msg: Message; line, col: int; useFmt: bool; args: varargs[string])

newObject:

• ast: newObject(): Node

newPreview:

• ast: newPreview(tk: TokenTuple): Node

newProperty:

• ast: newProperty(pName: string): Node

newPseudoClass:

• ast: newPseudoClass(tk: TokenTuple; props = KeyValueTable(); multipleSelectors = @[""]; concat: seq[Node] = @[]): Node

newSize:

• ast: newSize(size: int; unit: Units): Node

newString:

• ast: newString(sVal: string): Node

newTag:

• ast: newTag(tk: TokenTuple; props = KeyValueTable(); multipleSelectors = @[""]; concat: seq[Node] = @[]): Node

newValue:

• ast: newValue(val: Node): Node
• ast: newValue(tk: TokenTuple; valNode: Node): Node

newVariable:

• ast: newVariable(varName: string; varValue: Node; tk: TokenTuple): Node
• ast: newVariable(tk: TokenTuple): Node

newWarn:

• logging: newWarn(logger: Logger; msg: Message; line, col: int; useFmt: bool; args: varargs[string])

newWarningMultiLines:

• logging: newWarningMultiLines(logger: Logger; msg: Message; line, col: int; useFmt: bool; extraLines: seq[string]; extraLabel: string; args: varargs[string])

Node:

• ast: Node

NodeType:

• ast: NodeType

NonStandard:

• Status.NonStandard

NTAccessor:

• NodeType.NTAccessor

NTArray:

• NodeType.NTArray

NTAtRule:

• NodeType.NTAtRule

NTAttrSelector:

• NodeType.NTAttrSelector

NTBool:

• NodeType.NTBool

NTCall:

• NodeType.NTCall

NTCaseStmt:

• NodeType.NTCaseStmt

NTClassSelector:

• NodeType.NTClassSelector

NTColor:

• NodeType.NTColor

NTCommand:

• NodeType.NTCommand

NTComment:

• NodeType.NTComment

NTCondStmt:

• NodeType.NTCondStmt

NTExtend:

• NodeType.NTExtend

NTFloat:

• NodeType.NTFloat

NTForStmt:

• NodeType.NTForStmt

NTFunction:

• NodeType.NTFunction

NTIDSelector:

• NodeType.NTIDSelector

NTImport:

• NodeType.NTImport

NTInfix:

• NodeType.NTInfix

NTInt:

• NodeType.NTInt

NTJsonValue:

• NodeType.NTJsonValue

NTMathStmt:

• NodeType.NTMathStmt

NTObject:

• NodeType.NTObject

NTPreview:

• NodeType.NTPreview

NTProperty:

• NodeType.NTProperty

NTPseudoClassSelector:

• NodeType.NTPseudoClassSelector

NTPseudoElements:

• NodeType.NTPseudoElements

NTRoot:

• NodeType.NTRoot

NTSize:

• NodeType.NTSize

NTString:

• NodeType.NTString

NTTagSelector:

• NodeType.NTTagSelector

NTUniversalSelector:

• NodeType.NTUniversalSelector

NTVariable:

• NodeType.NTVariable

NTVariableValue:

• NodeType.NTVariableValue

Obsolete:

• Status.Obsolete

parseProgram:

• parser: parseProgram(fpath: string): Parser

Parser:

• parser: Parser

PC:

• Units.PC

prefixed:

• ast: prefixed(tk: TokenTuple): string

Program:

• ast: Program

Properties:

• properties: Properties

Property:

• properties: Property

PropertyRule:

• ast: PropertyRule

propRuleDefault:

• PropertyRule.propRuleDefault

propRuleImportant:

• PropertyRule.propRuleImportant

propRuleNone:

• PropertyRule.propRuleNone

PSIZE:

• Units.PSIZE

PT:

• Units.PT

PX:

• Units.PX

Relative:

• LengthType.Relative

REM:

• Units.REM

Removed:

• Status.Removed

runCommand:

• astCommand: runCommand(v: Values)
• cCommand: runCommand(v: Values)
• docCommand: runCommand(v: Values)
• mapCommand: runCommand(v: Values)
• reprCommand: runCommand(v: Values)
• watchCommand: runCommand(v: Values)

ScopeTable:

• ast: ScopeTable

Separator:

• properties: Separator

setError:

• tokens: setError(lex: var Lexer; message: string)

skip:

• tokens: skip(lex: var Lexer)

SourceInfo:

• sourcemap: SourceInfo

SourceMap:

• sourcemap: SourceMap

spaceSep:

• Separator.spaceSep

Status:

• properties: Status

tokenize:

• sourcemap: tokenize(line: string): (int, string)

TokenKind:

• tokens: TokenKind

TokenTuple:

• tokens: TokenTuple

toSourceMap:

• sourcemap: toSourceMap(info: SourceInfo; file: string): SourceMap

TryingAccessNonObject:

• Message.TryingAccessNonObject

UndeclaredCSSSelector:

• Message.UndeclaredCSSSelector

UndeclaredVariable:

• Message.UndeclaredVariable

UndefinedPropertyAccessor:

• Message.UndefinedPropertyAccessor

UndefinedValueVariable:

• Message.UndefinedValueVariable

UnexpectedToken:

• Message.UnexpectedToken

Unimplemented:

• Status.Unimplemented

Units:

• ast: Units

UnknownPseudoClass:

• Message.UnknownPseudoClass

UnrecognizedToken:

• Message.UnrecognizedToken

UnstablePropertyStatus:

• Message.UnstablePropertyStatus

VariableRedefinition:

• Message.VariableRedefinition

VH:

• Units.VH

VMAX:

• Units.VMAX

VMIN:

• Units.VMIN

VW:

• Units.VW

warn:

• logging: warn(logger: Logger; msg: Message; line, col: int; strFmt: bool; args: varargs[string])
• logging: warn(logger: Logger; msg: Message; line, col: int; args: varargs[string])
• logging: warn(msg: Message; tk: TokenTuple; strFmt: bool; args: varargs[string])
• logging: warn(msg: Message; tk: TokenTuple; args: varargs[string])

Warning:

• compiler: Warning
• parser: Warning

warnings:

• logging: warnings(logger: Logger): Row