jcledisef.pas

East make Tray Icon in delphi

    end
    else // Repeating data block (K = 1 on the first pass)
    begin
      // Get repeat count
      N := StrSearch(SEFDelimiter_OpeningBracket, Data, K);
      RepeatCount := StrToInt(Copy(Data, K + 1, (N - K) - 1));
      // Correct start position
      K := StrSearch(SEFDelimiter_OpeningBracket, Data, K);
      // Validate end position
      N := StrSearch(SEFDelimiter_OpeningBrace, Data, K + 1);
      while (N <> 0) and (N < L) do // Detect nested repetition
      begin
        N := StrSearch(SEFDelimiter_OpeningBrace, Data, N + 1); // Search for nested repetition
        L := StrSearch(SEFDelimiter_ClosingBrace, Data, L + 1); // Correct end position
      end;
      // Copy data for repetition
      RepeatData := Copy(Data, K, L - K);
      M := L + 1;
      // Handle Repeating Data Block
      RepeatingPattern := AddRepeatingPatternTo(Segment);
      RepeatingPattern.RepeatCount := RepeatCount;
      RepeatingPattern.Data := RepeatData;
      RepeatingPattern.Disassemble;
    end;
  end;
  // Store Currently Unused Data
  if (M <= Length(Data)) and (Segment is TEDISEFSegment) then
    TEDISEFSegment(Segment).FExtendedData := Copy(Data, M, (Length(Data) - M) + 1);
end;

procedure ParseSEGSDataOfSEGSDefinition(Data: string; Segment: TEDISEFSegment;
  SEFFile: TEDISEFFile);
begin
  InternalParseSEGSDataOfSEGSDefinition(Data, Segment, SEFFile);
end;

function CombineSEGSDataOfSEGSDefinition(Segment: TEDISEFSegment): string;
var
  ListItem: TEDISEFDataObjectListItem;
begin
  Result := Segment.Id + SEFDelimiter_EqualSign;
  ListItem := Segment.EDISEFDataObjects.First;
  while ListItem <> nil do
  begin
    if not (ListItem.EDISEFDataObject is TEDISEFRepeatingPattern) then
      Result := Result + SEFDelimiter_OpeningBracket + ListItem.EDISEFDataObject.Assemble +
        SEFDelimiter_ClosingBracket
    else
      Result := Result + SEFDelimiter_OpeningBrace + ListItem.EDISEFDataObject.Assemble +
        SEFDelimiter_ClosingBrace;
    ListItem := ListItem.NextItem;
  end;
  Result := Result + Segment.FExtendedData;
end;

procedure ParseSEGSDataOfSETSDefinition(Data: string; Segment: TEDISEFSegment;
  SEFFile: TEDISEFFile);
var
  Temp: TStringList;
  ListItem: TEDISEFDataObjectListItem;
  SegmentDef: TEDISEFSegment;
  I, J, K: Integer;
begin
  Segment.UserAttribute := '';
  Segment.Ordinal := -1;
  Segment.RequirementDesignator := Value_Optional;
  Segment.MaximumUse := 1;
  Segment.EDISEFDataObjects.Clear;
  Temp := TStringList.Create;
  try
    Temp.CommaText := Data;
    if Temp.Count >= 1 then
    begin
      I := 1;
      // Parse User Attribute
      if Temp[0][1] in EDISEFUserAttributeSet then
      begin
        Segment.UserAttribute := Temp[0][1];
        I := 2;
      end;
      J := StrSearch(SEFDelimiter_Asterisk, Temp[0], 1);
      K := StrSearch(SEFDelimiter_AtSign, Temp[0], 1);
      // Parse Mask Number
      if J <> 0 then
      begin
        Segment.FMaskNumberSpecified := True;
        if K = 0 then
          Segment.FMaskNumber := StrToInt(Copy(PChar(Temp[0]), J + 1, Length(PChar(Temp[0])) - J))
        else
          Segment.FMaskNumber := StrToInt(Copy(PChar(Temp[0]), J + 1, (K - J) - 1));
      end;
      // Parse Explicitly Assigned Ordinal
      if K <> 0 then
        Segment.Ordinal := StrToInt(Copy(PChar(Temp[0]), K + 1, Length(PChar(Temp[0])) - K));
      // Parse Segment Id
      if (J = 0) and (K = 0) then
      begin
        if I = 1 then
          Segment.Id := Temp[0]
        else // Had to cast Temp[0] as PChar here because of a bug during runtime
          Segment.Id := Copy(PChar(Temp[0]), I, Length(PChar(Temp[0])) - 1);
      end
      else                                               
      begin
        K := Length(PChar(Temp[0])) - 1;  
        if (J < K) and (J <> 0) then
          K := J;
        Segment.Id := Copy(PChar(Temp[0]), I, K - I);
      end;
    end;
    ListItem := SEFFile.SEGS.FindItemByName(Segment.Id);
    if (ListItem <> nil) and (ListItem.EDISEFDataObject <> nil) then
    begin
      SegmentDef := TEDISEFSegment(ListItem.EDISEFDataObject);
      Segment.Assign(SegmentDef);
    end;
    if Temp.Count >= 2 then
    begin
      if Temp[1] = '' then
        Temp[1] := Value_Optional;
      Segment.RequirementDesignator := Temp[1];
    end;
    if Temp.Count >= 3 then
    begin
      if Temp[2] = Value_GreaterThanOne then
        Temp[2] := IntToStr(Value_UndefinedMaximum);
      Segment.MaximumUse := StrToInt(Temp[2]);
    end;
  finally
    Temp.Free;
  end;
end;

function CombineSEGSDataOfSETSDefinition(Segment: TEDISEFSegment): string;
begin
  if Segment.UserAttribute <> '' then
    Result := Result + Segment.UserAttribute;
  Result := Result + Segment.Id;
  if Segment.FMaskNumberSpecified then
    Result := Result + SEFDelimiter_Asterisk + IntToStr(Segment.FMaskNumber);
  if Segment.OutOfSequenceOrdinal then
    Result := Result + SEFDelimiter_AtSign + IntToStr(Segment.Ordinal);
  if (Segment.RequirementDesignator <> '') and
    (Segment.RequirementDesignator <> Value_Optional) then
    Result := Result + SEFDelimiter_Comma + Segment.RequirementDesignator;
  if Segment.MaximumUse > 1 then
  begin
    if (Segment.RequirementDesignator = '') or
      (Segment.RequirementDesignator = Value_Optional) then
      Result := Result + SEFDelimiter_Comma;
    if Segment.MaximumUse >= Value_UndefinedMaximum then    
      Result := Result + SEFDelimiter_Comma + Value_GreaterThanOne
    else
      Result := Result + SEFDelimiter_Comma + IntToStr(Segment.MaximumUse);
  end;
end;

procedure ParseLoopDataOfSETSDefinition(Data: string; Loop: TEDISEFLoop;
  SEFFile: TEDISEFFile);
var
  I, J, K, L, M, N: Integer;
  SegmentData: string;
  PositionIncrement: string;  
  RepeatCount: Integer;
  LoopId, RepeatData: string;
  Segment: TEDISEFSegment;
  NestedLoop: TEDISEFLoop;
  ListItem: TEDISEFDataObjectListItem;
begin
  Loop.EDISEFDataObjects.Clear;
  I := 1;
  M := I;
  // Search for Loops and Segments
  while I > 0 do
  begin
    // Start search
    I := StrSearch(SEFDelimiter_OpeningBracket, Data, M);
    if I = 0 then
      Break;
    J := StrSearch(SEFDelimiter_ClosingBracket, Data, M);
    K := StrSearch(SEFDelimiter_OpeningBrace, Data, M);
    L := StrSearch(SEFDelimiter_ClosingBrace, Data, M);
    // Determine if data block to process is a repetition
    if (I < K) or (K = 0) then // Normal data block
    begin
      L := M;
      M := StrSearch(SEFDelimiter_PlusSign, Data, L);
      N := StrSearch(SEFDelimiter_MinusSign, Data, L);
      L := 0;
      if (M < I) and (M <> 0) then
        L := M;
      if (N < I) and (N <> 0) then
        L := N;
      if L <> 0 then
        PositionIncrement := Copy(Data, L, (I - L));      

      SegmentData := Copy(Data, I + 1, (J - I) - 1);
      //
      Segment := Loop.AddSegment;
      Segment.SEFFile := SEFFile;
      if L <> 0 then
      begin
        Segment.ResetPositionInc := True;
        Segment.PositionIncrement := StrToInt(PositionIncrement);
      end;
      Segment.Data := SegmentData;
      Segment.Disassemble;
      if Loop.Id = '' then
        Loop.Id := Segment.Id;
      M := J + 1;
    end
    else // Repeating data block (K = 1 on the first pass)
    begin
      N := StrSearch(SEFDelimiter_OpeningBracket, Data, K);
      J := StrSearch(SEFDelimiter_PlusSign, Data, K);
      M := StrSearch(SEFDelimiter_MinusSign, Data, K);
      // Adjustments
      if (J < N) and (J <> 0) then
        N := J;
      if (M < N) and (M <> 0) then
        N := M;
      // Get Loop Id: <Id>:<Repeat>+<Number>[<Id>]..."
      RepeatData := Copy(Data, K + 1, (N - K) - 1);
      J := StrSearch(SEFDelimiter_Colon, RepeatData, 1);
      if J = 0 then
      begin
        LoopId := RepeatData;
        RepeatData := '';
      end
      else
      begin
        LoopId := Copy(RepeatData, 1, J - 1);
        RepeatData := Copy(RepeatData, J + 1, Length(RepeatData) - J);
      end;
      // Get Repeat Count
      if RepeatData = Value_GreaterThanOne then
        RepeatData := IntToStr(Value_UndefinedMaximum);
      if RepeatData = '' then
        RepeatData := Value_One;
      RepeatCount := StrToInt(RepeatData);
      // Correct start position
      K := N;      
      // Validate end position
      N := StrSearch(SEFDelimiter_OpeningBrace, Data, K + 1);
      while (N <> 0) and (N < L) do // Detect nested repetition
      begin
        N := StrSearch(SEFDelimiter_OpeningBrace, Data, N + 1); // Search for nested repetition
        L := StrSearch(SEFDelimiter_ClosingBrace, Data, L + 1); // Correct end position
      end;
      // Copy data for repetition
      RepeatData := Copy(Data, K, L - K);
      //
      M := L + 1;
      // Create Loop Object
      NestedLoop := Loop.AddLoop;
      NestedLoop.SEFFile := SEFFile;
      NestedLoop.LoopId := LoopId;
      NestedLoop.MaximumRepeat := RepeatCount;                
      NestedLoop.Data := RepeatData;
      NestedLoop.Disassemble;
      if NestedLoop.LoopId = '' then
      begin
        ListItem := NestedLoop.EDISEFDataObjects.First;
        NestedLoop.LoopId := ListItem.EDISEFDataObject.Id;
      end;
    end;
  end;
end;

procedure ParseTableDataOfSETSDefinition(Data: string; Table: TEDISEFTable;
  SEFFile: TEDISEFFile);
var
  I, J, K, L, M, N: Integer;
  SegmentData: string;
  PositionIncrement: string;
  RepeatCount: Integer;
  LoopId, RepeatData: string;
  Segment: TEDISEFSegment;
  Loop: TEDISEFLoop;
  ListItem: TEDISEFDataObjectListItem;
begin
  Table.EDISEFDataObjects.Clear;
  I := 1;
  M := I;
  // Search for Loops and Segments
  while I > 0 do
  begin
    // Start search
    I := StrSearch(SEFDelimiter_OpeningBracket, Data, M);
    if I = 0 then
      Break;
    J := StrSearch(SEFDelimiter_ClosingBracket, Data, M);
    K := StrSearch(SEFDelimiter_OpeningBrace, Data, M);
    L := StrSearch(SEFDelimiter_ClosingBrace, Data, M);
    // Determine if data block to process is a repetition
    if (I < K) or (K = 0) then // Normal data block
    begin
      L := M;
      M := StrSearch(SEFDelimiter_PlusSign, Data, L);
      N := StrSearch(SEFDelimiter_MinusSign, Data, L);
      L := 0;
      if (M < I) and (M <> 0) then
        L := M;
      if (N < I) and (N <> 0) then
        L := N;
      if L <> 0 then
        PositionIncrement := Copy(Data, L, (I - L));          

      SegmentData := Copy(Data, I + 1, (J - I) - 1);
      //
      Segment := Table.AddSegment;
      Segment.SEFFile := SEFFile;
      if L <> 0 then
      begin
        Segment.ResetPositionInc := True;
        Segment.PositionIncrement := StrToInt(PositionIncrement);
      end;
      Segment.Data := SegmentData;
      Segment.Disassemble;
      M := J + 1;
    end
    else // Repeating data block (K = 1 on the first pass)
    begin
      N := StrSearch(SEFDelimiter_OpeningBracket, Data, K);
      J := StrSearch(SEFDelimiter_PlusSign, Data, K);
      M := StrSearch(SEFDelimiter_MinusSign, Data, K);
      // Adjustments - N becomes the start position of RepeatData
      if (J < N) and (J <> 0) then
        N := J;
      if (M < N) and (M <> 0) then
        N := M;
      // Get Loop Id: {<Loop Id>:<Repeat><+or-><Position Increment>[<Segment Id>]..."
      RepeatData := Copy(Data, K + 1, (N - K) - 1);
      J := StrSearch(SEFD