git.kianting.info Git - clo/blob - src/parser.ts

   1 /**
   2  * parser.ts - parser and js generator of clo.
   3  */
   4 import * as p from 'typescript-parsec';
   5 import { Token } from 'typescript-parsec';
   6
   7 /**
   8  *
   9  * # REPRESENTATION
  10  */
  11
  12 /**
  13  * convert a `tkTree` AST to S-expr string
  14  * @param t the `tkTree`
  15  * @returns S-expr String
  16  *
  17 export function tkTreeToSExp(t: tkTree): string{
  18     var str = "";
  19
  20     if (Array.isArray(t)){
  21         let strArray = t.map((x)=>tkTreeToSExp(x));
  22         str = "(" + strArray.join("◎") + ")";
  23     }else{
  24         if (t=== undefined){
  25             str = "%undefined"
  26         }else{
  27             str = t;
  28         }
  29     }
  30
  31     return str;
  32 }*/
  33
  34 export type tkTree = string | tkTree[];
  35
  36 export enum TokenKind {
  37     Seperator, // ---
  38     Semicolon, // ;
  39     Number,
  40     Op,
  41     ExprMark, // @
  42     ExcapeAt, // \@
  43     Paren,
  44     SpaceNL, // \s\t\n\r
  45     Id,
  46     Str,
  47     Comment, // /* ooo */
  48 }
  49
  50 /**
  51  * Parsing
  52  */
  53 export const lexer = p.buildLexer([
  54     [true, /^\d+(\.\d+)?/g, TokenKind.Number],
  55     [true, /^[\\][\\]/g, TokenKind.Op],
  56     [true, /^\\\@/g, TokenKind.ExcapeAt],
  57     [true, /^\/\*([^/]|\/[^*])*\*\//g, TokenKind.Comment],
  58     [true, /^\;/g, TokenKind.Semicolon],
  59     [true, /^[-][-][-]/g, TokenKind.Seperator],
  60     [true, /^[\+\-\*\/\&\|\!\^\<\>\~\=\?]+/g, TokenKind.Op],
  61     [true, /^\@/g, TokenKind.ExprMark],
  62     [true, /^[()\[\]{}]/g, TokenKind.Paren],
  63     [true, /^[\"]([^\"]|[\\].)*[\"]/g, TokenKind.Str],
  64     [true, /^[\']([^\']|[\\].)*[\']/g, TokenKind.Str],
  65     [true, /^[()\[\]{}]/g, TokenKind.Paren],
  66     [true, /^[^\/\\\@\s\n\t\r;]+/g, TokenKind.Id],
  67     [true, /^(\s|\n|\r|\t)+/g, TokenKind.SpaceNL],
  68
  69 ]);
  70
  71 /**
  72  *
  73  * # TEST
  74  */
  75
  76
  77
  78 export const PROG = p.rule<TokenKind, tkTree>();
  79 export const SEGMENT = p.rule<TokenKind, tkTree>();
  80 export const IMPORT = p.rule<TokenKind, tkTree>();
  81 export const IMPORTS = p.rule<TokenKind, tkTree>();
  82 export const SEMICOLON = p.rule<TokenKind, tkTree>();
  83 export const NOT_AT_TEXT = p.rule<TokenKind, tkTree>();
  84 export const CONTENT = p.rule<TokenKind, tkTree>();
  85
  86
  87 export function applySegment(input: [Token<TokenKind>, Token<TokenKind>[],
  88         Token<TokenKind>]): tkTree[]{
  89     let unpackedInnerExprs = input[1].map((x)=>{return x.text});
  90     return ["%exprs", unpackedInnerExprs];
  91 }
  92
  93 export function applySemiColon(value: Token<TokenKind.Semicolon>): tkTree{
  94     return value.text;
  95 }
  96
  97 export function applyParts(first: tkTree,
  98                     second: [Token<TokenKind>, Token<TokenKind>, tkTree]):tkTree {
  99     return ["%clo", first , second[2]];
 100 }
 101
 102 export function applyPartsWithoutImport(
 103         parsed: [Token<TokenKind>, Token<TokenKind>, tkTree]):tkTree {
 104 return ["%clo", "" , parsed[2]];
 105 }
 106
 107
 108 export function applyComment(value: Token<TokenKind.Comment>): tkTree[]{
 109     return [value.text];
 110 }
 111
 112
 113 export function applyImport(input: [Token<TokenKind>,Token<TokenKind>[], tkTree]) : tkTree{
 114     let importTail = input[1].map(x=>x.text);
 115     return ["import"].concat(importTail);
 116 };
 117
 118
 119 /*
 120 function applyImportComment(input: [Token<TokenKind>,Token<TokenKind>[],
 121     tkTree, Token<TokenKind.Comment>]) : tkTree{
 122     let importTail = input[1].map(x=>x.text);
 123     let comment = [input[3].text];
 124     return ["import"].concat(importTail).concat(comment);
 125 };*/
 126
 127 export function applyImports(input : [tkTree, tkTree[]]): tkTree{
 128     let resultBody = [input[0]].concat(input[1]);
 129     let resultWrapper = ["%import", resultBody];
 130     return resultWrapper;
 131 };
 132
 133
 134
 135
 136 export function applyNotAtText(value : Token<TokenKind>): tkTree{
 137     if (value.text == "\\\@"){
 138         return '@';
 139     }
 140     else{return value.text;}
 141 };
 142
 143 export function applyText (input : tkTree): tkTree[]{
 144     return ["%text", input];
 145 };
 146
 147 export function applyContent(input : tkTree[]): tkTree[]{
 148     return ["%content", input];
 149 };
 150
 151 export function applySpaceNL(value : Token<TokenKind.SpaceNL>): tkTree{
 152     return value.text;
 153 }
 154
 155 /**
 156  * IMPORTEE:  Number, Op, Paren, Id, Str, Comment,
 157  */
 158 export let IMPORTEE = p.alt(p.tok(TokenKind.Number),
 159     p.tok(TokenKind.Op),
 160     p.tok(TokenKind.Paren),
 161     p.tok(TokenKind.Id),
 162     p.tok(TokenKind.Str),
 163     p.tok(TokenKind.SpaceNL),
 164     p.tok(TokenKind.Comment));
 165
 166 export let NOT_AT = p.alt(p.tok(TokenKind.Seperator),
 167     p.tok(TokenKind.Semicolon),
 168     p.tok(TokenKind.Number),
 169     p.tok(TokenKind.ExcapeAt),
 170     p.tok(TokenKind.Op),
 171     p.tok(TokenKind.Paren),
 172     p.tok(TokenKind.SpaceNL),
 173     p.tok(TokenKind.Id),
 174     p.tok(TokenKind.Str),
 175     p.tok(TokenKind.Comment),
 176     );
 177
 178 /**
 179  * PROG : IMPORTS '---' NEWLINE CONTENT | '---' NEWLINE CONTNENT
 180  */
 181 PROG.setPattern(
 182     p.alt(
 183         p.lrec_sc(IMPORTS, p.seq(p.str('---'), p.str("\n"), CONTENT), applyParts),
 184         p.apply(p.seq(p.str('---'), p.str("\n"), CONTENT), applyPartsWithoutImport))
 185
 186 )
 187
 188 /**
 189  * NOT_AT_TEXT : NOT_AT
 190  */
 191 NOT_AT_TEXT.setPattern(
 192     p.apply(NOT_AT, applyNotAtText)
 193 );
 194
 195 IMPORTS.setPattern(
 196     p.apply( p.seq(IMPORT, p.rep(IMPORT)), applyImports)
 197 );
 198
 199 /**
 200  * IMPORT :
 201  * 'import' IMPORTEE* SEMICOLON |
 202  * COMMENT |
 203  */
 204 IMPORT.setPattern(
 205     p.alt(
 206         p.apply(p.seq(p.str('import'), p.rep_sc(IMPORTEE), SEMICOLON),
 207             applyImport),
 208         p.apply(p.tok(TokenKind.Comment), applyComment),
 209         p.apply(p.tok(TokenKind.SpaceNL), applySpaceNL)
 210
 211     )
 212 );
 213
 214 /**
 215  * SEMICOLON : ';';
 216  */
 217 SEMICOLON.setPattern(
 218     p.apply(p.tok(TokenKind.Semicolon), applySemiColon)
 219 );
 220
 221
 222
 223 /**
 224  * SEGMENT : '@' NOT_AT* '@' |
 225  * (NOT_AT_TEXT | EXCAPE_AT)*
 226  */
 227 SEGMENT.setPattern(
 228     p.alt(
 229         p.apply(p.rep_sc(NOT_AT_TEXT), applyText),
 230         p.apply(p.seq(p.str('@'), p.rep(NOT_AT), p.str('@')), applySegment),
 231     )
 232 );
 233
 234 /**
 235  * CONTENT : SEGMENT*
 236  */
 237 CONTENT.setPattern(
 238     p.apply(p.rep(SEGMENT), applyContent)
 239 );
 240
 241
 242
 243 /**
 244  * the head part of the output JS code : before import
 245  */
 246 export let outputHead = `
 247 /* clo, a typesetting engine, generated JS file*/
 248 /* CLO:  beginning of head*/
 249
 250 let cloLib = require("./src/libclo/index.js");
 251 let clo = new cloLib.Clo();
 252
 253 /* CLO:  end of head*/\n`
 254
 255 /**
 256  * the middle part of the output JS code : between import part and content part
 257  */
 258 export let outputMiddle =`
 259 /* CLO:  beginning of middle part*/
 260 clo.mainStream = /* CLO: end of middle part*/
 261 `
 262
 263 /**
 264  * the end part of the output JS code : after content part
 265  */
 266 export let outputEnd =`
 267 /* CLO: beginning of end part*/
 268 clo.generatePdf();
 269 /*CLO : end of end part*/
 270 `
 271
 272 /**
 273  * Convert `tree` (ASTTree; `tkTree`) to JS Code.
 274  */
 275 export function treeToJS(tree : tkTree): string{
 276
 277     let head = tree[0];
 278     if (head == "%clo"){
 279         let totalResult = outputHead + treeToJS(tree[1]) +
 280             outputMiddle + treeToJS(tree[2]) + outputEnd;
 281         return totalResult;
 282     }
 283     if (head == "%import"){
 284         let imports = tree[1];
 285         if (Array.isArray(imports)){
 286             let importsText = imports.map(
 287                 (x)=>{
 288                     if (Array.isArray(x)){
 289                         return x.join('') + ';';
 290                     }
 291                     else{
 292                         return x;
 293                     }
 294                 });
 295             let importTextCombined = importsText.join('');
 296             return importTextCombined;
 297         }
 298         else{
 299             return imports;
 300         }
 301     }
 302     if (head == "%content"){
 303         let tail = tree[1];
 304         if (Array.isArray(tail)){
 305             if (tail.length == 1){
 306                 return tail.map((x)=>treeToJS(x)).join("').concat('")+ ";";
 307             }
 308             let tailStrings = tail.map((x)=>treeToJS(x));
 309             return "(" + tailStrings.join(').concat(') + ");";
 310         }else{
 311             return tail;
 312         }
 313     }
 314     if (head == "%text"){
 315         let textContents = tree[1];
 316         if (Array.isArray(textContents)){
 317             let decoratedArray = textContents
 318                                 .flatMap(x=>String(x))
 319                                 .map(x=>x.replace("\`","\\\`"));
 320
 321             return "[`" + decoratedArray.join("\`, \`") + "`]";
 322         }else{
 323             let decorated = textContents.replace("\`","\\\`");
 324
 325             return "[`" + decorated + "`]";
 326         }
 327     }
 328
 329     if (head == "%exprs"){
 330         let content = tree[1];
 331         if (Array.isArray(content)){
 332             let flattenContent = content.flat();
 333             return flattenContent.join('');
 334         }
 335         else{
 336             return content;
 337         }
 338
 339     }
 340     else{
 341         if (Array.isArray(tree)){
 342             return tree.join('');
 343         }else{
 344             return tree;
 345         }
 346     }
 347 }
 348
 349
 350 /**
 351  * `inputText` to `tkTree` (ASTTree)
 352  */
 353 export function inputTextToTree(inputText : string){
 354     // force convert Windows newline to Linux newline
 355     inputText = inputText.replace("\r\n", "\n");
 356
 357     return p.expectSingleResult(
 358         p.expectEOF(PROG.parse(lexer.parse(inputText))));
 359 }