source: trunk/UKConfig.pas

unit UKConfig;

// Kconfig format specification:
// https://www.kernel.org/doc/Documentation/kbuild/kconfig-language.txt

{$mode Delphi}{$H+}

interface

uses
  Classes, SysUtils, Contnrs, FileUtil, ComCtrls;

type
  TValueType = (vtNone, vtBool, vtTristate, vtString, vtInt, vtHex, vtChoice,
    vtComment);

  TMenuNode = class;
  TLoadTreeOption = (toShowSystem);
  TLoadTreeOptions = set of TLoadTreeOption;
  TObjectMove = record
    Source: TObject;
    NewParent: TObject;
  end;
  TObjectMoves = array of TObjectMove;

  TExpOperator = (eoAnd, eoOr);

  { TExpression }

  TExpression = class
    ExpOperator: TExpOperator;
    Items: TObjectList; // TList<TExpression>
    Parent: TExpression;
    function Show: String; virtual;
    function CanBeTrue: Boolean; virtual;
    procedure GetList(List: TStringList); virtual;
    constructor Create; virtual;
    destructor Destroy; override;
  end;

  TCompareType = (ctNone, ctEqual, ctNotEqual);

  { TExpressionVar }

  TExpressionVar = class(TExpression)
    Name: string;
    //Node: TMenuNode;
    Negative: Boolean;
    Compare: TCompareType;
    Value: string;
    function CompareValue: Boolean;
    function CanBeTrue: Boolean; override;
    constructor Create; override;
    procedure GetList(List: TStringList); override;
    function Show: String; override;
  end;

  { TMenuNode }

  TMenuNode = class
  private
    function GetVisible: Boolean;
  public
    ID: string;
    Name: string;
    DependsOn: TExpression;
    Selects: TStringList;
    Description: TStringList;
    Items: TObjectList; // TList<TMenuNode>
    Parent: TMenuNode;
    //NewParent: TMenuNode;
    DefaultValue: string;
    ValueType: TValueType;
    RangeMin: string;
    RangeMax: string;
    MenuConfig: Boolean;
    Optional: Boolean;
    constructor Create; virtual;
    destructor Destroy; override;
    procedure ChangeParent(NewParent: TMenuNode);
    procedure AddLastToList(List: TObjectList);
    function GetName: string; virtual;
    function GetAbsoluteName: string; virtual;
    procedure LoadTreeNode(Node: TTreeNode; Options: TLoadTreeOptions = []); virtual;
    procedure LoadStats(List: TStrings); virtual;
    procedure GetNodes(List: TStrings); virtual;
    procedure Search(Text: string; List: TObjectList); virtual;
    procedure SaveToList(List: TStrings); virtual;
    function PrepareMoveList(Lookup: TStringList; var List: TObjectMoves): Boolean; virtual;
    function GetCount: Integer; virtual;
    function GetTopNode: TMenuNode; virtual;
    function FindNode(ID: string): TMenuNode; virtual;
    function CanBeVisible: Boolean;
    property Visible: Boolean read GetVisible;
  end;

  TOnLogEvent = procedure (Text: string) of object;

  { TConfigMenu }

  TConfigMenu = class
  private
    CurrentMenu: TMenuNode;
    ConditionStack: TStringList;
    FArch: string;
    FOnLog: TOnLogEvent;
    ParseFileName: string;
    LineNumber: Integer;
    function GetTopCondition: string;
    procedure Log(Text: string);
    function IsWhiteSpace(Character: Char): Boolean;
    function IsAlpha(Character: Char): Boolean;
    function IsAlphaNumeric(Character: Char): Boolean;
    function IsNumeric(Character: Char): Boolean;
    function IsIdentifier(Name: string): Boolean;
    function IsSpecialSymbol(Character: Char): Boolean;
    procedure Expect(var Text: string; Token: string);
    function GetNextToken(var Text: string): string;
    procedure ParseExpression(Node: TMenuNode; Line: string);
    procedure ParseFile(FileName: string);
    procedure ParseConfig;
    procedure ParseMakeFile;
    function GetLog: string;
    procedure SetArch(AValue: string);
  public
    TopNode: TMenuNode;
    BaseDir: string;
    Version: string;
    procedure OptionListNames(List: TStringList);
    procedure PrepareMoveList(var List: TObjectMoves);
    procedure CompareStringLists(List1, List2: TStringList; Missing1,
      Missing2: TStrings);
    procedure LoadFromDir(Dir: string);
    property OnLog: TOnLogEvent read FOnLog write FOnLog;
    constructor Create;
    destructor Destroy; override;
    property Arch: string read FArch write SetArch;
  end;

implementation

{ TExpressionVar }

function TExpressionVar.CompareValue: Boolean;
begin

end;

function TExpressionVar.CanBeTrue: Boolean;
begin
  if Compare = ctNone then begin

  end else
  if Compare = ctEqual then begin
    Result := Result and CompareValue;
  end else
  if Compare = ctNotEqual then begin
    Result := Result and not CompareValue;
  end;
//  Result := Node.CanBeVisible;
end;

constructor TExpressionVar.Create;
begin
  inherited;
  Compare := ctNone;
  Value := '';
  Negative := False;
  Name := '';
end;

procedure TExpressionVar.GetList(List: TStringList);
begin
  inherited GetList(List);
  List.Add(Name);
end;

function TExpressionVar.Show: String;
begin
  Result := Name;
  if Negative then Result := '!' + Result;
  if Compare = ctEqual then Result := Result + ' = ' + Value;
  if Compare = ctNotEqual then Result := Result + ' != ' + Value;
end;

{ TExpression }

function TExpression.Show: String;
var
  Operand: string;
  I: Integer;
begin
  Result := '';
  if ExpOperator = eoAnd then Operand := '&&';
  if ExpOperator = eoOr then Operand := '||';
  for I := 0 to Items.Count - 1 do begin
    Result := Result + TExpression(Items[I]).Show;
    if I < (Items.Count - 1) then Result := Result + ' ' + Operand + ' ';
  end;
  if Assigned(Parent) then Result := '(' + Result + ')';
end;

function TExpression.CanBeTrue: Boolean;
var
  I: Integer;
begin
  if ExpOperator = eoAnd then begin
    Result := True;
    for I := 0 to Items.Count - 1 do
      Result := Result and TExpression(Items[I]).CanBeTrue;
  end else
  if ExpOperator = eoOr then begin
    Result := False;
    for I := 0 to Items.Count - 1 do
      Result := Result or TExpression(Items[I]).CanBeTrue;
  end;
end;

procedure TExpression.GetList(List: TStringList);
var
  I: Integer;
begin
  for I := 0 to Items.Count - 1 do
    TExpression(Items[I]).GetList(List);
end;

constructor TExpression.Create;
begin
  Items := TObjectList.Create;
  Parent := nil;
  ExpOperator := eoAnd;
end;

destructor TExpression.Destroy;
begin
  Items.Free;
  inherited Destroy;
end;

{ TMenuNode }

function TMenuNode.GetVisible: Boolean;
var
  I: Integer;
begin
  Result := True;
  //for I := 0 to Depends.Count - 1 do
  //if Depends[I]
end;

constructor TMenuNode.Create;
begin
  Name := '';
  ID := '';
  Parent := nil;
  DependsOn := TExpression.Create;
  Description := TStringList.Create;
  Selects := TStringList.Create;
  Items := TObjectList.Create;
  MenuConfig := False;
end;

destructor TMenuNode.Destroy;
begin
  DependsOn.Free;
  Items.Free;
  Description.Free;
  Selects.Free;
  inherited Destroy;
end;

procedure TMenuNode.ChangeParent(NewParent: TMenuNode);
var
  LastOwnState: Boolean;
begin
  try
    LastOwnState := Parent.Items.OwnsObjects;
    Parent.Items.OwnsObjects := False;
    Parent.Items.Remove(Self);
  finally
    Parent.Items.OwnsObjects := LastOwnState;
  end;
  Parent := NewParent;
  NewParent.Items.Add(Self);
end;

procedure TMenuNode.AddLastToList(List: TObjectList);
begin
  List.Add(Self);
  if Items.Count > 0 then begin
    TMenuNode(Items.Last).AddLastToList(List);
  end;
end;

function TMenuNode.GetName: string;
begin
  Result := Name;
  if Result = '' then Result := ID;
end;

function TMenuNode.GetAbsoluteName: string;
begin
  if Assigned(Parent) and Assigned(Parent.Parent) then Result := Parent.GetAbsoluteName + ' - ';
  Result := Result + GetName;
end;

procedure TMenuNode.LoadTreeNode(Node: TTreeNode; Options: TLoadTreeOptions);
var
  I: Integer;
  NewNode: TTreeNode;
begin
  for I := 0 to Items.Count - 1 do
  with TMenuNode(Items[I]) do begin
    if (Name <> '') or ((Name = '') and (toShowSystem in Options)) then begin
      NewNode := Node.TreeNodes.AddChild(Node, GetName);
      NewNode.Data := TMenuNode(Self.Items[I]);
      LoadTreeNode(NewNode, Options);
    end else LoadTreeNode(Node, Options);
  end;
end;

procedure TMenuNode.LoadStats(List: TStrings);
begin
  with List do begin
    Clear;
    Add('ID: ' + ID);
    Add('Name: ' + Name);
    Add('Depends on: ' + DependsOn.Show);
    Add('Selects: ' + Selects.Text);
    Add('Description: ' + Description.Text);
    Add('Value type: ' + IntToStr(Integer(ValueType)));
    Add('Default value: ' + DefaultValue);
    Add('Path: ' + GetAbsoluteName);
  end;
end;

procedure TMenuNode.GetNodes(List: TStrings);
var
  I: Integer;
begin
  if ID <> '' then List.AddObject(ID, Self);
  for I := 0 to Items.Count - 1 do
  with TMenuNode(Items[I]) do begin
    GetNodes(List);
  end;
end;

procedure TMenuNode.Search(Text: string; List: TObjectList);
var
  I: Integer;
begin
  if (Pos(Text, ID) > 0) or (Pos(Text, Name) > 0) then List.Add(Self);
  for I := 0 to Items.Count - 1 do
    TMenuNode(Items[I]).Search(Text, List);
end;

procedure TMenuNode.SaveToList(List: TStrings);
var
  I: Integer;
begin
  if ID <> '' then List.AddObject(ID, Self);
  for I := 0 to Items.Count - 1 do
  with TMenuNode(Items[I]) do begin
    SaveToList(List);
  end;
end;

function TMenuNode.PrepareMoveList(Lookup: TStringList; var List: TObjectMoves): Boolean;
var
  I: Integer;
  J: Integer;
  NewMove: TObjectMove;
  Index: Integer;
  LatestNode: TMenuNode;
  CheckList: TObjectList;
  DepList: TStringList;
begin
  Result := False;
  try
    CheckList := TObjectList.Create;
    CheckList.OwnsObjects := False;
    DepList := TStringList.Create;
    if Assigned(Parent) then begin
    Index := Parent.Items.IndexOf(Self);
    if Index = -1 then raise Exception.Create('Node not found in parent');
    if Index >= 1 then TMenuNode(Parent.Items[Index - 1]).AddLastToList(CheckList);
    DepList.Clear;
    DependsOn.GetList(DepList);
    for I := CheckList.Count - 1 downto 0 do begin
      for J := 0 to DepList.Count - 1 do
      if Trim(DepList[J]) <> '' then begin
        if (DepList[J] = TMenuNode(CheckList[I]).ID) and (TMenuNode(CheckList[I]).ValueType <> vtChoice) then begin
          ChangeParent(TMenuNode(CheckList[I]));
          Result := True;
          Break;
        end;
      end;
      if Result then Break;
    end;
    end;
  finally
    DepList.Free;
    CheckList.Free;
  end;

  I := 0;
  while I < Items.Count do
  with TMenuNode(Items[I]) do begin
    if not PrepareMoveList(Lookup, List) then Inc(I);
  end;
end;

function TMenuNode.GetCount: Integer;
var
  I: Integer;
begin
  Result := 1;
  for I := 0 to Items.Count - 1 do
  with TMenuNode(Items[I]) do begin
    Result := Result + GetCount;
  end;
end;

function TMenuNode.GetTopNode: TMenuNode;
begin
  if Assigned(Parent) then Result := Parent.GetTopNode
    else Result := Self;
end;

function TMenuNode.FindNode(ID: string): TMenuNode;
var
  I: Integer;
begin
  Result := nil;
  if Self.ID = ID then Result := Self
  else begin
    I := 0;
    while (I < Items.Count) do begin
      Result := TMenuNode(Items[I]).FindNode(ID);
      if Assigned(Result) then Break;
      Inc(I);
    end;
  end;
end;

function TMenuNode.CanBeVisible: Boolean;
begin
  // TODO
  // Check if it can be selected manually if manual option
  // Check if it can be selected automatically by other option

end;

{ TConfigMenu }

function TConfigMenu.GetTopCondition: string;
begin
  if ConditionStack.Count > 0 then
  Result := ConditionStack[ConditionStack.Count - 1]
  else Result := '';
end;

procedure TConfigMenu.Log(Text: string);
begin
  if Assigned(FOnLog) then FOnLog(Text);
end;

function TConfigMenu.IsWhiteSpace(Character: Char): Boolean;
begin
  Result := (Character >= #0) and (Character <= ' ');
end;

function TConfigMenu.IsAlpha(Character: Char): Boolean;
begin
  Result := ((Character >= 'a') and (Character <= 'z'))
    or ((Character >= 'A') and (Character <= 'Z'));
end;

function TConfigMenu.IsAlphaNumeric(Character: Char): Boolean;
begin
  Result := IsAlpha(Character) or IsNumeric(Character);
end;

function TConfigMenu.IsNumeric(Character: Char): Boolean;
begin
  Result := (Character >= '0') and (Character <= '9');
end;

function TConfigMenu.IsIdentifier(Name: string): Boolean;
var
  I: Integer;
begin
  Result := True;
  for I := 1 to Length(Name) do
    if not (IsAlphaNumeric(Name[I]) or (Name[I] = '_')) then begin
      Result := False;
      Break;
    end;
end;

function TConfigMenu.IsSpecialSymbol(Character: Char): Boolean;
begin
  Result := (Character = '!') or (Character = '=') or (Character = '(') or
    (Character = ')') or (Character = '-') or (Character = '|') or (Character = '&');
end;

procedure TConfigMenu.Expect(var Text: string; Token: string);
begin
  if GetNextToken(Text) <> Token then
    raise Exception.Create('Expected "' + Token + '"');
end;

function TConfigMenu.GetNextToken(var Text: string): string;
var
  I: Integer;
  Terminate: Boolean;
  State: (stNormal, stWhiteSpace, stString, stSpecialSymbol, stIdent,
    stString2);
begin
  I := 1;
  Terminate := False;
  Result := '';
  State := stNormal;
  while (I <= Length(Text)) and not Terminate do begin
    if State = stWhiteSpace then begin
      if not IsWhiteSpace(Text[I]) then begin
        State := stNormal;
        Terminate := True;
      end;
    end else
    if State = stString then begin
      if Text[I] = '"' then begin
        State := stNormal;
        Terminate := True;
        Inc(I);
      end else Result := Result + Text[I];
    end else
    if State = stString2 then begin
      if Text[I] = '''' then begin
        State := stNormal;
        Terminate := True;
        Inc(I);
      end else Result := Result + Text[I];
    end else
    if State = stSpecialSymbol then begin
      if not IsSpecialSymbol(Text[I]) or (Result = '(') or (Result = ')') or
        ((Result = '!') and (Text[I] <> '=')) or (Result = '||') or
        (Result = '&&') then begin
        State := stNormal;
        Terminate := True;
      end else Result := Result + Text[I];
    end else
    if State = stIdent then begin
      if not (IsAlphanumeric(Text[I]) or (Text[I] = '_')) then begin
        State := stNormal;
        Terminate := True;
      end else Result := Result + Text[I];
    end else begin
      if IsWhiteSpace(Text[I]) then State := stWhiteSpace
      else if Text[I] = '"' then State := stString
      else if Text[I] = '''' then State := stString2
      else if Text[I] = '#' then begin
        // Comment
        Text := '';
        Terminate := True;
      end
      else if IsSpecialSymbol(Text[I]) then begin
        State := stSpecialSymbol;
        Result := Result + Text[I];
      end
      else if IsAlphaNumeric(Text[I]) then begin
        State := stIdent;
        Result := Result + Text[I];
      end
      else Result := Result + Text[I];
    end;
    if not Terminate then Inc(I);
  end;
  Delete(Text, 1, I - 1);
end;

procedure TConfigMenu.ParseExpression(Node: TMenuNode; Line: string);
var
  Token: string;
  Exp: TExpression;
  ExpVar: TExpressionVar;
  ExpNew: TExpression;
  Neg: Boolean;
  Compare: TCompareType;
begin
  Line := Trim(Line);
  Exp := Node.DependsOn;
  Neg := False;
  while Line <> '' do begin
    Token := GetNextToken(Line);
    if Token = '||' then begin
      Exp.ExpOperator := eoOr;
    end else
    if Token = '&&' then begin
      Exp.ExpOperator := eoAnd;
    end else
    if Token = '!' then begin
      Neg := True;
      Continue;
    end else
    if Token = '(' then begin
      ExpNew := TExpression.Create;
      ExpNew.Parent := Exp;
      Exp.Items.Add(ExpNew);
      Exp := ExpNew;
      Neg := False;
    end else
    if Token = ')' then begin
      if Assigned(Exp.Parent) then Exp := Exp.Parent
        else raise Exception.Create('Cannot go to expression parent.' + GetLog);
      Neg := False;
    end else
    if Token = '' then begin
      // White space
    end else
    if Token = '=' then begin
      ExpVar.Compare := ctEqual;
      Token := GetNextToken(Line);
      ExpVar.Value := Token;
      Continue;
    end else
    if Token = '!=' then begin
      ExpVar.Compare := ctNotEqual;
      Token := GetNextToken(Line);
      ExpVar.Value := Token;
      Continue;
    end else
    if IsIdentifier(Token) then begin
      ExpVar := TExpressionVar.Create;
      ExpVar.Negative := Neg;
      ExpVar.Name := Token;
      ExpVar.Compare := Compare;
      Exp.Items.Add(ExpVar);
      Neg := False;
    end else
      raise Exception.Create('Unknown token "' + Token + '".' + GetLog);
  end;

  {// Just try to load symbol list. Do not parse expression
  while Trim(Line) <> '' do begin
    Parameter := GetNextToken(Line);
    if Copy(Parameter, 1, 1) = '!' then Delete(Parameter, 1, 1);
    if Copy(Parameter, 1, 1) = '(' then Delete(Parameter, 1, 1);
    if Copy(Parameter, Length(Parameter), 1) = ')' then Delete(Parameter, Length(Parameter), 1);
    Parameter := Trim(Parameter);
    if (Parameter <> '&&') and (Parameter <> '||') then
      Node.Depends.Add(Parameter);
  end;
  }

end;

function TConfigMenu.GetLog: string;
begin
  Result := ' ' + ParseFileName + ':' + IntToStr(LineNumber);
end;

procedure TConfigMenu.SetArch(AValue: string);
begin
  if FArch = AValue then Exit;
  FArch := AValue;
  LoadFromDir(BaseDir);
end;

procedure TConfigMenu.ParseFile(FileName: string);
var
  Content: TStringList;
  I: Integer;
  J: Integer;
  Command: string;
  Parameter: string;
  Line: string;
  State: (stNormal, stConfig, stHelp, stHelpStart);
  NewItem: TMenuNode;
  NewMenu: TMenuNode;
  MergedLines: string;
  HelpIndent: Integer;
  LineIndent: Integer;
  NewExp: TExpressionVar;
const
  TabSize = 8;
begin
  ParseFileName := FileName;
  Log('FILE ' + FileName);
  try
    Content := TStringList.Create;
    Content.LoadFromFile(FileName);
    State := stNormal;
    NewItem := nil;
    MergedLines := '';
    HelpIndent := 0;
    for I := 0 to Content.Count - 1 do begin
      LineNumber := I + 1;
      Line := MergedLines + Content[I];
      MergedLines := '';
      LineIndent := 0;
      J := 1;
      while (J <= Length(Line)) and IsWhiteSpace(Line[J]) do begin
        if Line[J] = #9 then LineIndent := (Trunc(LineIndent / TabSize) + 1) * TabSize
          else Inc(LineIndent);
        Inc(J);
      end;
      if (State = stHelp) and (Trim(Line) <> '') then begin
        State := stHelpStart;
        if LineIndent = 0 then State := stNormal;
        HelpIndent := LineIndent;
        if (State = stHelpStart) and (HelpIndent = 0) then
          raise Exception.Create('Error during help parsing.' + GetLog);
      end;
      if (State = stHelpStart) and (Trim(Line) <> '') and (LineIndent < HelpIndent) then
        State := stNormal;

      if (Copy(Trim(Line), 1, 1) = '#') or (Copy(Trim(Line), 1, 2) = '\#') then begin
        // Skip comments
        Continue;
      end;
      if Copy(TrimRight(Line), Length(Line), 1) = '\' then begin
        // Merge lines
        Line := TrimRight(Line);
        Delete(Line, Length(Line), 1);
        MergedLines := Line;
        Continue;
      end;
      Line := Trim(Line);
      if Line = '' then begin
        // Skip empty non help lines
        Continue;
      end;
      Command := GetNextToken(Line);
      if (State = stHelp) or (State = stHelpStart) then begin
        NewItem.Description.Add(Trim(Content[I]));
      end else
      if (Command = 'bool') or (Command = 'boolean') then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
        NewItem.ValueType := vtBool;
        NewItem.Name := Parameter;
      end else
      if Command = 'def_bool' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
        NewItem.DefaultValue := Parameter;
        NewItem.ValueType := vtBool;
      end else
      if Command = 'tristate' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
        NewItem.Name := Parameter;
        NewItem.ValueType := vtTristate;
      end else
      if Command = 'def_tristate' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
        NewItem.Name := Parameter;
      end else
      if Command = 'string' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
        NewItem.Name := Parameter;
        NewItem.ValueType := vtString;
      end else
      if Command = 'int' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
        NewItem.Name := Parameter;
        NewItem.ValueType := vtInt;
      end else
      if Command = 'hex' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
        NewItem.Name := Parameter;
        NewItem.ValueType := vtHex;
      end else
      if Command = 'range' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
        NewItem.RangeMin := Parameter;
        Parameter := GetNextToken(Line);
        NewItem.RangeMax := Parameter;
      end else
      if Command = 'prompt' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
        NewItem.Name := Parameter;
      end else
      if Command = 'default' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
        NewItem.DefaultValue := Parameter;
      end else
      if Command = 'depends' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if Parameter = 'on' then begin
          if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
          ParseExpression(NewItem, Line);
        end;
      end else
      if Command = 'select' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if not Assigned(NewItem) then raise Exception.Create('Item not defined.' + GetLog);
        NewItem.Selects.Add(Parameter);
      end else
      if Command = '---' then begin
        Command := GetNextToken(Line);
        if Command = 'help' then begin
          Command := GetNextToken(Line);
          if Command = '---' then begin
            State := stHelp;
            HelpIndent := LineIndent;
          end;
        end else
        if Command = '' then begin
          Command := GetNextToken(Line);
          if Command = 'help' then begin
            Expect(Line, '');
            Command := GetNextToken(Line);
            if Command = '---' then begin
              State := stHelp;
              HelpIndent := LineIndent;
            end;
          end;
        end;
      end else
      if (Command = 'help') or (Command = '---help---') then begin
        State := stHelp;
        HelpIndent := LineIndent;
      end else
      if Command = 'option' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
      end else
      if (Command = 'config') or (Command = 'menuconfig') then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        State := stConfig;
        NewItem := TMenuNode.Create;
        NewItem.Parent := CurrentMenu;
        NewItem.ID := Parameter;
        for J := 0 to ConditionStack.Count - 1 do
        if ConditionStack[J] <> '' then
        begin
          NewExp := TExpressionVar.Create;
          NewExp.Name := ConditionStack[J];
          NewItem.DependsOn.Items.Add(NewExp);
        end;
        CurrentMenu.Items.Add(NewItem);
        if Command = 'menuconfig' then NewItem.MenuConfig := True;
      end else
      if (Command = 'comment')  then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        NewItem := TMenuNode.Create;
        NewItem.Parent := CurrentMenu;
        NewItem.Name := Parameter;
        for J := 0 to ConditionStack.Count - 1 do
        if ConditionStack[J] <> '' then begin
          NewExp := TExpressionVar.Create;
          NewExp.Name := ConditionStack[J];
          NewItem.DependsOn.Items.Add(NewExp);
        end;
        NewItem.ValueType := vtComment;
        CurrentMenu.Items.Add(NewItem);
      end else
      if Command = 'source' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        if Pos('$SRCARCH', Parameter) > 0 then
          Parameter := StringReplace(Parameter, '$SRCARCH', Arch, [rfReplaceAll]);
        Parameter := BaseDir + DirectorySeparator + Parameter;
        if FileExistsUTF8(Parameter) then
          ParseFile(Parameter)
          else raise Exception.Create('Source file "' + Parameter + '" not found.' + GetLog);
      end else
      if Command = 'choice' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        NewMenu := TMenuNode.Create;
        NewMenu.ValueType := vtChoice;
        NewMenu.Name := Parameter;
        NewMenu.Parent := CurrentMenu;
        for J := 0 to ConditionStack.Count - 1 do
        if ConditionStack[J] <> '' then begin
          NewExp := TExpressionVar.Create;
          NewExp.Name := ConditionStack[J];
          NewMenu.DependsOn.Items.Add(NewExp);
        end;
        ConditionStack.AddObject('', nil);
        NewItem := NewMenu;
        CurrentMenu.Items.Add(NewMenu);
        CurrentMenu := NewMenu;
      end else
      if command = 'endchoice' then begin
        if Assigned(CurrentMenu.Parent) then begin
          ConditionStack.Delete(ConditionStack.Count - 1);
          CurrentMenu := CurrentMenu.Parent;
        end else raise Exception.Create('Can''t change menu level up.' + GetLog);
      end else
      if Command = 'mainmenu' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        Parameter := StringReplace(Parameter, '$ARCH', Arch, [rfReplaceAll]);
        Parameter := StringReplace(Parameter, '$KERNELVERSION', Version, [rfReplaceAll]);
        TopNode.Name := Parameter;
      end else
      if Command = 'menu' then begin
        Expect(Line, '');
        Parameter := GetNextToken(Line);
        Log('MENU ' + Parameter + ' IN ' + CurrentMenu.GetAbsoluteName);
        NewMenu := TMenuNode.Create;
        NewMenu.Name := Parameter;
        NewMenu.Parent := CurrentMenu;
        for J := 0 to ConditionStack.Count - 1 do
        if ConditionStack[J] <> '' then begin
          NewExp := TExpressionVar.Create;
          NewExp.Name := ConditionStack[J];
          NewMenu.DependsOn.Items.Add(NewExp);
        end;
        ConditionStack.AddObject('', nil);
        NewItem := NewMenu;
        CurrentMenu.Items.Add(NewMenu);
        CurrentMenu := NewMenu;
      end else
      if command = 'endmenu' then begin
        Log('ENDMENU ' + CurrentMenu.GetAbsoluteName);
        if Assigned(CurrentMenu.Parent) then begin
          ConditionStack.Delete(ConditionStack.Count - 1);
          CurrentMenu := CurrentMenu.Parent;
        end else raise Exception.Create('Can''t change menu level up.' + GetLog);
      end else
      if Command = 'if' then begin
        Expect(Line, '');
        ConditionStack.AddObject(GetNextToken(Line), NewItem);
      end else
      if Command = 'visible' then begin
        //VisibleCondition := GetNextToken(Line);
      end else
      if Command = 'optional' then begin
        NewItem.Optional := True;
      end else
      if Command = 'endif' then begin
        ConditionStack.Delete(ConditionStack.Count - 1);
      end else
        raise Exception.Create('Unknown command "' + Command + '".' + GetLog);
    end;
  finally
    Content.Free;
  end;
end;

procedure TConfigMenu.ParseConfig;
begin
  ConditionStack.Clear;
  TopNode.Free;
  TopNode := TMenuNode.Create;
  TopNode.Name := 'Root';
  CurrentMenu := TopNode;
  ParseFile(BaseDir + DirectorySeparator + 'Kconfig');
end;

procedure TConfigMenu.ParseMakeFile;
var
  Content: TStringList;
  I: Integer;
  Line: string;
  Token: string;
begin
  try
    Content := TStringList.Create;
    Content.LoadFromFile(BaseDir + DirectorySeparator + 'Makefile');
    for I := 0 to Content.Count - 1 do begin
      Line := Trim(Content[I]);
      Token := GetNextToken(Line);
      if Token = 'VERSION' then begin
        Line := Trim(Line);
        Token := GetNextToken(Line);
        if Token = '=' then
          Version := Trim(Line);
      end else
      if Token = 'PATCHLEVEL' then begin
        Line := Trim(Line);
        Token := GetNextToken(Line);
        if Token = '=' then
          Version := Version + '.' + Trim(Line);
      end else
      if Token = 'SUBLEVEL' then begin
        Line := Trim(Line);
        Token := GetNextToken(Line);
        if Token = '=' then
          Version := Version + '.' + Trim(Line);
      end;
    end;
  finally
    Content.Free;
  end;
end;

procedure TConfigMenu.OptionListNames(List: TStringList);
var
  I: Integer;
  Node: TMenuNode;
begin
  for I := 0 to List.Count - 1 do begin
    Node := TopNode.FindNode(List[I]);
    if Assigned(Node) then
      List[I] := '"' + Node.GetAbsoluteName + '";' + List[I];
  end;
end;

procedure TConfigMenu.PrepareMoveList(var List: TObjectMoves);
var
  Lookup: TStringList;
begin
  try
    Lookup := TStringList.Create;
    Lookup.OwnsObjects := False;
    TopNode.GetNodes(Lookup);
    Lookup.Sorted := True;
    TopNode.PrepareMoveList(Lookup, List);
  finally
    Lookup.Free;
  end;
end;

procedure TConfigMenu.CompareStringLists(List1, List2: TStringList;
  Missing1, Missing2: TStrings);
var
  I: Integer;
  J: Integer;
begin
  List1.Sort;
  List2.Sort;
  I := 0;
  J := 0;
  while (I < List1.Count) and (J < List2.Count) do
  begin
    if List1[I] < List2[J] then
    begin
      Missing2.Add(List1[I]);
      Inc(I);
    end
    else if List1[I] > List2[J] then
    begin
      Missing1.Add(List2[J]);
      Inc(J);
    end
    else
    begin
      Inc(I);
      Inc(J);
    end;
  end;
  for I := I to List1.Count - 1 do
    Missing2.Add(List1[I]);
  for J := J to List2.Count - 1 do
    Missing1.Add(List2[J]);
end;

procedure TConfigMenu.LoadFromDir(Dir: string);
var
  Moves: TObjectMoves;
  I: Integer;
begin
  BaseDir := Dir;
  ParseMakeFile;
  ParseConfig;

  SetLength(Moves, 0);
  PrepareMoveList(Moves);
  for I := 0 to Length(Moves) - 1 do
  with Moves[I] do begin
    TMenuNode(Source).Parent.Items.OwnsObjects := False;
    TMenuNode(Source).Parent.Items.Remove(Source);
    TMenuNode(Source).Parent.Items.OwnsObjects := True;
    TMenuNode(Source).Parent := TMenuNode(NewParent);
    TMenuNode(NewParent).Items.Add(Source);
  end;
end;

constructor TConfigMenu.Create;
begin
  ConditionStack := TStringList.Create;
  Self.FArch := 'x86';
end;

destructor TConfigMenu.Destroy;
begin
  ConditionStack.Free;
end;

end.