@ibm/ibmi-eventf-parser 1.0.0

package/dist/src/IMarkerCreator.d.ts

@@ -0,0 +1,10 @@
+import { ErrorInformationRecord } from "./record/ErrorInformationRecord";
+/**
+ * A call back object implementing this interface is called by the Parser whenever
+ * an ErrorInformationRecord is encountered.
+ * This should provide all the required information to open an editor on the original file
+ * and position or highlight the error.
+ */
+export interface IMarkerCreator {
+    createMarker(record: ErrorInformationRecord, fileLocation: string, isReadOnly: string): void;
+}

package/dist/src/IProcessor.d.ts

@@ -0,0 +1,108 @@
+import { ErrorInformationRecord } from "./record/ErrorInformationRecord";
+import { ExpansionRecord } from "./record/ExpansionRecord";
+import { FeedbackCodeRecord } from "./record/FeedbackCodeRecord";
+import { FileEndRecord } from "./record/FileEndRecord";
+import { FileIDRecord } from "./record/FileIDRecord";
+import { MapDefineRecord } from "./record/MapDefineRecord";
+import { MapEndRecord } from "./record/MapEndRecord";
+import { MapStartRecord } from "./record/MapStartRecord";
+import { ProcessorRecord } from "./record/ProcessorRecord";
+import { ProgramRecord } from "./record/ProgramRecord";
+import { TimestampRecord } from "./record/TimestampRecord";
+/**
+ * This interface defines a backbone for processing Events File Records.
+ *
+ * As the Events File Format gets more complex and more used, the parsing logic
+ * should be seperated from the processing logic. A different processor could
+ * potentially be associated with Events Files generated for different purposes.
+ *
+ * For instance, an SQL compile might need a different processor to make use of the
+ * Expansion record.
+ */
+export interface IProcessor {
+    /**
+     * Processes a File ID record object.
+     * @param record The File ID record.
+     */
+    processFileIDRecord(record: FileIDRecord): void;
+    /**
+     * Processes a File End record object.
+     * @param record The File End record.
+     */
+    processFileEndRecord(record: FileEndRecord): void;
+    /**
+     * Processes a Processor record object.
+     * @param record The Processor record.
+     */
+    processProcessorRecord(record: ProcessorRecord): void;
+    /**
+     * Processes a Timestamp record object.
+     * @param record The Timestamp record.
+     */
+    processTimestampRecord(record: TimestampRecord): void;
+    /**
+     * Processes an Error record object.
+     * @param record The Error record.
+     */
+    processErrorRecord(record: ErrorInformationRecord): void;
+    /**
+     * Processes a Program record object.
+     * @param record The Program record.
+     */
+    processProgramRecord(record: ProgramRecord): void;
+    /**
+     * Processes a Feedback Code record object.
+     * @param record The Feedback Code record.
+     */
+    processFeedbackCodeRecord(record: FeedbackCodeRecord): void;
+    /**
+     * Processes a Map Define record object.
+     * @param record The Map Define record.
+     */
+    processMapDefineRecord(record: MapDefineRecord): void;
+    /**
+     * Processes a Map Start record object.
+     * @param record The Map Start record.
+     */
+    processMapStartRecord(record: MapStartRecord): void;
+    /**
+     * Processes a Map End record object.
+     * @param record The Map End record.
+     */
+    processMapEndRecord(record: MapEndRecord): void;
+    /**
+     * Processes an Expansion record object.
+     * @param record The Expansion record.
+     */
+    processExpansionRecord(record: ExpansionRecord): void;
+    /**
+     * After parsing all records in the Events File, this method will be called to
+     * process the records.
+     *
+     * @return True if post-processing was succesful or false otherwise.
+     */
+    doPostProcessing(): boolean;
+    /**
+     * Before parsing all records in the Events File, this method will be called to
+     * allow the processor to perform initialization.
+     *
+     * @return True if pre-processing was succesful or false otherwise.
+     */
+    doPreProcessing(): boolean;
+    /**
+     * After all records in the Events File are processed, this method is called to
+     * return all the errors from all the processor blocks (ProcessorBlock) of the
+     * Events File. Since each ProcessorBlock contains an array of errors, the result
+     * will be returned as a array of those arrays.
+     *
+     * @return An array of arrays of all parsed errors from all processor blocks of
+     * the Events File (one list for each processor block).
+     */
+    getAllErrors(): ErrorInformationRecord[][];
+    /**
+     * Return all file ID records.
+     *
+     * @return An array of all file ID records.
+     */
+    getAllFileIDRecords(): FileIDRecord[];
+}

package/dist/src/ISequentialFileReader.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Iterates through a sequential file and provides one line at a time.
+ */
+export interface ISequentialFileReader {
+    /**
+     * Get the next line.
+     *
+     * @return The next line.
+     **/
+    readNextLine(): string | undefined;
+}

package/dist/src/MapTable.d.ts

@@ -0,0 +1,78 @@
+import { ErrorInformationRecord } from "./record/ErrorInformationRecord";
+import { ExpansionRecord } from "./record/ExpansionRecord";
+import { FileEndRecord } from "./record/FileEndRecord";
+import { FileIDRecord } from "./record/FileIDRecord";
+export declare class MapTable {
+    private map;
+    private queueExpansion;
+    private files;
+    private lookupIndex;
+    private fileTable;
+    constructor();
+    /**
+     * Adds file information to the map.
+     *
+     * @param Tecord The File ID record.
+     */
+    addFileInformation(record: FileIDRecord): void;
+    /**
+     * Adds file information only to the file table. This is useful for processing the
+     * compiler (000) processor block, since we don't need to keep track of line mappings
+     * and FileIDLinesPair pairings.
+     *
+     * @param record The File ID record
+     */
+    addFileToFileTable(record: FileIDRecord): void;
+    /**
+     * Sets the correct bounds for the files in the map that were added using `AddFileInformation()`.
+     *
+     * @param record The File End record that contains the number of lines in the source.
+     */
+    closeFile(record: FileEndRecord): void;
+    /**
+     * Create a `SourceLineRange` with open bounds. The bounds will be set once the FileEnd record is read.
+     *
+     * @param record The FileID record that contains information about where the `SourceLineRange` should start.
+     */
+    private createOpenEndedSourceLineRange;
+    addExpansionRecord(record: ExpansionRecord): void;
+    private getSourceLineRangeForOutputLine;
+    private optimizedSourceLineRangeLookup;
+    private getSourceLineRangeForInputLine;
+    private shiftRangesBy;
+    private handleExpansion;
+    private splitExpandedSourceLineRange;
+    private createSourceLineRange;
+    /**
+     * Returns the QSYSEventsFileFileIDRecord corresponding to a file ID.
+     *
+     * @param ID The ID of the file to look for.
+     * @return The FileIDRecord corresponding to the file ID if it exists in the table, `undefined` otherwise.
+     */
+    getFileIDRecordForFileID(ID: string): FileIDRecord | undefined;
+    getFileLocationForFileID(ID: string): string | undefined;
+    /**
+     * Modifies the information contained in the Error record based on the available map.
+     *
+     * @param record The Error record to be modified.
+     */
+    modifyErrorInformation(record: ErrorInformationRecord): void;
+    /**
+     * Calculates the line number based on the initial number and how many lines where
+     * shifted in the expansion process.
+     *
+     * @param range `SourceLineRange` that contains mapping information.
+     * @param initial The line number.
+     * @return The new line number.
+     */
+    private getLineFromSourceLineRange;
+    finalizeMap(): void;
+    /**
+     * Prints the map.
+     */
+    toString(): string;
+    /**
+     * Get all file locations.
+     */
+    getAllFileIDRecords(): FileIDRecord[];
+}

package/dist/src/Parser.d.ts

@@ -0,0 +1,51 @@
+import { FileIDRecord } from './record/FileIDRecord';
+import { IProcessor } from './IProcessor';
+import { ISequentialFileReader } from './ISequentialFileReader';
+import { IMarkerCreator } from './IMarkerCreator';
+import { ErrorInformationRecord } from './record/ErrorInformationRecord';
+export declare class Parser {
+    static LOGGER: any;
+    private exception;
+    private processor;
+    private lastOutputFile;
+    private currentOutputFile;
+    private sourceTable;
+    constructor();
+    private getUntilTheEndOfTheLine;
+    private log;
+    /**
+     * To parse an eventf generated by an IBM i compiler.
+     * @param fileName local file containing the eventf encoded in UTF-8
+     * @param markerCreator optionally passing in an object implementing IMarkerCreator
+     *   allows the parser to call this object back with each error.  The original source
+     *   file name and error location and error message will be in the information provided
+     *   on the callback
+     */
+    parseFile(fileName: string, markerCreator?: IMarkerCreator): void;
+    parse(fileReader: ISequentialFileReader, markerCreator?: IMarkerCreator): void;
+    private resolveRelativePath;
+    getException(): Error | undefined;
+    setProcessor(processor: IProcessor): void;
+    /**
+     * After all records in the Events File are processed, this method is called to
+     * return all the errors from all the processor blocks (ProcessorBlock) of the
+     * Events File. Since each ProcessorBlock contains an array of errors, the result
+     * will be flattened to an array.
+     *
+     * @return An array of all parsed errors from all processor blocks of the Events File.
+     */
+    getAllErrors(): ErrorInformationRecord[];
+    /**
+     * Get all file ID records.
+     *
+     * @return An array of all file ID records.
+     */
+    getAllFileIDRecords(): FileIDRecord[];
+}
+export default class FileReader implements ISequentialFileReader {
+    file: string;
+    linesArray: string[];
+    currLineNum: number;
+    constructor(fileName: string);
+    readNextLine(): string | undefined;
+}

package/dist/src/ProcessorBlock.d.ts

@@ -0,0 +1,93 @@
+import { ErrorInformationRecord } from "./record/ErrorInformationRecord";
+import { FileEndRecord } from "./record/FileEndRecord";
+import { FileIDRecord } from "./record/FileIDRecord";
+import { MapTable } from "./MapTable";
+import { ProcessorRecord } from "./record/ProcessorRecord";
+export declare class ProcessorBlock {
+    readonly INPUT_FILE_ID: string;
+    private errors;
+    private inputFile;
+    private outputFile;
+    private currentProcessor;
+    private mappingTable;
+    private previousProcessorBlock;
+    private containsExpansionEvents;
+    private isFirstInEventsFile;
+    private mappingSupported;
+    private totalNumberOfLinesInOutputFile;
+    private totalNumberOfLinesInInputFiles;
+    constructor(record: ProcessorRecord);
+    getInputFile(): FileIDRecord | undefined;
+    /**
+     * Get the input file of the first processor block of the current events file.
+     *
+     * @return the input file of the first processor block of the current events file.
+     */
+    getInitialInputFile(): FileIDRecord | undefined;
+    setInputFile(file: FileIDRecord): void;
+    addFile(file: FileIDRecord): void;
+    closeFile(file: FileEndRecord): void;
+    getOutputFile(): FileIDRecord | undefined;
+    setOutputFile(file: FileIDRecord): void;
+    getMappingTable(): MapTable;
+    isProcessorIDZero(): boolean;
+    addErrorInformation(record: ErrorInformationRecord): void;
+    processorEnded(): void;
+    setPreviousProcessor(previous: ProcessorBlock): void;
+    setContainsExpansionEvents(containsExpansionEvents: boolean): void;
+    getContainsExpansionEvents(): boolean;
+    increaseTotalNumberOfLinesInInputFiles(numberOfLines: number): void;
+    getTotalNumberOfLinesInInputFiles(): number;
+    setTotalNumberOfLinesInOutputFile(numberOfLines: number): void;
+    getTotalNumberOfLinesInOutputFile(): number;
+    getPreviousProcessorBlock(): ProcessorBlock | undefined;
+    modifyErrorInformation(error: ErrorInformationRecord): void;
+    /**
+     * Sets whether the current processor block is the first one in the current "sub" events file
+     * (needed for events file that contains multiple events files that have been combined into one).
+     *
+     * @param isFirstInEventsFile
+     */
+    setFirstInEventsFile(isFirstInEventsFile: boolean): void;
+    /**
+     * Returns whether the current processor block is the first one in the current "sub" events file
+     * (needed for events file that contains multiple events files that have been combined into one).
+     *
+     * @return True if the current processor block is the first one in the current "sub" events file, false otherwise.
+     */
+    getIsFirstInEventsFile(): boolean;
+    setMappingSupported(mappingSupported: boolean): void;
+    isMappingSupported(): boolean;
+    /**
+     * Determines whether a file in the current processor block is read-only or not.
+     * A file is considered read-only if it is a temporary file created by an SQL pre-compiler.
+     *
+     * @param fileRecord The FileIDRecord of the file to check.
+     * @return True if the file is read-only, false otherwise.
+     */
+    isFileReadOnly(fileIDRecord: FileIDRecord): boolean;
+    /**
+     * This method is used by the test for event file processing.
+     *
+     * This method returns all errors in this and all previous processor blocks.
+     * Since each ProcessorBlock contains an array of errors, the result will be
+     * returned as an array of those arrays.
+     *
+     * This method is called by ExpansionProcessor.getAllErrors().
+     *
+     * @return An array of arrays of all parsed errors from the current and all
+     * previous processor blocks (one list for each processor block).
+     */
+    getAllProcessorErrors(): ErrorInformationRecord[][];
+    resolveFileNamesForAllErrors(): void;
+    /**
+     * Maps the error back to the original input member and resolves the
+     * filename of that member. If mappings are not supported, checks and
+     * returns whether that member is read-only.
+     *
+     * @param error The ErrorInformationRecord to resolve.
+     * @return True if mappings are not supported and the member that the
+     * error points to is read-only, false otherwise.
+     */
+    resolveFileNameAndDetermineIfReadOnly(error: ErrorInformationRecord): boolean;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export { Parser } from "./Parser";
+export { ErrorInformationRecord } from "./record/ErrorInformationRecord";
+export { IMarkerCreator } from "./IMarkerCreator";

package/dist/src/record/ErrorInformationRecord.d.ts

@@ -0,0 +1,161 @@
+import { IRecordT } from "./IRecordT";
+import { IRecord } from "./IRecord";
+/**
+ * This class represents a Error Information record in an events file.
+ */
+export declare class ErrorInformationRecord implements IRecord {
+    private version;
+    private fileId;
+    private annotClass;
+    private stmtLine;
+    private startErrLine;
+    private tokenStart;
+    private endErrLine;
+    private tokenEnd;
+    private msgId;
+    private sevChar;
+    private sevNum;
+    private length;
+    private msg;
+    private fileName;
+    constructor(version: string, fileId: string, annotClass: string, stmtLine: string, startErrLine: string, tokenStart: string, endErrLine: string, tokenEnd: string, msgId: string, sevChar: string, sevNum: string, length: string, msg: string);
+    getRecordType(): IRecordT;
+    /**
+     * Get the version.
+     *
+     * @return The version.
+     */
+    getVersion(): string;
+    /**
+     * Get the file id.
+     *
+     * @return The file id.
+     */
+    getFileId(): string;
+    /**
+     * Set the file id.
+     *
+     * @param fileId The file id.
+     */
+    setFileId(fileId: string): void;
+    /**
+     * Get the file name.
+     *
+     * @return The file id.
+     */
+    getFileName(): string;
+    /**
+     * Set the file name.
+     *
+     * @param fileName The file id.
+     */
+    setFileName(fileName: string): void;
+    /**
+     * Get the annotation class.
+     *
+     * @return The annotation class.
+     */
+    getAnnotClass(): string;
+    /**
+     * Set the annotation class.
+     *
+     * @param annotClass The annotation class.
+     */
+    setAnnotClass(annotClass: string): void;
+    /**
+     * Get the statement line.
+     *
+     * @return The statement line.
+     */
+    getStmtLine(): string;
+    /**
+     * Set the statement line.
+     *
+     * @param stmtLine The statement line.
+     */
+    setStmtLine(stmtLine: string): void;
+    /**
+     * Get the starting error line.
+     *
+     * @return The starting error line.
+     */
+    getStartErrLine(): string;
+    /**
+     * Set the starting error line.
+     *
+     * @param startErrLine The starting error line.
+     */
+    setStartErrLine(startErrLine: string): void;
+    /**
+     * Get the starting error column.
+     *
+     * @return The starting error column.
+     */
+    getTokenStart(): string;
+    /**
+     * Set the starting error column.
+     *
+     * @param tokenStart The starting error column.
+     */
+    setTokenStart(tokenStart: string): void;
+    /**
+     * Get the ending error line.
+     *
+     * @return The ending error line.
+     */
+    getEndErrLine(): string;
+    /**
+     * Set the ending error line.
+     *
+     * @param endErrLine The ending error line.
+     */
+    setEndErrLine(endErrLine: string): void;
+    /**
+     * Get the ending error column.
+     *
+     * @return The ending error column.
+     */
+    getTokenEnd(): string;
+    /**
+     * Set the ending error column.
+     *
+     * @param tokenEnd The ending error column.
+     */
+    setTokenEnd(tokenEnd: string): void;
+    /**
+     * Get the message id.
+     *
+     * @return The message id.
+     */
+    getMsgId(): string;
+    /**
+     * Get the severity code.
+     *
+     * @return The severity code.
+     */
+    getSevChar(): string;
+    /**
+     * Get the severity level number.
+     *
+     * @return The severity level number.
+     */
+    getSevNum(): string;
+    /**
+     * Get the length of the message.
+     *
+     * @return The length of the message.
+     */
+    getLength(): string;
+    /**
+     * Set the length of the message.
+     *
+     * @param length The length of the message.
+     */
+    setLength(length: string): void;
+    /**
+     * Get the message.
+     *
+     * @return The message.
+     */
+    getMsg(): string;
+}

package/dist/src/record/ExpansionRecord.d.ts

@@ -0,0 +1,100 @@
+import { IRecordT } from "./IRecordT";
+import { IRecord } from "./IRecord";
+/**
+ * This class represents an Expansion record in an Events File.
+ */
+export declare class ExpansionRecord implements IRecord {
+    private version;
+    private inputFileID;
+    private inputLineStart;
+    private inputLineEnd;
+    private outputFileID;
+    private outputLineStart;
+    private outputLineEnd;
+    constructor(version: string, inputFileID: string, inputLineStart: string, inputLineEnd: string, outputFileID: string, outputLineStart: string, outputLineEnd: string);
+    getRecordType(): IRecordT;
+    /**
+     * Get the version.
+     *
+     * @return The version.
+     */
+    getVersion(): string;
+    /**
+     * Set the version.
+     *
+     * @param version The version.
+     */
+    setVersion(version: string): void;
+    /**
+     * Get the input file ID.
+     *
+     * @return The input file ID.
+     */
+    getInputFileID(): string;
+    /**
+     * Set the input file ID.
+     *
+     * @param fileID The input file ID.
+     */
+    setInputFileID(fileID: string): void;
+    /**
+     * Get the input line start.
+     *
+     * @return The input line start.
+     */
+    getInputLineStart(): string;
+    /**
+     * Set the input line start.
+     *
+     * @param lineStart The input line start.
+     */
+    setInputLineStart(lineStart: string): void;
+    /**
+     * Get the input line end.
+     *
+     * @return The input line end.
+     */
+    getInputLineEnd(): string;
+    /**
+     * Set the input line end.
+     *
+     * @param lineEnd The input line end.
+     */
+    setInputLineEnd(lineEnd: string): void;
+    /**
+     * Get the output file ID.
+     *
+     * @return The output file ID.
+     */
+    getOutputFileID(): string;
+    /**
+     * Set the output file ID.
+     *
+     * @param fileID The output file ID.
+     */
+    setOutputFileID(fileID: string): void;
+    /**
+     * Get the output line start.
+     *
+     * @return The output line start.
+     */
+    getOutputLineStart(): string;
+    /**
+     * Set the output line start.
+     *
+     * @param lineStart The output line start.
+     */
+    setOutputLineStart(lineStart: string): void;
+    /**
+     * Get the output line end.
+     *
+     * @return The output line end.
+     */
+    getOutputLineEnd(): string;
+    /**
+     * Set the output line end.
+     *
+     * @param lineEnd The output line end.
+     */
+    setOutputLineEnd(lineEnd: string): void;
+}

package/dist/src/record/FeedbackCodeRecord.d.ts

@@ -0,0 +1,35 @@
+import { IRecordT } from "./IRecordT";
+import { IRecord } from "./IRecord";
+/**
+ * This class represents a Feedback Code record in an events file.
+ */
+export declare class FeedbackCodeRecord implements IRecord {
+    private returnCode;
+    private reasonCode;
+    constructor(returnCode: string, reasonCode: string);
+    getRecordType(): IRecordT;
+    /**
+     * Get the return code.
+     *
+     * @return The return code.
+     */
+    getReturnCode(): string;
+    /**
+     * Set the return code.
+     *
+     * @param returnCode The return code.
+     */
+    setReturnCode(returnCode: string): void;
+    /**
+     * Get the reason code.
+     *
+     * @return The reason code.
+     */
+    getReasonCode(): string;
+    /**
+     * Set the reason code.
+     *
+     * @param reasonCode The reason code.
+     */
+    setReasonCode(reasonCode: string): void;
+}