@futpib/parser 1.0.4 → 1.0.6

package/build/zigUnparser.d.ts

@@ -0,0 +1,2 @@
+import { type Unparser } from './unparser.js';
+export declare const zigSourceFileUnparser: Unparser<unknown, string>;

package/build/zigUnparser.js

@@ -0,0 +1,460 @@
+import { escapeZigString, escapeZigChar } from './stringEscapes.js';
+function unparseExpression(node) {
+    switch (node.type) {
+        case 'Identifier':
+            return node.name;
+        case 'IntegerLiteral':
+            return node.value;
+        case 'FloatLiteral':
+            return node.value;
+        case 'StringLiteral':
+            return '"' + escapeZigString(node.value) + '"';
+        case 'MultilineStringLiteral':
+            return node.value;
+        case 'CharLiteral':
+            return "'" + escapeZigChar(node.value) + "'";
+        case 'EnumLiteral':
+            return '.' + node.name;
+        case 'BoolLiteral':
+            return node.value ? 'true' : 'false';
+        case 'NullLiteral':
+            return 'null';
+        case 'UndefinedLiteral':
+            return 'undefined';
+        case 'BinaryExpr':
+            return unparseExpression(node.left) + ' ' + unparseBinaryOp(node.operator) + ' ' + unparseExpression(node.right);
+        case 'UnaryExpr':
+            if (node.operator === '&') {
+                return '&' + unparseExpression(node.operand);
+            }
+            return node.operator + unparseExpression(node.operand);
+        case 'FieldAccessExpr':
+            return unparseExpression(node.operand) + '.' + node.member;
+        case 'IndexExpr':
+            return unparseExpression(node.operand) + '[' + unparseExpression(node.index) + ']';
+        case 'SliceExpr': {
+            let result = unparseExpression(node.operand) + '[' + unparseExpression(node.start) + '..';
+            if (node.end) {
+                result += unparseExpression(node.end);
+            }
+            result += ']';
+            return result;
+        }
+        case 'CallExpr':
+            return unparseExpression(node.callee) + '(' + node.args.map(a => unparseExpression(a)).join(', ') + ')';
+        case 'BuiltinCallExpr':
+            return '@' + node.name + '(' + node.args.map(a => unparseExpression(a)).join(', ') + ')';
+        case 'IfExpr': {
+            let result = 'if (' + unparseExpression(node.condition) + ')';
+            if (node.capture) {
+                result += ' |' + node.capture + '|';
+            }
+            result += ' ' + unparseExpression(node.body);
+            if (node.elseBody) {
+                result += ' else';
+                if (node.elseCapture) {
+                    result += ' |' + node.elseCapture + '|';
+                }
+                result += ' ' + unparseExpression(node.elseBody);
+            }
+            return result;
+        }
+        case 'SwitchExpr': {
+            let result = 'switch (' + unparseExpression(node.operand) + ') {';
+            for (let i = 0; i < node.prongs.length; i++) {
+                if (i > 0) {
+                    result += ',';
+                }
+                result += ' ' + unparseSwitchProng(node.prongs[i]);
+            }
+            if (node.prongs.length > 0) {
+                result += ',';
+            }
+            result += ' }';
+            return result;
+        }
+        case 'StructInitExpr': {
+            let result = '';
+            if (node.operand) {
+                result += unparseExpression(node.operand);
+            }
+            else {
+                result += '.';
+            }
+            result += '{ ';
+            result += node.fields.map(f => unparseStructInitField(f)).join(', ');
+            if (node.fields.length > 0) {
+                result += ', ';
+            }
+            result += '}';
+            return result;
+        }
+        case 'ArrayInitExpr': {
+            let result = '';
+            if (node.operand) {
+                result += unparseExpression(node.operand);
+            }
+            else {
+                result += '.';
+            }
+            result += '{ ';
+            result += node.elements.map(e => unparseExpression(e)).join(', ');
+            if (node.elements.length > 0) {
+                result += ', ';
+            }
+            result += '}';
+            return result;
+        }
+        case 'TryExpr':
+            return 'try ' + unparseExpression(node.operand);
+        case 'ComptimeExpr':
+            return 'comptime ' + unparseExpression(node.operand);
+        case 'BlockExpr':
+            return unparseBlockExpr(node);
+        case 'GroupedExpr':
+            return '(' + unparseExpression(node.inner) + ')';
+        case 'ErrorSetExpr':
+            return 'error{ ' + node.names.join(', ') + ' }';
+        case 'ErrorUnionType':
+            return unparseTypeExpression(node.error) + '!' + unparseTypeExpression(node.payload);
+        case 'PointerType':
+            return unparsePointerType(node);
+        case 'OptionalType':
+            return '?' + unparseTypeExpression(node.child);
+        case 'FnProtoType':
+            return 'fn(' + node.params.map(p => unparseFnParam(p)).join(', ') + ') ' + unparseTypeExpression(node.returnType);
+        case 'StructExpr': {
+            let result = 'struct { ';
+            for (const member of node.members) {
+                result += unparseContainerMember(member) + ' ';
+            }
+            result += '}';
+            return result;
+        }
+        case 'ArrayType': {
+            let result = '[' + unparseExpression(node.length);
+            if (node.sentinel) {
+                result += ':' + unparseExpression(node.sentinel);
+            }
+            result += ']';
+            result += unparseTypeExpression(node.child);
+            return result;
+        }
+        default:
+            throw new Error(`Unknown expression type: ${node.type}`);
+    }
+}
+function unparsePointerType(node) {
+    let result = '';
+    switch (node.size) {
+        case 'one':
+            result += '*';
+            break;
+        case 'many':
+            result += '[*]';
+            break;
+        case 'slice':
+            result += '[]';
+            break;
+    }
+    if (node.isConst) {
+        result += 'const ';
+    }
+    result += unparseTypeExpression(node.child);
+    return result;
+}
+function unparseTypeExpression(node) {
+    switch (node.type) {
+        case 'IdentifierType':
+            return node.name;
+        case 'PointerType':
+            return unparsePointerType(node);
+        case 'ArrayType': {
+            let result = '[' + unparseExpression(node.length);
+            if (node.sentinel) {
+                result += ':' + unparseExpression(node.sentinel);
+            }
+            result += ']';
+            result += unparseTypeExpression(node.child);
+            return result;
+        }
+        case 'OptionalType':
+            return '?' + unparseTypeExpression(node.child);
+        case 'ErrorUnionType':
+            return unparseTypeExpression(node.error) + '!' + unparseTypeExpression(node.payload);
+        case 'DotType':
+            return unparseTypeExpression(node.operand) + '.' + node.member;
+        case 'BuiltinType':
+            return '@' + node.name;
+        case 'FnProtoType':
+            return 'fn(' + node.params.map(p => unparseFnParam(p)).join(', ') + ') ' + unparseTypeExpression(node.returnType);
+        default:
+            return unparseExpression(node);
+    }
+}
+function unparseBinaryOp(op) {
+    switch (op) {
+        case 'and':
+            return 'and';
+        case 'or':
+            return 'or';
+        case 'orelse':
+            return 'orelse';
+        case 'catch':
+            return 'catch';
+        default:
+            return op;
+    }
+}
+function unparseSwitchProng(prong) {
+    let result = '';
+    if (prong.isElse) {
+        result += 'else';
+    }
+    else {
+        result += prong.cases.map(c => unparseExpression(c)).join(', ');
+    }
+    result += ' =>';
+    if (prong.capture) {
+        result += ' |' + prong.capture + '|';
+    }
+    result += ' ' + unparseExpression(prong.body);
+    return result;
+}
+function unparseStructInitField(field) {
+    return '.' + field.name + ' = ' + unparseExpression(field.value);
+}
+function unparseBlockExpr(node) {
+    let result = '';
+    if (node.label) {
+        result += node.label + ': ';
+    }
+    result += '{ ';
+    for (const stmt of node.statements) {
+        result += unparseStatement(stmt) + ' ';
+    }
+    result += '}';
+    return result;
+}
+function unparseStatement(node) {
+    switch (node.type) {
+        case 'AssignStmt':
+            return unparseExpression(node.target) + ' ' + node.operator + ' ' + unparseExpression(node.value) + ';';
+        case 'VarDecl':
+            return unparseVarDeclCommon(node);
+        case 'IfExpr': {
+            let result = 'if (' + unparseExpression(node.condition) + ')';
+            if (node.capture) {
+                result += ' |' + node.capture + '|';
+            }
+            result += ' ' + unparseStatement(node.body);
+            if (node.elseBody) {
+                result += ' else';
+                if (node.elseCapture) {
+                    result += ' |' + node.elseCapture + '|';
+                }
+                result += ' ' + unparseStatement(node.elseBody);
+            }
+            return result;
+        }
+        case 'WhileStmt': {
+            let result = '';
+            if (node.label) {
+                result += node.label + ': ';
+            }
+            if (node.isInline) {
+                result += 'inline ';
+            }
+            result += 'while (' + unparseExpression(node.condition) + ')';
+            if (node.capture) {
+                result += ' |' + node.capture + '|';
+            }
+            if (node.continuation) {
+                result += ' : (' + unparseExpression(node.continuation) + ')';
+            }
+            result += ' ' + unparseStatement(node.body);
+            if (node.elseBody) {
+                result += ' else ' + unparseStatement(node.elseBody);
+            }
+            return result;
+        }
+        case 'ForStmt': {
+            let result = '';
+            if (node.label) {
+                result += node.label + ': ';
+            }
+            if (node.isInline) {
+                result += 'inline ';
+            }
+            result += 'for (' + node.inputs.map(i => unparseExpression(i)).join(', ') + ') |' + node.captures.join(', ') + '| ' + unparseStatement(node.body);
+            if (node.elseBody) {
+                result += ' else ' + unparseStatement(node.elseBody);
+            }
+            return result;
+        }
+        case 'ReturnStmt':
+            if (node.value) {
+                return 'return ' + unparseExpression(node.value) + ';';
+            }
+            return 'return;';
+        case 'BreakStmt': {
+            let result = 'break';
+            if (node.label) {
+                result += ' :' + node.label;
+            }
+            if (node.value) {
+                result += ' ' + unparseExpression(node.value);
+            }
+            result += ';';
+            return result;
+        }
+        case 'ContinueStmt': {
+            let result = 'continue';
+            if (node.label) {
+                result += ' :' + node.label;
+            }
+            result += ';';
+            return result;
+        }
+        case 'DeferStmt': {
+            let result = node.isErrdefer ? 'errdefer' : 'defer';
+            if (node.capture) {
+                result += ' |' + node.capture + '|';
+            }
+            result += ' ' + unparseStatement(node.body);
+            return result;
+        }
+        case 'BlockExpr':
+            return unparseBlockExpr(node);
+        default:
+            return unparseExpression(node) + ';';
+    }
+}
+function unparseVarDeclCommon(node) {
+    let result = '';
+    if (node.isPub) {
+        result += 'pub ';
+    }
+    if (node.isExtern) {
+        result += 'extern ';
+    }
+    if (node.isComptime) {
+        result += 'comptime ';
+    }
+    if (node.isThreadlocal) {
+        result += 'threadlocal ';
+    }
+    result += node.isConst ? 'const' : 'var';
+    result += ' ' + node.name;
+    if (node.typeExpr) {
+        result += ': ' + unparseTypeExpression(node.typeExpr);
+    }
+    if (node.alignExpr) {
+        result += ' align(' + unparseExpression(node.alignExpr) + ')';
+    }
+    if (node.initExpr) {
+        result += ' = ' + unparseExpression(node.initExpr);
+    }
+    result += ';';
+    return result;
+}
+function unparseFnParam(param) {
+    let result = '';
+    if (param.isComptime) {
+        result += 'comptime ';
+    }
+    if (param.isNoalias) {
+        result += 'noalias ';
+    }
+    if (param.name) {
+        result += param.name + ': ';
+    }
+    if (param.typeExpr) {
+        result += unparseTypeExpression(param.typeExpr);
+    }
+    return result;
+}
+function unparseContainerMember(node) {
+    switch (node.type) {
+        case 'FnDecl':
+            return unparseFnDecl(node);
+        case 'VarDecl':
+            return unparseVarDeclCommon(node);
+        case 'TestDecl':
+            return unparseTestDecl(node);
+        case 'UsingnamespaceDecl':
+            return unparseUsingnamespaceDecl(node);
+        case 'ContainerField':
+            return unparseContainerField(node);
+        default:
+            throw new Error(`Unknown container member type: ${node.type}`);
+    }
+}
+function unparseFnDecl(node) {
+    let result = '';
+    if (node.isPub) {
+        result += 'pub ';
+    }
+    if (node.isExtern) {
+        result += 'extern ';
+    }
+    if (node.isExport) {
+        result += 'export ';
+    }
+    if (node.isInline) {
+        result += 'inline ';
+    }
+    if (node.isComptime) {
+        result += 'comptime ';
+    }
+    result += 'fn ' + node.name + '(' + node.params.map(p => unparseFnParam(p)).join(', ') + ') ';
+    result += unparseTypeExpression(node.returnType);
+    if (node.body) {
+        result += ' ' + unparseBlockExpr(node.body);
+    }
+    else {
+        result += ';';
+    }
+    return result;
+}
+function unparseTestDecl(node) {
+    let result = 'test';
+    if (node.name) {
+        result += ' "' + escapeZigString(node.name) + '"';
+    }
+    result += ' ' + unparseBlockExpr(node.body);
+    return result;
+}
+function unparseUsingnamespaceDecl(node) {
+    let result = '';
+    if (node.isPub) {
+        result += 'pub ';
+    }
+    result += 'usingnamespace ' + unparseExpression(node.expression) + ';';
+    return result;
+}
+function unparseContainerField(node) {
+    let result = node.name;
+    if (node.typeExpr) {
+        result += ': ' + unparseTypeExpression(node.typeExpr);
+    }
+    if (node.alignExpr) {
+        result += ' align(' + unparseExpression(node.alignExpr) + ')';
+    }
+    if (node.defaultValue) {
+        result += ' = ' + unparseExpression(node.defaultValue);
+    }
+    result += ',';
+    return result;
+}
+export const zigSourceFileUnparser = async function* (input) {
+    const root = input;
+    let result = '';
+    for (let i = 0; i < root.members.length; i++) {
+        if (i > 0) {
+            result += '\n';
+        }
+        result += unparseContainerMember(root.members[i]);
+    }
+    yield result;
+};

package/build/zigUnparser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/zigUnparser.test.js

@@ -0,0 +1,24 @@
+import { testProp } from '@fast-check/ava';
+import { arbitraryZigRoot } from './arbitraryZig.js';
+import { zigSourceFileUnparser } from './zigUnparser.js';
+import { zigSourceFileParser } from './zigParser.js';
+import { runParser } from './parser.js';
+import { runUnparser } from './unparser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { stringUnparserOutputCompanion } from './unparserOutputCompanion.js';
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+async function collectString(asyncIterable) {
+    let result = '';
+    for await (const chunk of asyncIterable) {
+        result += chunk;
+    }
+    return result;
+}
+testProp('zigUnparser roundtrip', [arbitraryZigRoot], async (t, root) => {
+    const source = await collectString(runUnparser(zigSourceFileUnparser, root, stringUnparserOutputCompanion));
+    const reparsed = await runParser(zigSourceFileParser, source, stringParserInputCompanion);
+    t.deepEqual(reparsed, root);
+}, {
+    verbose: true,
+    seed,
+});

package/build/zipParser.js

@@ -4,6 +4,7 @@ import { pipeline } from 'node:stream/promises';
 import invariant from 'invariant';
 import { createArrayParser } from './arrayParser.js';
 import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createObjectParser } from './objectParser.js';
 import { setParserName } from './parser.js';
 import { createTupleParser } from './tupleParser.js';
 import { promiseCompose } from './promiseCompose.js';
@@ -66,19 +67,15 @@ const zipEncryptionHeaderParser = async (parserContext) => {
 };
 const zipDataDescriptorSignature = Buffer.from('504b0708', 'hex');
 const zipDataDescriptorSignatureParser = createExactSequenceParser(zipDataDescriptorSignature);
-const zipDataDescriptorParser = promiseCompose(createTupleParser([
-    createNegativeLookaheadParser(zipLocalFileHeaderSignatureParser),
+const zipDataDescriptorParser = createObjectParser({
+    _notZipLocalFileHeaderSignature: createNegativeLookaheadParser(zipLocalFileHeaderSignatureParser),
     // FIXME: optional in spec
-    // createOptionalParser(zipDataDescriptorSignatureParser),
-    zipDataDescriptorSignatureParser,
-    uint32LEParser,
-    uint32LEParser,
-    uint32LEParser,
-]), ([_notZipLocalFileHeaderSignature, _zipDataDescriptorSignature, crc32, compressedSize, uncompressedSize,]) => ({
-    crc32,
-    compressedSize,
-    uncompressedSize,
-}));
+    // _zipDataDescriptorSignature: createOptionalParser(zipDataDescriptorSignatureParser),
+    _zipDataDescriptorSignature: zipDataDescriptorSignatureParser,
+    crc32: uint32LEParser,
+    compressedSize: uint32LEParser,
+    uncompressedSize: uint32LEParser,
+});
 setParserName(zipDataDescriptorParser, 'zipDataDescriptorParser');
 export const zipLocalFileParser = promiseCompose(parserCreatorCompose(() => zipLocalFileHeaderParser, zipLocalFileHeader => {
     const sizeInDataDescriptor = Boolean(zipLocalFileHeader.generalPurposeBitFlag & 0b0000_0000_0000_1000
@@ -176,26 +173,16 @@ export const zip64EndOfCentralDirectoryLocatorParser = async (parserContext) =>
     parserContext.invariant(false, 'Not implemented');
 };
 const zipFileCommentParser = promiseCompose(parserCreatorCompose(() => uint16LEParser, length => createFixedLengthSequenceParser(length))(), uint8Array => Buffer.from(uint8Array).toString('utf8'));
-const zipEndOfCentralDirectoryRecordParser_ = createTupleParser([
-    createExactSequenceParser(Buffer.from('504b0506', 'hex')),
-    uint16LEParser,
-    uint16LEParser,
-    uint16LEParser,
-    uint16LEParser,
-    uint32LEParser,
-    uint32LEParser,
-    zipFileCommentParser,
-]);
-setParserName(zipEndOfCentralDirectoryRecordParser_, 'zipEndOfCentralDirectoryRecordParser_');
-export const zipEndOfCentralDirectoryRecordParser = promiseCompose(zipEndOfCentralDirectoryRecordParser_, ([_endOfCentralDirectoryRecordSignature, numberOfThisDisk, numberOfTheDiskWithTheStartOfTheCentralDirectory, totalNumberOfEntriesInTheCentralDirectoryOnThisDisk, totalNumberOfEntriesInTheCentralDirectory, sizeOfTheCentralDirectory, offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber, zipFileComment,]) => ({
-    numberOfThisDisk,
-    numberOfTheDiskWithTheStartOfTheCentralDirectory,
-    totalNumberOfEntriesInTheCentralDirectoryOnThisDisk,
-    totalNumberOfEntriesInTheCentralDirectory,
-    sizeOfTheCentralDirectory,
-    offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber,
-    zipFileComment,
-}));
+export const zipEndOfCentralDirectoryRecordParser = createObjectParser({
+    _endOfCentralDirectoryRecordSignature: createExactSequenceParser(Buffer.from('504b0506', 'hex')),
+    numberOfThisDisk: uint16LEParser,
+    numberOfTheDiskWithTheStartOfTheCentralDirectory: uint16LEParser,
+    totalNumberOfEntriesInTheCentralDirectoryOnThisDisk: uint16LEParser,
+    totalNumberOfEntriesInTheCentralDirectory: uint16LEParser,
+    sizeOfTheCentralDirectory: uint32LEParser,
+    offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber: uint32LEParser,
+    zipFileComment: zipFileCommentParser,
+});
 setParserName(zipEndOfCentralDirectoryRecordParser, 'zipEndOfCentralDirectoryRecordParser');
 const zipParser_ = createTupleParser([
     createArrayParser(zipLocalFileParser),

package/build/zipUnparser.js

@@ -78,6 +78,12 @@ export const createZipUnparser = ({ dataDescriptor = false, } = {}) => async fun
         ]);
         return [[zipEntry, promise.then(([, compressedContent]) => compressedContent)]];
     }));
+    const crc32ByZipFileEntry = new Map(zip.entries.flatMap(zipEntry => {
+        if (zipEntry.type !== 'file') {
+            return [];
+        }
+        return [[zipEntry, zlib.crc32(zipEntry.content)]];
+    }));
     const filePathByZipEntry = new Map(zip.entries.map(zipEntry => [zipEntry, zipEntry.type === 'file' ? zipEntry.path : zipEntry.path + '/']));
     const localHeaderPositionByZipEntry = new Map();
     for (const zipEntry of zip.entries) {
@@ -95,12 +101,18 @@ export const createZipUnparser = ({ dataDescriptor = false, } = {}) => async fun
             extraField: Buffer.alloc(0),
         };
         let shouldWriteDataDescriptor = false;
+        let actualCrc32 = 0;
+        let actualCompressedSize = 0;
+        let actualUncompressedSize = 0;
         if (zipEntry.type === 'file') {
             const compressedContent = await compressedContentByZipFileEntry.get(zipEntry);
             zipLocalFileHeader.compressionMethod = zipEntry.compression;
-            zipLocalFileHeader.crc32 = 0; // TODO
-            zipLocalFileHeader.compressedSize = compressedContent.length;
-            zipLocalFileHeader.uncompressedSize = zipEntry.content.length;
+            actualCrc32 = crc32ByZipFileEntry.get(zipEntry);
+            actualCompressedSize = compressedContent.length;
+            actualUncompressedSize = zipEntry.content.length;
+            zipLocalFileHeader.crc32 = actualCrc32;
+            zipLocalFileHeader.compressedSize = actualCompressedSize;
+            zipLocalFileHeader.uncompressedSize = actualUncompressedSize;
             if (dataDescriptor) {
                 shouldWriteDataDescriptor = true;
                 zipLocalFileHeader.generalPurposeBitFlag |= 0b0000_0000_0000_1000;
@@ -115,9 +127,9 @@ export const createZipUnparser = ({ dataDescriptor = false, } = {}) => async fun
             yield compressedContent;
             if (shouldWriteDataDescriptor) {
                 yield* zipDataDescriptorUnparser({
-                    crc32: zipLocalFileHeader.crc32,
-                    compressedSize: zipLocalFileHeader.compressedSize,
-                    uncompressedSize: zipLocalFileHeader.uncompressedSize,
+                    crc32: actualCrc32,
+                    compressedSize: actualCompressedSize,
+                    uncompressedSize: actualUncompressedSize,
                 }, unparserContext);
             }
         }
@@ -139,7 +151,7 @@ export const createZipUnparser = ({ dataDescriptor = false, } = {}) => async fun
         yield* dosDateTimeUnparser(zipEntry.date, unparserContext);
         if (zipEntry.type === 'file') {
             const compressedContent = await compressedContentByZipFileEntry.get(zipEntry);
-            yield* uint32LEUnparser(0, unparserContext); // Crc32 // TODO
+            yield* uint32LEUnparser(crc32ByZipFileEntry.get(zipEntry), unparserContext);
             yield* uint32LEUnparser(compressedContent.length, unparserContext);
             yield* uint32LEUnparser(zipEntry.content.length, unparserContext);
         }

package/build/zipUnparser.test.js

@@ -34,7 +34,7 @@ async function _7zList(zipFilePath) {
         throw new Error(`7z reports errors: ${stdout}`);
     }
     return {
-        isEmptyZipfile: false, // TODO
+        isEmptyZipfile: /\b0 files\b/.test(stdout),
     };
 }
 testProp('zip', [

package/node_modules-@types/s-expression/index.d.ts

@@ -0,0 +1,5 @@
+declare module 's-expression' {
+	type SExpressionResult = string | String | SExpressionResult[] | Error;
+	function sExpression(input: string): SExpressionResult;
+	export default sExpression;
+}