X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.ts;h=a8d103b5d550e29e63fe0e707a9b36b3b10bd090;hb=6f2e788329da7702ea96dc28ae04499917ec8152;hp=26cd10df0e081ec2ce445b72c26aeef17bdde0bb;hpb=4cfa9c7cb47795674b6f2c2f2d0f63fe24100c49;p=clo diff --git a/src/index.ts b/src/index.ts index 26cd10d..a8d103b 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,104 +1,120 @@ var fs = require('fs'); - -type Some = { _tag: "Some"; value: T }; -type None = {_tag: "None"}; +import { argv } from 'node:process'; +import * as tk from './tokenize.js'; +import * as util from 'util'; /** - * @description Like the `Some(a)` and `None` in Rust. - * - * @example - * ```ts - * let exam1 : Maybe = { _tag: "Some", value: 12 }; - * let exam2 : Maybe = None; - * ``` + * token tree type. */ -export type Maybe = Some | None; - +type tkTree = tk.Token[] | tk.Token -/** - * @description - * the pair of the string to be matched later and the string that have been matched - * @param matched : string have been matched - * @param remained : string will be tested whether it'll be matched. - */ -export type MatcheePair = {matched : string; remained : string}; +export interface TokenMatcheePair { + matched: tkTree[] + remained: tk.Token[] +} /** * @description - * it returns a function which test if the first char of the `remained` part of - * the argument of the function is `c`, if it's true, update the `MatchedPair` wrapped + * match one token type. + * + * it returns a function which test if the type of first token of the `remained` part of + * the argument of the function is `typ` , if it's true, update the `TokenMatcheePair` wrapped * in `Some`. Otherwise, it returns `None`. - * * @param c : the char to be test. - * @returns the updated `MatchedPair` wrapped in `Some(x)` or `None`. + * * @param typ : the type to be test. + * @returns the updated `TokenMatcheePair` wrapped in `Some(x)` or `None`. */ -export function match1Char(c : string) : (m: MatcheePair) => Maybe { - return (m : MatcheePair)=>{ - const charToBeMatched = m.remained[0]; - if (charToBeMatched === c){ - return {_tag: "Some", value :{ - matched : m.matched + charToBeMatched, - remained : m.remained.substring(1)}}; +export function m1TType(typ: tk.TokenType): + (m: TokenMatcheePair) => tk.Maybe { + return (m: TokenMatcheePair) => { + if (m.remained.length == 0) { + return { _tag: "None" }; } - else{ - return {_tag: "None"}; - } - } -}; - -/** - * @description - * it returns a function which test if the first char of the `remained` part of - * the argument of the function is between `l` and `u`, if it's true, update the `MatchedPair` wrapped - * in `Some`. Otherwise, it returns `None`. - * * @param l : lower bound char, 1-char string - * * @param u : upper bound char, 1-char string - * @returns the updated `MatchedPair` wrapped in `Some(x)` or `None`. - */ -export function matchRange(l : string, u : string) : (m: MatcheePair) => Maybe { - let lCodepoint = charToCodepoint(l); - let uCodepoint = charToCodepoint(u); - if (l > u){ - throw new Error("Error: the codepoint of `"+l+"` is not smaller than `"+u+"`)"); - } - return (m : MatcheePair)=>{ - - const charToBeMatched = m.remained[0]; - const codePointToBeMatched = charToCodepoint(charToBeMatched); - if (codePointToBeMatched >= lCodepoint && codePointToBeMatched <= uCodepoint){ - return {_tag: "Some", value :{ - matched : m.matched + charToBeMatched, - remained : m.remained.substring(1)}}; + /** + * token to be matched + * */ + const ttbm = m.remained[0]; + + if (ttbm.type == typ) { + m.matched.push(ttbm); + return { + _tag: "Some", value: { + matched: m.matched, + remained: m.remained.slice(1) + } + }; } - else{ - return {_tag: "None"}; + else { + return { _tag: "None" }; } } }; +let toSome = tk.toSome; +let thenDo = tk.thenDo; +let orDo = tk.orDo; + + +argv.forEach((val, index) => { + console.log(`${index}=${val}`); +}); + +let commandInput = argv[2]; +let commandInputTokenized = tk.tokenize(commandInput); +console.log(commandInputTokenized); + /** - * convert the one-char string to codepoint. - * @param s : the string to code point. - * @returns if `s.length > 1` return error; otherwise, return the codepoint of `s`. + * matchee pair of commandInputTokenized */ -export function charToCodepoint(s : string): number{ - if (s.length > 1){ - throw new Error("Error: the length of input string for "+s+ "is "+s.length+`, - however, it should be 1.`); +let commandTPair : TokenMatcheePair = {matched:[], + remained: commandInputTokenized}; + + +let tInt = m1TType(tk.TokenType.INT); +let tFlo = m1TType(tk.TokenType.FLO); +let tStr = m1TType(tk.TokenType.STR); +function tBool (x : TokenMatcheePair) :tk.Maybe { + let text = x.remained[0].text + if (text == "true" || text == "false"){ + return thenDo(toSome(x), m1TType(tk.TokenType.ID)); }else{ - return s.charCodeAt(0); + return {_tag : "None"}; } } /** - * @description thendo(input, f, ...) like - * a ==> f + * define the right hand side of a grammar + * eg. `LHS ::= a + b` + * @param process the right hand side processing : eg. `a + b` in `LHS` + * @param arrange define the order (0 starting) of the elements of the result. + * ast. : eg. `a + c` is `1 0 2` `(+ a c)` + * @returns the processed ast. */ -export function thenDo(input : Maybe, f : Function) : Maybe{ - if (input._tag == "None"){ - return input; +function gramRHS (process: Function, arrange : number[]){ + return (m : TokenMatcheePair)=>{ + + let result : tk.Maybe = process(m); + console.log(`result ${result}`) + if (result._tag == "None"){ + return result; } else{ - let inner = input.value; - return f(inner); + let matched = result.value.matched; + let return_array : tkTree[] = Array(arrange.length); + + arrange.forEach((val, index) => { + return_array[arrange[index]] = matched[index]; + }); + + return return_array; + } } } + +/** + * CONST ::= INT | STR | FLO | BOOL + */ +var constParser = gramRHS((x : TokenMatcheePair)=> + {return thenDo(toSome(x),orDo(orDo(orDo(tInt,tFlo),tStr),tBool))}, [0]); + +let tree = constParser(commandTPair); +console.log(util.inspect(tree, { showHidden: true, depth: null }));