* Now able to generate code for all browser APIs

packages/webidl/src/webidltopas.pp

@@ -71,7 +71,8 @@ Type
     Resolved: TIDLTypeDefinition;
     NativeType : TPascalNativeType;
     NameChecked : Boolean;
-    FullmemberList : TIDLDefinitionList;
+    FullMemberList : TIDLDefinitionList;
+    ParentsMemberList : TIDLDefinitionList;
     Constructor Create(APasName: String; D: TIDLBaseObject);
     Destructor Destroy; override;
     Property PasName: String read FPasName write FPasName;
@@ -147,17 +148,15 @@ type
     FTypeAliases: TStrings; // user defined type maping name to name
     FVerbose: Boolean;
     FWebIDLVersion: TWebIDLVersion;
-    procedure AddFullMemberList(aParent: TIDLStructuredDefinition; AddToList: TIDLDefinitionList);
-    function CheckExistingSequence(ST: TIDLSequenceTypeDefDefinition; out TN: TIDLString): Boolean;
-    function CheckExistingUnion(UT: TIDLUnionTypeDefDefinition; out TN: TIDLString): Boolean;
-    function GetAliasPascalType(aNativeTypeName: String; out PascalTypeName: string): TPascalNativeType;
-    function GetFullMemberList(aParent: TIDLStructuredDefinition): TIDLDefinitionList;
     procedure SetGlobalVars(const AValue: TStrings);
     procedure SetIncludeImplementationCode(AValue: TStrings);
     procedure SetIncludeInterfaceCode(AValue: TStrings);
     procedure SetOutputFileName(const AValue: String);
     procedure SetTypeAliases(AValue: TStrings);
   Protected
+    function CheckExistingSequence(ST: TIDLSequenceTypeDefDefinition; out TN: TIDLString): Boolean;
+    function CheckExistingUnion(UT: TIDLUnionTypeDefDefinition; out TN: TIDLString): Boolean;
+    function GetAliasPascalType(aNativeTypeName: String; out PascalTypeName: string): TPascalNativeType;
     procedure TrimList(List: TStrings); virtual;
     procedure AddOptionsToHeader;
     Procedure Parse; virtual;
@@ -166,6 +165,9 @@ type
     function CreateScanner(S: TStream): TWebIDLScanner; virtual;
     Function CreateContext: TWebIDLContext; virtual;
     // Auxiliary routines
+    procedure AddFullMemberList(aParent: TIDLStructuredDefinition; AddToList: TIDLDefinitionList);
+    function GetFullMemberList(aParent: TIDLStructuredDefinition): TIDLDefinitionList;
+    function GetParentsMemberList(aParent: TIDLStructuredDefinition): TIDLDefinitionList;
     procedure GetOptions(L: TStrings; Full: boolean); virtual;
     procedure ProcessDefinitions; virtual;
     function CreatePasData(aName: String; aNativetype : TPascalNativeType; D: TIDLBaseObject; Escape: boolean): TPasData; virtual;
@@ -183,25 +185,25 @@ type
     // Pascal Name allocation/retrieval
     function AddSequenceDef(ST: TIDLSequenceTypeDefDefinition): Boolean; virtual;
     function AddUnionDef(UT: TIDLUnionTypeDefDefinition): Boolean; virtual;
-    procedure EnsureUniqueNames(ML: TIDLDefinitionList; const aParentName: String); virtual;
+    procedure EnsureUniqueNames(aParent : TIDLStructuredDefinition; ML: TIDLDefinitionList; const aParentName: String); virtual;
     procedure EnsureUniqueArgNames(Intf: TIDLStructuredDefinition); virtual;
     procedure AllocatePasNames(aList: TIDLDefinitionList; ParentName: String=''); virtual;
     function AllocatePasName(D: TIDLDefinition; ParentName: String; Recurse : Boolean): TPasData; virtual;
     function GetAliasPascalType(D: TIDLDefinition; out PascalTypeName : string): TPascalNativeType; virtual;
-    function AllocateArgumentPasName(D: TIDLArgumentDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateAttributePasName(D: TIDLAttributeDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateCallbackPasName(D: TIDLCallBackDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateDefaultPasName(D: TIDLDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateDictionaryMemberPasName(D: TIDLDictionaryMemberDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateDictionaryPasName(D: TIDLDictionaryDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateFunctionPasName(D: TIDLFunctionDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateInterfacePasName(D: TIDLInterfaceDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateNamespacePasName(D: TIDLNameSpaceDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateSequencePasName(D: TIDLSequenceTypeDefDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateUnionPasName(D: TIDLUnionTypeDefDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateMapLikePasName(D: TIDLMapLikeDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateEnumeratedPasName(D: TIDLEnumDefinition; ParentName: String; Recurse: Boolean): TPasData;
-    function AllocateConstPasName(D: TIDLConstDefinition; ParentName: String; Recurse: Boolean): TPasData;
+    function AllocateArgumentPasName(D: TIDLArgumentDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateAttributePasName(aParent : TIDLStructuredDefinition; D: TIDLAttributeDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateCallbackPasName(D: TIDLCallBackDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateDefaultPasName(D: TIDLDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateDictionaryMemberPasName(D: TIDLDictionaryMemberDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateDictionaryPasName(D: TIDLDictionaryDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateFunctionPasName(D: TIDLFunctionDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateInterfacePasName(D: TIDLInterfaceDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateNamespacePasName(D: TIDLNameSpaceDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateSequencePasName(D: TIDLSequenceTypeDefDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateUnionPasName(D: TIDLUnionTypeDefDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateMapLikePasName(D: TIDLMapLikeDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateEnumeratedPasName(D: TIDLEnumDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
+    function AllocateConstPasName(D: TIDLConstDefinition; ParentName: String; Recurse: Boolean): TPasData; virtual;
 
     function GetPasName(ADef: TIDLDefinition): String; virtual;
     function GetPasNativeType(ADef: TIDLDefinition): TPascalNativeType; virtual;
@@ -352,6 +354,8 @@ end;
 destructor TPasData.Destroy;
 begin
   FreeAndNil(FullmemberList);
+  FreeAndNil(ParentsMemberList);
+
   inherited Destroy;
 end;
 
@@ -549,7 +553,7 @@ function TBaseWebIDLToPas.WriteDictionaryMemberImplicitTypes(
   aDict: TIDLDictionaryDefinition; aList: TIDLDefinitionList): Integer;
 
 Var
-  MT,D: TIDLDefinition;
+  D: TIDLDefinition;
   FD: TIDLDictionaryMemberDefinition absolute D;
 
 
@@ -750,6 +754,32 @@ begin
         Result:=Result+WriteMapLikeMethodDefinitions(aParent,MD);
 end;
 
+function TBaseWebIDLToPas.GetParentsMemberList(aParent: TIDLStructuredDefinition) : TIDLDefinitionList;
+
+var
+  D : TPasData;
+
+begin
+  D:=TPasData(aParent.Data);
+  if Not Assigned(D) then
+    Raise EWebIDLError.CreateFmt('%s does not have data assigned to it',[aParent]);
+  if Not Assigned(D.ParentsMemberList) then
+    begin
+    D.ParentsMemberList:=TIDLDefinitionList.Create(aParent,False);
+    While aParent<>Nil do
+      begin
+      AddFullMemberList(aParent,D.ParentsmemberList);
+      if aParent is TIDLInterfaceDefinition then
+        aParent:=TIDLInterfaceDefinition(aParent).ParentInterface
+      else if aParent is TIDLDictionaryDefinition then
+        aParent:=TIDLDictionaryDefinition(aParent).ParentDictionary
+      else
+        aParent:=Nil;
+      end;
+    end;
+  Result:=D.ParentsmemberList;
+end;
+
 procedure TBaseWebIDLToPas.AddFullMemberList(aParent: TIDLStructuredDefinition; AddToList : TIDLDefinitionList);
 
 Var
@@ -828,12 +858,11 @@ end;
 function TBaseWebIDLToPas.CheckExistingSequence(ST: TIDLSequenceTypeDefDefinition; out TN: TIDLString): Boolean;
 
 var
-  ArgType : TIDLTypeDefinition;
   ArgTypeName,ArgResolvedTypeName : String;
   NT : TPascalNativeType;
 
 begin
-  ArgType:=GetResolvedType(ST,NT,ArgTypeName,ArgResolvedTypeName);
+  GetResolvedType(ST,NT,ArgTypeName,ArgResolvedTypeName);
   TN:=ArgTypeName;
   Result:=FAutoTypes.IndexOf(TN)<>-1;
 end;
@@ -841,12 +870,11 @@ end;
 function TBaseWebIDLToPas.CheckExistingUnion(UT: TIDLUnionTypeDefDefinition; out TN: TIDLString): Boolean;
 
 var
-  ArgType : TIDLTypeDefinition;
   ArgTypeName,ArgResolvedTypeName : String;
   NT : TPascalNativeType;
 
 begin
-  ArgType:=GetResolvedType(UT,NT,ArgTypeName,ArgResolvedTypeName);
+  GetResolvedType(UT,NT,ArgTypeName,ArgResolvedTypeName);
   TN:=ArgTypeName;
   Result:=FAutoTypes.IndexOf(TN)<>-1;
 end;
@@ -879,7 +907,7 @@ begin
     end;
 end;
 
-procedure TBaseWebIDLToPas.EnsureUniqueNames(ML: TIDLDefinitionList;const aParentName : String);
+procedure TBaseWebIDLToPas.EnsureUniqueNames(aParent : TIDLStructuredDefinition;ML: TIDLDefinitionList;const aParentName : String);
 
 Var
   L: TFPObjectHashTable;
@@ -998,24 +1026,13 @@ var
 
 var
   Members, MembersWithParents: TIDLDefinitionList;
-  CurIntf: TIDLStructuredDefinition;
   D: TIDLDefinition;
   CurName: String;
 begin
-  Members:=Nil;
+  Members:=GetFullMemberList(Intf);
+  MembersWithParents:=GetParentsMemberList(Intf);
   Names:=TFPObjectHashTable.Create(False);
-  MembersWithParents:=TIDLDefinitionList.Create(Nil,False);
   try
-    Members:=GetFullMemberList(Intf);
-    CurIntf:=Intf;
-    while CurIntf<>nil do
-      begin
-      AddFullMemberList(CurIntf,MembersWithParents);
-      if CurIntf is TIDLInterfaceDefinition then
-        CurIntf:=TIDLInterfaceDefinition(CurIntf).ParentInterface
-      else
-        CurIntf:=nil;
-      end;
     For D in MembersWithParents Do
       if ConvertDef(D) then
         begin
@@ -1028,7 +1045,6 @@ begin
         if ConvertDef(D) then
           CheckRenameArgs(TIDLFunctionDefinition(D));
   finally
-    MembersWithParents.Free;
     Names.Free;
   end;
 end;
@@ -1043,7 +1059,7 @@ Var
 begin
   Result:=True;
   ML:=GetFullMemberList(Intf);
-  EnsureUniqueNames(ML,Intf.Name);
+  EnsureUniqueNames(Intf,ML,Intf.Name);
   EnsureUniqueArgNames(Intf);
   aClassName:=GetPasName(Intf);
   // class comment
@@ -1092,7 +1108,7 @@ Var
 begin
   Result:=True;
   ML:=GetFullMemberList(aNamespace);
-  EnsureUniqueNames(ML,aNameSpace.name);
+  EnsureUniqueNames(aNameSpace,ML,aNameSpace.name);
   EnsureUniqueArgNames(aNamespace);
   aClassName:=GetPasName(aNamespace);
   // class comment
@@ -1130,35 +1146,22 @@ begin
   AddLn('end;');
 end;
 
-function TBaseWebIDLToPas.WriteDictionaryDef(aDict: TIDLDictionaryDefinition
-  ): Boolean;
+function TBaseWebIDLToPas.WriteDictionaryDef(aDict: TIDLDictionaryDefinition): Boolean;
 
 Var
   CurClassName, Decl: String;
   DefList: TIDLDefinitionList;
-  CurDefs: TIDLDictionaryDefinition;
-
 begin
   Result:=True;
-  DefList:=TIDLDefinitionList.Create(Nil,False);
-  try
-    CurDefs:=aDict;
-    While CurDefs<>Nil do
-      begin
-      AddFullMemberList(CurDefs,DefList);
-      CurDefs:=CurDefs.ParentDictionary;
-      end;
-    CurClassName:=GetPasName(aDict);
-    ClassComment(CurClassName);
-    WriteDictionaryMemberImplicitTypes(aDict, DefList);
-    // class and ancestor
-    Decl:=GetDictionaryDefHead(CurClassName,aDict);
-    AddLn(Decl);
-    WriteDictionaryFields(aDict,DefList);
-    AddLn('end;');
-  finally
-    DefList.Free;
-  end;
+  DefList:=GetParentsMemberList(aDict);
+  CurClassName:=GetPasName(aDict);
+  ClassComment(CurClassName);
+  WriteDictionaryMemberImplicitTypes(aDict, DefList);
+  // class and ancestor
+  Decl:=GetDictionaryDefHead(CurClassName,aDict);
+  AddLn(Decl);
+  WriteDictionaryFields(aDict,DefList);
+  AddLn('end;');
 end;
 
 constructor TBaseWebIDLToPas.Create(TheOwner: TComponent);
@@ -1647,8 +1650,6 @@ Var
   D: TIDLDefinition;
   TD: TIDLTypeDefDefinition absolute D;
   CD: TIDLCallbackDefinition absolute D;
-  N : String;
-
 begin
   Result:=0;
   EnsureSection(csType);
@@ -2294,8 +2295,6 @@ function TBaseWebIDLToPas.AllocateSequencePasName(D: TIDLSequenceTypeDefDefiniti
 var
   CN : String;
   sDef : TIDLDefinition;
-  TN,RTN : String;
-
 begin
   Result:=Nil;
   CN:=D.Name;
@@ -2425,7 +2424,8 @@ begin
     AllocatePasName(D.FunctionDef,'',True)
 end;
 
-function TBaseWebIDLToPas.AllocateAttributePasName(D: TIDLAttributeDefinition; ParentName: String; Recurse : Boolean): TPasData;
+function TBaseWebIDLToPas.AllocateAttributePasName(aParent: TIDLStructuredDefinition; D: TIDLAttributeDefinition;
+  ParentName: String; Recurse: Boolean): TPasData;
 
 Var
   CN: String;
@@ -2623,7 +2623,7 @@ begin
   else if D Is TIDLCallBackDefinition then
     Result:=AllocateCallBackPasName(TIDLCallBackDefinition(D),ParentName,Recurse)
   else if D is TIDLAttributeDefinition then
-    Result:=AllocateAttributePasName(TIDLAttributeDefinition(D),ParentName,Recurse)
+    Result:=AllocateAttributePasName(D.Parent as TIDLStructuredDefinition,TIDLAttributeDefinition(D),ParentName,Recurse)
   else if D is TIDLFunctionDefinition then
     Result:=AllocateFunctionPasName(TIDLFunctionDefinition(D),ParentName,Recurse)
   else if D is TIDLEnumDefinition then
@@ -3015,6 +3015,7 @@ end;
 
 procedure TBaseWebIDLToPas.AllocatePasNames(aList: TIDLDefinitionList; ParentName: String = '');
 
+
 var
   D: TIDLDefinition;
 

packages/webidl/src/webidltowasmjob.pp

@@ -66,6 +66,8 @@ const
 type
 
   TPasDataWasmJob = class(TPasData)
+    PropertyGetterName : String;
+    PropertySetterName : String;
   end;
 
   { TWebIDLToPasWasmJob }
@@ -75,6 +77,9 @@ type
     FPasInterfacePrefix: TIDLString;
     FPasInterfaceSuffix: TIDLString;
     FGeneratingInterface : Boolean;
+    procedure AllocateAttributeGetterSetter(aParent: TIDLStructuredDefinition; aAttr: TIDLAttributeDefinition);
+    procedure AllocateAttributeGetterSetters;
+    function GetAccessorNames(Attr: TIDLAttributeDefinition; out aGetter, aSetter: TIDLString): Boolean;
     function GetArgName(d: TIDLDefinition): string;
     function GetFunctionSuffix(aDef: TIDLFunctionDefinition; Overloads: TFPObjectList): String;
     function GetInvokeClassName(aResultDef: TIDLDefinition; aName: TIDLString; aDef: TIDLFunctionDefinition=nil): TIDLString;
@@ -134,6 +139,8 @@ type
     function GetFunctionSignature(aDef: TIDLFunctionDefinition; aReturnDef: TIDLDefinition; aFuncname, aReturnTypeName,
       aSuffix: TIDLString; ArgDefList: TIDLDefinitionList; out ProcKind: TIDLString): String;
     function GetMethodInfo(aParent: TIDLStructuredDefinition; aDef: TIDLFunctionDefinition; out FuncName, ReturnTypeName, ResolvedReturnTypeName, InvokeName, InvokeClassName: TIDLString): TIDLDefinition;
+    function AllocateAttributePasName(aParent : TIDLStructuredDefinition; D: TIDLAttributeDefinition; ParentName: String; Recurse: Boolean): TPasData; override;
+    Procedure ProcessDefinitions; override;
     // Implementation writing
     procedure WriteImplementation; override;
     // Implementation, per type
@@ -158,7 +165,10 @@ type
     procedure WriteMapLikeFunctionImplementations(aDef: TIDLStructuredDefinition; MD: TIDLMapLikeDefinition);
     procedure WriteMapLikeEntriesFunctionImplementation(aDef: TIDLStructuredDefinition; ML: TIDLMapLikeDefinition);
     procedure WriteMapLikeGetFunctionImplementation(aDef: TIDLStructuredDefinition; ML: TIDLMapLikeDefinition);
+    procedure WriteMapLikeSetFunctionImplementation(aDef: TIDLStructuredDefinition; ML: TIDLMapLikeDefinition);
+    procedure WriteMapLikeClearFunctionImplementation(aDef: TIDLStructuredDefinition; ML: TIDLMapLikeDefinition);
     procedure WriteMapLikeHasFunctionImplementation(aDef: TIDLStructuredDefinition; ML: TIDLMapLikeDefinition);
+    procedure WriteMapLikeDeleteFunctionImplementation(aDef: TIDLStructuredDefinition; ML: TIDLMapLikeDefinition);
     procedure WriteMapLikeKeysFunctionImplementation(aDef: TIDLStructuredDefinition; ML: TIDLMapLikeDefinition);
     procedure WriteMapLikeValuesFunctionImplementation(aDef: TIDLStructuredDefinition; ML: TIDLMapLikeDefinition);
 
@@ -745,6 +755,61 @@ begin
     end;
 end;
 
+function TWebIDLToPasWasmJob.AllocateAttributePasName(aParent: TIDLStructuredDefinition; D: TIDLAttributeDefinition;
+  ParentName: String; Recurse: Boolean): TPasData;
+
+begin
+  Result:=inherited AllocateAttributePasName(aParent, D, ParentName, Recurse);
+end;
+
+procedure TWebIDLToPasWasmJob.AllocateAttributeGetterSetter(aParent : TIDLStructuredDefinition; aAttr : TIDLAttributeDefinition);
+
+var
+  Full : TIDLDefinitionList;
+  aDef : TIDLDefinition;
+  aCount : integer;
+  DJob : TPasDataWasmJob;
+  BaseName : string;
+begin
+  if not (aAttr.Data is TPasDataWasmJob) then
+    Raise EWebIDLError.CreateFmt('No data assigned for attribute %s of %s',[aAttr.Name,aParent.Name]);
+  DJob:=TPasDataWasmJob(aAttr.Data);
+  Full:=GetParentsMemberList(aParent);
+  aCount:=1;
+  BaseName:=GetPasName(aAttr);
+  For aDef in Full do
+    if (aDef is TIDLAttributeDefinition) and ConvertDef(aDef) then
+      if (aAttr<>aDef) and (BaseName=GetPasName(aDef)) then
+        inc(aCount);
+  if aCount>1 then
+    BaseName:=BaseName+IntToStr(aCount);
+  DJob.PropertyGetterName:=GetterPrefix+BaseName;
+  DJob.PropertySetterName:=SetterPrefix+BaseName;
+end;
+
+procedure TWebIDLToPasWasmJob.AllocateAttributeGetterSetters;
+
+
+var
+  D,MD : TIDLDefinition;
+  SD : TIDLStructuredDefinition absolute D;
+  AD : TIDLAttributeDefinition absolute MD;
+
+begin
+  For D in Context.Definitions do
+    if D is TIDLStructuredDefinition then
+      For MD in GetFullMemberList(SD) do
+        if MD is TIDLAttributeDefinition then
+          AllocateAttributeGetterSetter(SD,AD);
+end;
+
+procedure TWebIDLToPasWasmJob.ProcessDefinitions;
+begin
+  Inherited ProcessDefinitions;
+  AllocateAttributeGetterSetters;
+end;
+
+
 function TWebIDLToPasWasmJob.GetFunctionSignature(aDef: TIDLFunctionDefinition; aReturnDef: TIDLDefinition; aFuncname,
   aReturnTypeName, aSuffix: TIDLString; ArgDefList: TIDLDefinitionList; out ProcKind: TIDLString): String;
 
@@ -1125,14 +1190,11 @@ begin
   FuncName:=GetPasName(FD);
   CallbackTypeName:=GetPasName(aDef);
   ReturnDef:=GetResolvedType(FD.ReturnType,RNT,ReturnTypeName,ResolvedReturnTypeName);
-  case RNT of
-  ntNone,
-  ntUnknown:
+  if RNT in [ntNone,ntUnknown] then
     begin
     ReturnTypeName:='';
     ResolvedReturnTypeName:='';
     end;
-  end;
   if ReturnDef is TIDLSequenceTypeDefDefinition then
     ReturnTypeName:=PasInterfacePrefix+'Array'+PasInterfaceSuffix
   else if ReturnDef is TIDLPromiseTypeDefDefinition then
@@ -1301,11 +1363,14 @@ end;
 
 function TWebIDLToPasWasmJob.GetPrivateGetterInfo(Attr: TIDLAttributeDefinition;out  aNativeType : TPascalNativeType; out AttrTypeName, AttrResolvedTypeName, FuncName: TIDLString) : TIDLDefinition;
 
+var
+  D : TIDLString;
+
 begin
   Result:=nil;
   if Attr.AttributeType=nil then
     exit;
-  FuncName:=GetterPrefix+GetPasName(Attr);
+  GetAccessorNames(Attr,FuncName,D);
   Result:=GetResolvedType(Attr.AttributeType,aNativeType, AttrTypeName,AttrResolvedTypeName);
   if Result is TIDLInterfaceDefinition then
     AttrTypeName:=GetPasIntfName(Result)
@@ -1347,7 +1412,6 @@ function TWebIDLToPasWasmJob.WritePrivateGetter(aParent: TIDLStructuredDefinitio
 var
   FuncName,
   AttrTypeName, AttrResolvedTypeName: TIDLString;
-  AttrType: TIDLDefinition;
   aNT : TPascalNativeType;
 
 begin
@@ -1356,19 +1420,36 @@ begin
     Exit;
   if Attr.AttributeType=nil then
     exit;
-  AttrType:=GetPrivateGetterInfo(Attr,ant,AttrTypeName,AttrResolvedTypeName,FuncName);
+  GetPrivateGetterInfo(Attr,ant,AttrTypeName,AttrResolvedTypeName,FuncName);
   AddLn('function '+FuncName+': '+AttrTypeName+'; overload;');
 end;
 
+function TWebIDLToPasWasmJob.GetAccessorNames(Attr: TIDLAttributeDefinition; out aGetter, aSetter: TIDLString): Boolean;
+
+var
+  D : TPasDataWasmJob;
+begin
+  Result:=Attr.Data is TPasDataWasmJob;
+  if Result then
+    begin
+    D:=Attr.Data as TPasDataWasmJob;
+    aGetter:=D.PropertyGetterName;
+    aSetter:=D.PropertySetterName;
+    end;
+end;
+
 function TWebIDLToPasWasmJob.GetPrivateSetterInfo(Attr: TIDLAttributeDefinition; out aNativeType: TPascalNativeType; out AttrTypeName, AttrResolvedTypeName, FuncName: TIDLString) : TIDLDefinition;
 
+var
+  D : TIDLString;
+
 begin
   Result:=nil;
   if (Attr.Name='') and (aoStringifier in Attr.Options) then
     Exit;
   if Attr.AttributeType=nil then
     exit;
-  FuncName:=SetterPrefix+GetPasName(Attr);
+  GetAccessorNames(Attr,D,FuncName);
   Result:=GetResolvedType(Attr.AttributeType,aNativeType,AttrTypeName,AttrResolvedTypeName);
   if Result is TIDLInterfaceDefinition then
     AttrTypeName:=GetPasIntfName(Result)
@@ -1480,6 +1561,7 @@ var
   PropName, Code, AttrTypeName, AttrResolvedTypeName: TIDLString;
   AttrType: TIDLDefinition;
   ANT : TPascalNativeType;
+  GetterName,SetterName : TIDLString;
 
 begin
   if aParent=nil then ;
@@ -1493,9 +1575,10 @@ begin
   AttrType:=GetResolvedType(Attr.AttributeType,ANT,AttrTypeName,AttrResolvedTypeName);
   if AttrType is TIDLInterfaceDefinition then
     AttrTypeName:=GetPasIntfName(AttrType);
-  Code:='property '+PropName+': '+AttrTypeName+' read '+GetterPrefix+PropName;
+  GetAccessorNames(Attr,GetterName,SetterName);
+  Code:='property '+PropName+': '+AttrTypeName+' read '+GetterName;
   if not (aoReadOnly in Attr.Options) then
-    Code:=Code+' write '+SetterPrefix+PropName;
+    Code:=Code+' write '+SetterName;
   Code:=Code+';';
   if AttrType is TIDLFunctionDefinition then
     Code:='// '+Code;
@@ -1643,6 +1726,57 @@ begin
   AddLn('end;');
 end;
 
+procedure TWebIDLToPasWasmJob.WriteMapLikeDeleteFunctionImplementation(aDef : TIDLStructuredDefinition; ML : TIDLMapLikeDefinition);
+
+var
+  D,aResolvedKeyTypeName,aResolvedValueTypeName: String;
+  aClassName : string;
+  KNT,VNT : TPascalNativeTYpe;
+
+begin
+  aClassName:=GetPasName(aDef);
+  GetResolvedType(ML.KeyType,KNT,D,aResolvedKeyTypeName);
+  GetResolvedType(ML.ValueType,VNT,D,aResolvedValueTypeName);
+  AddLn('Procedure %s.delete(key: %s);',[aClassName,aResolvedKeyTypeName]);
+  AddLn('begin');
+  Indent;
+  AddLn('InvokeJSNoResult(''delete'',[key]);');
+  Undent;
+  AddLn('end;');
+end;
+
+
+procedure TWebIDLToPasWasmJob.WriteMapLikeSetFunctionImplementation(aDef: TIDLStructuredDefinition; ML: TIDLMapLikeDefinition);
+var
+  D,aResolvedKeyTypeName,aResolvedValueTypeName: String;
+  aClassName : string;
+  KNT,VNT : TPascalNativeTYpe;
+
+begin
+  aClassName:=GetPasName(aDef);
+  GetResolvedType(ML.KeyType,KNT,D,aResolvedKeyTypeName);
+  GetResolvedType(ML.ValueType,VNT,D,aResolvedValueTypeName);
+  AddLn('Procedure %s.set_(key: %s; value : %s);',[aClassName,aResolvedKeyTypeName,aResolvedValueTypeName]);
+  AddLn('begin');
+  Indent;
+  AddLn('InvokeJSNoResult(''set'',[key,Value]);');
+  Undent;
+  AddLn('end;');
+end;
+
+procedure TWebIDLToPasWasmJob.WriteMapLikeClearFunctionImplementation(aDef: TIDLStructuredDefinition; ML: TIDLMapLikeDefinition);
+var
+  aClassName : string;
+begin
+  aClassName:=GetPasName(aDef);
+  AddLn('Procedure %s.clear;',[aClassName]);
+  AddLn('begin');
+  Indent;
+  AddLn('InvokeJSNoResult(''clear'',[]);');
+  Undent;
+  AddLn('end;');
+end;
+
 procedure TWebIDLToPasWasmJob.WriteMapLikeHasFunctionImplementation(aDef : TIDLStructuredDefinition; ML : TIDLMapLikeDefinition);
 
 var
@@ -1711,8 +1845,10 @@ procedure TWebIDLToPasWasmJob.WriteMapLikeFunctionImplementations(aDef : TIDLStr
 
 Var
   L : TIDLDefinitionList;
+  lReadOnly : Boolean;
 
 begin
+  lReadOnly:=MD.IsReadonly;
   L:=TIDLDefinitionList.Create(Nil,False);
   try
     aDef.GetFullMemberList(L);
@@ -1726,6 +1862,15 @@ begin
       WriteMapLikeKeysFunctionImplementation(aDef,MD);
     if not L.HasName('values') then
       WriteMapLikeValuesFunctionImplementation(aDef,MD);
+    if not lReadOnly then
+      begin
+      if Not L.HasName('set') then
+        WriteMapLikeSetFunctionImplementation(aDef,MD);
+      if Not L.HasName('clear') then
+        WriteMapLikeClearFunctionImplementation(aDef,MD);
+      if Not L.HasName('delete') then
+        WriteMapLikeDeleteFunctionImplementation(aDef,MD);
+      end;
   finally
     L.Free;
   end;