X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.ts;h=a8d103b5d550e29e63fe0e707a9b36b3b10bd090;hb=e8f894d994f145be9ffef38cdf4fa8fc23ae9e00;hp=883d94b742145129ff948e0325d94457b274b8f1;hpb=5fbb467bdf501dee03c78817242581d962547c4f;p=clo diff --git a/src/index.ts b/src/index.ts index 883d94b..a8d103b 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,362 +1,120 @@ var fs = require('fs'); - -export type Some = { _tag: "Some"; value: T }; -export type None = {_tag: "None"}; - - -/** - * wrap a x in a `Some(T)` - * @param x : variable to be wrapped. - * @returns wrapped `x`. - */ -function toSome(x: T): Some{ - return { _tag: "Some", value: x}; -} -/** - * @description Like the `Some(a)` and `None` in Rust. - * - * @example - * ```ts - * let exam1 : Maybe = { _tag: "Some", value: 12 }; - * let exam2 : Maybe = None; - * ``` - */ -export type Maybe = Some | None; - - -/** - * @description - * the pair of the string to be matched later and the string that have been matched - * @var matched : have been matched - * @var remained : will be tested whether it'll be matched. - * @var matched_type (optional): the type of the matched string -*/ -export interface MatcheePair { - matched : string - remained : string - matched_type?: TokenType -} +import { argv } from 'node:process'; +import * as tk from './tokenize.js'; +import * as util from 'util'; /** - * The types of Token - * NL, // newline - * - * SP, // half-width space and tab - * - * ID, // identifier - * - * STR, // string - * - * OP, // operator or something like it - * - * FLO, // float num - * - * INT, // Integer + * token tree type. */ -export enum TokenType{ - NL, // newlinw - SP, // half-width space and tab - ID, // identifier - STR, // string - OP, // operator - FLO, // float num - INT, // integer -} +type tkTree = tk.Token[] | tk.Token -/** - * tokenized token. - * @var text : the content text - * @var type (optional): the type of the token - * @var col : the column number - * @var ln : the line number - */ -export interface Token{ - text: string, - type?: TokenType, - col: number, - ln: number, +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)=>{ - if (m.remained.length == 0){ +export function m1TType(typ: tk.TokenType): + (m: TokenMatcheePair) => tk.Maybe { + return (m: TokenMatcheePair) => { + if (m.remained.length == 0) { return { _tag: "None" }; } - const charToBeMatched = m.remained[0]; - if (charToBeMatched === c){ - 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" }; } } }; -/** - * - * @param m : the `MatcheePair` to be consumed. - * @returns if the length of `m.remained` >= 1; consumes the matchee by 1 char and wraps it in `Some`, - * otherwise, returns `None`. - */ -export function matchAny(m : MatcheePair) : Maybe{ - if (m.remained.length >= 1){ - return {_tag: "Some", value :{ - matched : m.matched + m.remained[0], - remained : m.remained.substring(1)}}; - }else{ - return {_tag: "None"}; - } -} +let toSome = tk.toSome; +let thenDo = tk.thenDo; +let orDo = tk.orDo; -/** - * @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)=>{ - if (m.remained.length < 1){ - return {_tag : "None"}; - } - 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)}}; - } - else{ - return {_tag: "None"}; - } - } -}; -/** - * 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`. - */ -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.`); - }else{ - return s.charCodeAt(0); - } -} +argv.forEach((val, index) => { + console.log(`${index}=${val}`); +}); -/** - * @description thendo(input, f, ...) like - * a ==> f - * @param input: the wrapped input. - * @param f: the function to be applied. - * - * @returns:the applied wrapped result `MatcheePair`. - */ -export function thenDo(input : Maybe, f : Function) : Maybe{ - if (input._tag == "None"){ - return input; - } - else{ - let inner = input.value; - return f(inner); - } -} +let commandInput = argv[2]; +let commandInputTokenized = tk.tokenize(commandInput); +console.log(commandInputTokenized); /** - * @description "or", like the regex `( f1 | f2 )` . - * It returns a function `f` of which the argument is`x`. - * if `f1(x)` is None, then `f` returns `f2(x)`. Otherwise, - * `F` returns `f1(x)`. - * @param f1 : 1st function to be compared - * @param f2 : 2nd function to be compared - * @returns:the combined function + * matchee pair of commandInputTokenized */ -export function orDo(f1 : Function, f2: Function) : (x : T ) => Maybe{ - return (x) => { - let f1x : Maybe = (f1(x)); - { - if (f1x._tag == "None"){ - return f2(x); - } - else{ - return f1x; - } - } - }; -} - - -/** -* @description repeating matching function `f` -* zero or more times, like the asterisk `*` in regex `f*` . -* @param f : the function to be repeated 0+ times. -* @returns:the combined function -*/ -export function zeroOrMoreDo(f : Function): (x : T) => Maybe{ - return (x)=>{ - var wrapped_old_x : Maybe = {_tag: "Some", value : x}; - var wrapped_new_x : Maybe = wrapped_old_x; +let commandTPair : TokenMatcheePair = {matched:[], + remained: commandInputTokenized}; - while (wrapped_new_x._tag != "None"){ - wrapped_old_x = wrapped_new_x; - wrapped_new_x = thenDo(wrapped_old_x, f); - }; - return wrapped_old_x; - }; -} - -/** -* @description Not. like the `^` inside regex of [^f]. -* returns a function `F(x)` such that if `f(x)` is `None`, -* returns the x consuming a char; if `f(x)` is not None, F(x) -* returns `None`. -* @param f: the function forbidden to be matched. -* @returns: combined function `F`. -*/ -export function notDo(f : Function): (x : T) => Maybe{ - return (x)=>{ - let wrapped_x : Maybe = { - _tag : "Some", - value : x - }; - let f_x = thenDo(wrapped_x, f); - - if (f_x._tag != "None"){ - return {_tag:"None"}; - }else{ - return thenDo(wrapped_x, matchAny); - } - }; +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 {_tag : "None"}; + } } /** - * if `x` is matched by `f` once, returns `f(x)`. Otherwise, - * returns x - * similar to `?` in regex `f?`. - * @param f : the function to be matched - * @returns return wrapped f(x) + * 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 zeroOrOnceDo(f : Function): (x : T) => Maybe{ - return (x)=>{ - var wrapped_old_x : Maybe = {_tag: "Some", value : x}; - var wrapped_new_x = thenDo(wrapped_old_x, f); - - if (wrapped_new_x._tag != "None"){ - return wrapped_new_x; - }else{ - return wrapped_old_x; - } - }; -} - - -export function tokenize(input : string){ - var input_matchee_pair : Maybe = toSome( - {matched:"", - remained: input}); +function gramRHS (process: Function, arrange : number[]){ + return (m : TokenMatcheePair)=>{ - // integer = ([+]|[-])?\d\d* - let integer = (x : MatcheePair) => - { let wrapped_x = toSome(x); - let plusMinus = orDo(match1Char('+'), match1Char('-')); // ([+]|[-]) - let d = matchRange('0','9'); // \d - var result = thenDo(thenDo(thenDo(wrapped_x, - zeroOrOnceDo(plusMinus)),d), - zeroOrMoreDo(d)); - - if (result._tag == "Some"){ - result.value.matched_type = TokenType.INT; - } - return result; - } - let space = (x : MatcheePair) =>{ - let wrapped_x = toSome(x); - let s_aux = orDo(match1Char(' '), match1Char('\t')); // (" " | "\t") - var result = thenDo(thenDo(wrapped_x, s_aux), zeroOrMoreDo(s_aux)); - if (result._tag == "Some"){ - result.value.matched_type = TokenType.SP; - } - return result; - } - let newline = (x : MatcheePair) =>{ - let wrapped_x = toSome(x); - // nl = \r?\n - let result = thenDo(thenDo(wrapped_x, - zeroOrOnceDo(match1Char('\r'))), match1Char('\n')); - if (result._tag == "Some"){ - result.value.matched_type = TokenType.NL; - } + let result : tk.Maybe = process(m); + console.log(`result ${result}`) + if (result._tag == "None"){ return result; } + else{ + let matched = result.value.matched; + let return_array : tkTree[] = Array(arrange.length); - let term = (token_list : Array, x : Some)=>{ - var ln = 1; - var col = 0; - var old_x = x; - let term_list = [newline, space, integer]; - let term_aux = term_list.reduce((x,y)=> orDo(x,y)); - - var new_x : Maybe = thenDo(old_x, term_aux); - while (new_x._tag != "None"){ - if (new_x.value.matched_type != TokenType.NL){ - col += new_x.value.matched.length; - token_list.push({text : new_x.value.matched, - type: new_x.value.matched_type, - ln : ln, - col : col}); - - } - else{ - col = 0; - ln += 1; - - token_list.push({text : new_x.value.matched, - type: new_x.value.matched_type, - ln : ln, - col : col}); - - } - - - old_x = toSome({matched : "", - remained : new_x.value.remained}); - new_x = thenDo(old_x, term_aux); - } - - if (old_x.value.remained.length){ - console.log(token_list); - throw new Error("the code can't be tokenized is near Ln. "+ln+", Col."+col - +", starting with "+ old_x.value.remained.substring(0,10)); - } + arrange.forEach((val, index) => { + return_array[arrange[index]] = matched[index]; + }); - return token_list; + return return_array; + } } - - console.log(term([], input_matchee_pair)); - - // TODO: id, string, space, basic operator, 3 marks: @, {, }. - } +/** + * 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 }));