WSH: обсуждаем DynamicWrapperX от YMP - 2 (Страница 1 из 2)

LPDIRECT3D9 pDirect3D=NULL;
bool InitDirectX(void)
{
    if((pDirect3D=Direct3DCreate9(D3D_SDK_VERSION)) == NULL) return(false);
    D3DDISPLAYMODE stDisplay;
    if(FAILED(pDirect3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &stDisplay)))
        return(false);
    <...>
}

d3d9  MACRO  func, this, arglist :VARARG
 mov   eax , [this]
 mov   eax , [eax]
 IFB <arglist>
      INVOKE [IDirect3D9Vtbl. func][eax], this
 ELSE
      INVOKE [IDirect3D9Vtbl. func][eax], this, arglist
 ENDIF
ENDM

IDirect3D9Vtbl    STRUC
 <...>
 STDMETHOD    GetAdapterDisplayMode, :PTR IDirect3D9, :UINT, :PTR D3DDISPLAYMODE,
 <...>
IDirect3D9Vtbl    ENDS

 <...>
.COD
 invoke    Direct3DCreate9, D3D_SDK_VERSION
 mov    pd3d, eax
 d3d9    GetAdapterDisplayMode, pd3d, D3DADAPTER_DEFAULT, ADDR d3ddm
 <...>

var DWX=new ActiveXObject("DynamicWrapperX");
function InitDirect3D(){
 DWX.Register("d3d9.dll","Direct3DCreate9","i=u","r=p");
 var D3D_SDK_VERSION=32;
 var pDirect3D=DWX.Direct3DCreate9(D3D_SDK_VERSION);
 if(pDirect3D==0){WScript.Echo("Интерфейс Direct3D недоступен!");return 1}
 var D3DADAPTER_DEFAULT=0;
 var pDisplay=DWX.StrPtr(DWX.Space(16,""));
 var Direct3D=DWX.ObjGet(pDirect3D); // получаем интерфейс IUnknown Direct3D
 Direct3D.GetAdapterDisplayMode(D3DADAPTER_DEFAULT,pDisplay); // не работает ни один метод ((
 return 0;
}

var DX=new ActiveXObject("DynamicWrapperX");
function InitDirect3D(){
 DX.Register("d3d9.dll","Direct3DCreate9","i=u","r=p");
 var D3D_SDK_VERSION=32;
 var pDirect3D=DX.Direct3DCreate9(D3D_SDK_VERSION);
 var D3DADAPTER_DEFAULT=0;
 var IDirect3D9=new Object();
 DX.NumPut(pDirect3D,IDirect3D9); // здесь пишет ошибку...
 IDirect3D9.GetAdapterDisplayMode(D3DADAPTER_DEFAULT);
 return 0;
}

var DWX=new ActiveXObject("DynamicWrapperX");
var DWXTypes=["l","u","m","q","h","p","n","t","c","b","f","d"];//,"w","s","z","v"];
var str="x"+DWX.Bitness()+"\n";
var t0;
var t1="яяяяяяяяяяяяяяяяяяяяяяяяяяяяяяяя"; // 1111 1111
var t2="UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU"; // 0101 0101
var ptr1=DWX.StrPtr(t1,"cp1251");
var ptr2=DWX.StrPtr(t2,"cp1251");

for(var i=0;i<DWXTypes.length;i++){
 str+=DWXTypes[i]+"\t"+DWX.NumGet(ptr1,0,DWXTypes[i])+" \t\t "+DWX.NumGet(ptr2,0,DWXTypes[i])+"\n";
}
WSH.Echo(str);

var IDI_APPLICATION=0x7F00, IDC_ARROW=0x7F00, CS_VREDRAW=0x1, CS_HREDRAW=0x2,
 CS_DBLCLKS=0x8, CS_OWNDC=0x20, WS_OVERLAPPEDWINDOW=0xCF0000,
 WS_VISIBLE=0x10000000, WS_EX_TOPMOST=8, WS_POPUP=0x80000000, WM_DESTROY=0x2,
 WM_ACTIVATE=0x6, WM_CHAR=0x102, WM_SETCURSOR=0x20, WM_QUIT=0x12;

function WNDCLASSEX(){
 // UINT, UINT, WNDPROC, int, int, HINSTANCE, HICON, HCURSOR, HBRUSH, LPCTSTR, LPCTSTR, HICON
 var a=["cbSize","style","lpfnWndProc","cbClsExtra","cbWndExtra","hInstance",
  "hIcon","hCursor","hbrBackground","lpszMenuName","lpszClassName","hIconSm"];
 for(var i in a)this[a[i]]=arguments[i];
 this._const="uupllhhhhpph";
}
function getStructWin(struct){
 var types=struct._const, // строка типов в стандарте DynamicWrapperX
  size=0, // размер структуры (вначале исходной, потом возвращаемой)
  data; // информация для внесения в стуктуру
 for(var i=0;i<types.length;i++)size+=DWXTypes[types.charAt(i).toLowerCase()]; // Вычисляем размер структуры /*на строку память не выделится!!*/
 var ns=DWX.MemAlloc(size,1); // MemFree() // выделение памяти в БАЙТАХ // создание структуры (new struct)
 size=0;i=0;
 for(var p in struct){ // заполняем структуру
  if(p=="_const")continue; // исключаем из структуры МОЮ строку типов
  data=struct[p];
  if(data==null)data=0;
  DWX.NumPut(data,ns,size,types.charAt(i)); // заносим данные data в стуктуру ns со смещением size
  size+=DWXTypes[types.charAt(i++).toLowerCase()];
 }
 return ns; // возвращаем преобразованную структуру
}
function WndProc(hWnd,uMsg,wParam,lParam){ // Callback function
 switch(uMsg){
  case WM_DESTROY:
   Close=1;
   break;
 }
 return DWX.DefWindowProcW(hWnd,uMsg,wParam,lParam);
}

function InitWindow(){
 DWX.Register("user32","LoadIconW","i=hp","r=h");
 DWX.Register("user32","LoadCursorW","i=hp","r=h")
 DWX.Register("user32","RegisterClassExW","i=p","r=t"); // ATOM
 var pWndProc=DWX.RegisterCallback(WndProc,"i=huul","r=l");
 var szClass="Class_name";
 var myWClass=new WNDCLASSEX((bit==32)?48:80, CS_VREDRAW|CS_HREDRAW|CS_DBLCLKS|CS_OWNDC,
  pWndProc, 0, 0, hModule, DWX.LoadIconW(0,IDI_APPLICATION),
  DWX.LoadCursorW(0,IDC_ARROW), 0, 0, szClass, 0);
 var wc=getStructWin(myWClass);
 if(DWX.RegisterClassExW(wc)==0){WSH.Echo("Ошибка при регистрации класса.");return false}
 DWX.Register("user32.dll","CreateWindowExA","i=ussullllhhhl","r=h"); // i=DWORD,LPCTSTR,LPCTSTR,DWORD,int,int,int,int,HWND,HMENU,HINSTANCE,LPVOID r=HWND
 var szTitle="My window";
 hWnd=DWX.CreateWindowExA(0,szClass,szTitle,WS_OVERLAPPEDWINDOW|WS_VISIBLE,
  20,20,500,400,0,0,hModule,0);
 //  hWnd=DWX.CreateWindowExA(WS_EX_TOPMOST,szClass,szTitle,WS_POPUP, 0,0,800,600,0,0,hModule,0);
 if(hWnd==0){WSH.Echo("Ошибка при создании окна.");return false}
 return true;
}

var DWX=new ActiveXObject("DynamicWrapperX");
var bit=DWX.Bitness(); // разрядность процесса
// типы по стандарту DynamicWrapperX в БАЙТАХ (строковые - 0)
var DWXTypes={"l":4,"u":4,"m":8,"q":8,"h":bit/8,"p":bit/8,"n":2,"t":2,"c":1,"b":1,"f":4,"d":8,"w":0,"s":0,"z":0,"v":0};
DWX.Register("kernel32","GetModuleHandleW","i=p","r=h"); // i=(LPCTSTR); r=HMODULE
DWX.Register("user32","DefWindowProcW","i=hupp","r=l"); // i=(HWND, UINT, WPARAM, LPARAM); r=LRESULT
DWX.Register("user32","ShowWindow","i=hl","r=l"); // i=(HWND, int); r=BOOL
DWX.Register("user32","UpdateWindow","i=h","r=l"); // i=(HWND); r=BOOL
var hModule=DWX.GetModuleHandleW(0);
var hWnd=0;
var Close=0;
if(!InitWindow())WSH.Quit(); // hWnd
DWX.ShowWindow(hWnd,1);
DWX.UpdateWindow(hWnd);
do{WSH.Sleep(200);}while(Close==0);

var DWX=WScript.CreateObject("DynamicWrapperX");
var bit=DWX.Bitness(); // разрядность процесса
var dwxsize={l:4,u:4,m:8,q:8,h:bit/8,p:bit/8,n:2,t:2,c:1,b:1,f:4,d:8}; // размеры типов

function ld0n(val,n){val+="";while(val.length<n)val="0"+val;return val}
function cnv_num(val,f,t){return parseInt(val,f).toString(t).toUpperCase()} // Lower
function gethex(addr,size){
 for(var i=0,str="";i<size;i++)str+=ld0n(cnv_num(DWX.NumGet(addr,i,"b"),10,16),2);
 return str;
}

DWX.Register("advapi32.dll","GetTokenInformation","i=hupup","r=l"); // HANDLE,enum,LPVOID,DWORD,PDWORD; BOOL
DWX.Register("kernel32.dll","GetCurrentProcess","r=h"); // void; HANDLE
DWX.Register("advapi32.dll","OpenProcessToken","i=hup","r=l"); // HANDLE,DWORD,PHANDLE; BOOL
DWX.Register("kernel32.dll","LocalFree","i=h","r=h");
DWX.Register("kernel32.dll","CloseHandle","i=h","r=l");
DWX.Register("ntdll.dll","RtlMoveMemory","i=ppu"); // VOID UNALIGNED,const VOID UNALIGNED,SIZE_T; VOID

// буфер для последующего вывода
var BUFFER=DWX.MemAlloc(256,1),nBUFFER=0;

// добавляем в буфер какую-нибудь информацию
var test_str="Another info\0";
DWX.RtlMoveMemory(BUFFER+nBUFFER,test_str,test_str.length*2);
nBUFFER+=test_str.length*2;

var TOKEN_QUERY=0x0008;
var phToken=DWX.MemAlloc(dwxsize.h,1);
var hProcess=DWX.GetCurrentProcess();
DWX.OpenProcessToken(hProcess,TOKEN_QUERY,phToken);
var hToken=DWX.NumGet(phToken,0,"h");
var uSizeToken=dwxsize.p*2+28;
var ptiUser=DWX.MemAlloc(uSizeToken);
DWX.GetTokenInformation(hToken,1,ptiUser,uSizeToken,0);

// ещё добавляем информацию (User SID)
DWX.RtlMoveMemory(BUFFER+nBUFFER,DWX.NumGet(ptiUser,0,"p"),28);
nBUFFER+=28;

DWX.MemFree(ptiUser);
DWX.CloseHandle(hToken);
DWX.MemFree(phToken);
DWX.CloseHandle(hProcess);

// выводим буфер
WScript.Echo(gethex(BUFFER,nBUFFER));

var DWX=WScript.CreateObject("DynamicWrapperX.2");
var MyStruct=DWX.MemAlloc(14+2*4,0);
DWX.MemWrite("48656C6C6F2C20667269656E6473",MyStruct,14); // Hello, friends
DWX.NumPut(0x6C65645F,MyStruct,14,"u");
DWX.NumPut(0x00657465,MyStruct,18,"u");
var str0=DWX.StrGet(MyStruct,0,"s");
DWX.MemFree(MyStruct);
WScript.Echo(str0); // хочу получить "Hello, friends"
// str0=str0.substr(0,14);
var str1="Hello,\0World"; str1+=" my friend!"; // длина строки 23
WScript.Echo(DWX.MemRead(DWX.StrPtr(str1),str1.length*2,2,0));
// length=23; echo = 4800 6500 6C00 6C00 6F00 2C00 0000 5700 6F00 7200 6C00 6400 2000 6D00 7900 2000 6600 7200 6900 6500 6E00 6400 2100
// в JScript поддерживается работа со строками, содержащими терминальный 0
var MyStruct=DWX.MemAlloc(23*2+4,0);
DWX.StrPut(str1,MyStruct,0,"w");
DWX.NumPut(0x6C65645F,MyStruct,46,"u");
WScript.Echo(DWX.MemRead(MyStruct,23*2+4,2,0));
// echo = 4800 6500 6C00 6C00 6F00 2C00 0000 0100 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 FFFF 5F64 656C
// NumPut записала строку до нуля (не всю)
DWX.MemCopy(DWX.StrPtr(str1),MyStruct,23*2); // теперь запишем всю строку
var str2=DWX.StrGet(MyStruct,0,"w"); // и получим её
WScript.Echo(str2.length); // её длина стала 6
str2=DWX.Space(23,"");
DWX.MemCopy(MyStruct,DWX.StrPtr(str2),23*2);
WScript.Echo(DWX.MemRead(DWX.StrPtr(str2)-4,23*2+4,2,0));
// 2E00 0000 4800 6500 6C00 6C00 6F00 2C00 0000 5700 6F00 7200 6C00 6400 2000 6D00 7900 2000 6600 7200 6900 6500 6E00 6400 2100
// Всё в порядке
DWX.MemFree(MyStruct);

var DWX=WScript.CreateObject("DynamicWrapperX");
var bit=DWX.Bitness(); // разрядность процесса
var dwxsize={l:4,u:4,m:8,q:8,h:bit/8,p:bit/8,n:2,t:2,c:1,b:1,f:4,d:8}; // размеры типов

var defWINAPI={
 /*  4 */ LONG:"l", INT:"l", BOOL:"l", HRESULT:"l", NTSTATUS:"l", "int":"l",
 /* u4 */ ULONG:"u", UINT:"u", DWORD:"u", PUINT:"u", LPUINT:"u", ULONG32:"u", "enum":"u",
 /*  8 */ INT64:"m", LONGLONG:"m",
 /* u8 */ UINT64:"q", ULONGLONG:"q", DWORDLONG:"q", ULONG64:"q",
 /*  $ */ HANDLE:"h", HWND:"h", HMODULE:"h", HLOCAL:"h", HINSTANCE:"h", HICON:"h", HCURSOR:"h", HBRUSH:"h", HDROP:"h", PVOID:"h", INT_PTR:"h", LONG_PTR:"h", /*?*/ 
 /* u$ */ WNDPROC:"p", LPCTSTR:"p", LPCWSTR:"p", UINT_PTR:"p", WPARAM:"p", LPARAM:"p", LPVOID:"p", ULONG_PTR:"p", PULONG_PTR:"p", LRESULT:"p", SIZE_T:"p" /*unsigned*/, LPMSG:"p", PDWORD:"p", PHANDLE:"p", PSID:"p",
 /*  2 */ SHORT:"n",
 /* u2 */ USHORT:"t", WORD:"t", PWORD:"t", LPWORD:"t", WCHAR:"t", OLECHAR:"t", wchar_t:"t",
 /*  1 */ CHAR:"c", CCHAR:"c",
 /* u1 */ UCHAR:"b", BYTE:"b", PBYTE:"b", BOOLEAN:"b",
 /*  4 */ FLOAT:"f",
 /*  8 */ DOUBLE:"d",
 BSTR:"w", LPWSTR:"w", LPOLESTR:"w",
 LPSTR:"s", LPCSTRL:"s"
};
var struct={ // добавить описание обязательно к этому объекту
 use: [], // для очистки
 create: function(name,crtaddr){ // если crtaddr задан числом, отличным от 0, то память на структуру выделяться не будет
  if(typeof(struct[name])=="undefined"){WScript.Echo("Error, struct "+name+" is undefined!");WScript.Quit();return false} // исключение
  var obj={
   addr: crtaddr?crtaddr:DWX.MemAlloc(struct[name].$_size,1), // при crtaddr не выделяем память
   type: name,
   put: function(aStr,data){struct.put(this,aStr,data)},
   get: function(aStr){return struct.get(this,aStr)},
   size: struct[name].$_size,
   _nid: crtaddr?-1:struct.use.length // номер структуры, для destroy
  };
  if(!crtaddr)struct.use.push(obj);
  return obj
 },
 put: function(obj,aStr,data){
  var tp=struct[obj.type],sz=0; aStr=aStr.split(".");
  for(var i=0;i<aStr.length-1;i++){sz+=tp[aStr[i]].offset;tp=tp[aStr[i]].obj;}
  tp=tp[aStr.pop()];
  DWX.NumPut(data,obj.addr,(sz+tp.offset),tp.type);
 },
 get: function(obj,aStr){ // use: 'var SysTimeInfo=struct.create("SYSTEM_TIME_OF_DAY_INFORMATION"); SysTimeInfo.get("CurrentTime.LowPart");' - вернёт значение поля, а 'SysTimeInfo.get("CurrentTime");' вернёт указатель на поле
  var tp=struct[obj.type],sz=0,tmp; aStr=aStr.split(".");
  var charonly=false;
  for(var i=0;i<aStr.length;i++){
   tmp=aStr[i].split(/(\[)|(\])/g); // разделяем каждый элемент строки адреса по []
   tp=tp[tmp[0]]; sz+=tp.offset;
   if(tmp[1]){tmp=tmp[1]-0;charonly=true;if(tp.obj)sz+=tp.obj.$_size*tmp; else sz+=dwxsize[tp.type]*tmp;} // tmp=eval(tmp[1])-0; (убрал eval)
    else{charonly=false;}
   if(tp.obj)tp=tp.obj; else break;
  }
  if(tp.$_size)return obj.addr+sz; // если это не "лист" дерева структуры, то просто возвращаем указатель на память
  // DebugStr+=typeof(tmp)+": "+tmp+"\n";
  if((!tp.count)||charonly/*(tmp>=0) - bad*/)return DWX.NumGet(obj.addr,sz,tp.type); // (tmp>=0), где tmp=[srt,n] - чтобы при запросе str[n] не выводилась оставшаяся часть строки - bag solution (tp.count - количество элементов массива)
  // else: tmp=[str] => массив (пока обработчики только строки)
   if(tp.elemtype=="WCHAR")return DWX.StrGet(obj.addr+sz,"w"); // если это строка
   if(tp.elemtype=="UCHAR")return DWX.StrGet(obj.addr+sz,"s"); // если это строка
    WScript.Echo("TODO: добавить обработчик для типа: "+tp.elemtype); // debug
   return obj.addr+sz;
 },
 define: function(name,str,pack){ // pack - выравнивание для структуры (default(0): по максимальному члену)
  var obj={},sz=0,arg,tp;
  var align=1,tost; // new vars (renamed)
  if(!pack)pack=8; // размеры всех типов не превышают 8
  str=str.split(";");
  for(var i=0;i<str.length;i++){
   arg=str[i].split(/\s/gm);
   if(arg.length<2)continue;
   tp=defWINAPI[arg[0]];
   if(typeof(tp)=="undefined"){WScript.Echo("Error, type "+arg[0]+" is undefined!");WScript.Quit();return false} // исключение
   /* // без выравнивания:
   if(typeof(tp)=="string"){obj[arg[1]]={type:tp,offset:sz};sz+=dwxsize[tp];}
    else{obj[arg[1]]={obj:tp,offset:sz};sz+=tp.$_size}
   
   // с выравниванием:
   if(typeof(tp)=="string"){ // если тип является простым
    align=Math.max(align,dwxsize[tp]); // высчитываем общее выравнивание структуры
    tost=Math.min(pack,dwxsize[tp]); // выравнивание текущего члена (исключительно при изменении выравнивания pack)
    sz=Math.ceil(sz/tost)*tost; // отступ по выравниванию
    
    obj[arg[1]]={type:tp,offset:sz}; // создание члена в структуре
    sz+=dwxsize[tp];
   } else { // иначе (составным)
    align=Math.max(align,tp.$_align);
    tost=Math.min(pack,tp.$_align);
    sz=Math.ceil(sz/tost)*tost;
    
    obj[arg[1]]={obj:tp,offset:sz};
    sz+=tp.$_size;
   }
   */
   // с множественным обозначением (массивами)   
   var data,kdata;
   tost=arg[1].split(/(\[)|(\])/g); // temp var
   if(tost.length==1){data=arg[1];kdata=1;}else{data=tost[0];kdata=tost[1]-0;} // kdata=eval(tost[1])-0; (убрал eval)
   
   if(typeof(tp)=="string"){ // простой тип
    align=Math.max(align,dwxsize[tp]); // общее выравнивание структуры
    tost=Math.min(pack,dwxsize[tp]);
    sz=Math.ceil(sz/tost)*tost;
    
    obj[data]={type:tp,offset:sz};
    if(kdata>1){obj[data].count=kdata;obj[data].elemtype=arg[0];} // если массив (кол-во членов больше 1)
    sz+=dwxsize[tp]*kdata;
   } else { // составной тип
    align=Math.max(align,tp.$_align);
    tost=Math.min(pack,tp.$_align);
    sz=Math.ceil(sz/tost)*tost;
    
    obj[data]={obj:tp,offset:sz};
    if(kdata>1){obj[data].count=kdata;obj[data].elemtype=arg[0];}
    sz+=tp.$_size*kdata;
   }
  }
  tost=Math.min(pack,align);
  sz=Math.ceil(sz/tost)*tost; // выравниваем последний элемент структуры, оставляя после ного пустоту (правило выравнивание последнего поля)
  obj.$_size=sz;
  obj.$_align=Math.min(align,pack); // для маленьких структур
  defWINAPI[name]=obj;
  struct[name]=obj;
 },
 destroy: function(obj){DWX.MemFree(obj.addr);obj.addr=0;struct.use[obj._nid]=null;},
 destroyAll: function(){
  var t; while(struct.use.length){t=struct.use.pop();if(t!=null)struct.destroy(t);}
 }
/* Пример структуры - результат struct.define("WIN32_FIND_DATAW","DWORD dwFileAttributes; FILETIME ftCreationTime; FILETIME ftLastAccessTime; FILETIME ftLastWriteTime; DWORD nFileSizeHigh; DWORD nFileSizeLow; DWORD dwReserved0; DWORD dwReserved1; WCHAR cFileName[260]; WCHAR cAlternateFileName[14]"):
struct.WIN32_FIND_DATAW = defWINAPI.WIN32_FIND_DATAW = {
 "dwFileAttributes": {type: "u", offset: 0},
 "ftCreationTime": {
  obj: {
   "dwLowDateTime": {type: "u", offset: 0},
   "dwHighDateTime": {type: "u", offset: 4},
   $_size: 8,
   $_align: 4
  },
  offset: 4
 },
 "ftLastAccessTime": {
  obj: {
   "dwLowDateTime": {type: "u", offset: 0},
   "dwHighDateTime": {type: "u", offset: 4},
   $_size: 8,
   $_align: 4
  },
  offset: 12
 },
 "ftLastWriteTime": {
  obj: {
   "dwLowDateTime": {type: "u", offset: 0},
   "dwHighDateTime": {type: "u", offset: 4},
   $_size: 8,
   $_align: 4
  },
  offset: 20
 },
 "nFileSizeHigh": {type: "u", offset: 28},
 "nFileSizeLow": {type: "u", offset: 32},
 "dwReserved0": {type: "u", offset: 36},
 "dwReserved1": {type: "u", offset: 40},
 "cFileName": {type: "t", offset: 44, count: 260, elemtype: "WCHAR"},
 "cAlternateFileName": {type: "t", offset: 564, count: 14, elemtype: "WCHAR"},
 $_size: 592,
 $_align: 4
}
*/
}

// include
DWX.Register("kernel32.dll","FindFirstFileW","i=pp","r=h"); // LPCTSTR,LPWIN32_FIND_DATAW; HANDLE
DWX.Register("kernel32.dll","FindNextFileW","i=hp","r=l"); // HANDLE,LPWIN32_FIND_DATAW; BOOL
DWX.Register("kernel32.dll","FindClose","i=h","r=l"); // HANDLE; BOOL

// typedef
struct.define("FILETIME","DWORD dwLowDateTime; DWORD dwHighDateTime");
struct.define("WIN32_FIND_DATAW","DWORD dwFileAttributes; FILETIME ftCreationTime; FILETIME ftLastAccessTime; FILETIME ftLastWriteTime; DWORD nFileSizeHigh; DWORD nFileSizeLow; DWORD dwReserved0; DWORD dwReserved1; WCHAR cFileName[260]; WCHAR cAlternateFileName[14]"); // MAX_PATH=260

// define
var INVALID_HANDLE_VALUE=-1;

function FindFiles(path){
 var Files=[];
 var FindFileData=struct.create("WIN32_FIND_DATAW");
 var hFind=DWX.FindFirstFileW(path,FindFileData.addr);
 if(hFind!=INVALID_HANDLE_VALUE){
  while(1){
   if((FindFileData.get("dwFileAttributes")&0x10)==0) // FILE_ATTRIBUTE_DIRECTORY=0x00000010
    Files.push(FindFileData.get("cFileName")); // если не дирректория
   if(DWX.FindNextFileW(hFind,FindFileData.addr)==0)break;
  }
  DWX.FindClose(hFind);
 }
 struct.destroy(FindFileData);
 return Files;
}

// main
var DllFiles=FindFiles("C:\\Windows\\*.dll");
WScript.Echo(DllFiles.join("\n"));

var DWX=new ActiveXObject("DynamicWrapperX");
var bit=DWX.Bitness(); // разрядность процесса
// типы по стандарту DynamicWrapperX в БАЙТАХ (строковые - 0)
var DWXTypes={"l":4,"u":4,"m":8,"q":8,"h":bit/8,"p":bit/8,"n":2,"t":2,"c":1,"b":1,"f":4,"d":8,"w":0,"s":0,"z":0,"v":0};

 // функция преобразования (создания) структуры из объекта JScript (без строк)
function getStructWin(struct){
 var types=struct._const, // строка типов в стандарте DynamicWrapperX
  size=0, // размер структуры (вначале исходной, потом возвращаемой)
  data; // информация для внесения в структуру
 for(var i=0;i<types.length;i++)size+=DWXTypes[types.charAt(i).toLowerCase()]; // Вычисляем размер структуры /*на строку память не выделится!!*/
 var ns=DWX.MemAlloc(size,1); // MemFree() // выделение памяти в БАЙТАХ // создание структуры (new struct)
 size=0;i=0;
 for(var p in struct){ // заполняем структуру
  if(p=="_const")continue; // исключаем из структуры МОЮ строку типов
  data=struct[p];
  if(data==null)data=0;
  DWX.NumPut(data,ns,size,types.charAt(i)); // заносим данные data в структуру ns со смещением size
  size+=DWXTypes[types.charAt(i++).toLowerCase()];
 }
 return ns; // возвращаем преобразованную структуру
}

function getStructJS(ns,struct){ /*строки!!*/
 var types=struct._const, size=0;
 for(var i in struct){
  struct[i]=DWX.NumGet(ns,size,types.charAt(i))
  size+=DWXTypes[types.charAt(i).toLowerCase()]; // получая размер параметра
 }
 return struct; // возвращаем преобразованную структуру
}

// typedef struct
function WNDCLASSEX(){
 // UINT, UINT, WNDPROC, int, int, HINSTANCE, HICON, HCURSOR, HBRUSH, LPCTSTR, LPCTSTR, HICON
 var a=["cbSize","style","lpfnWndProc","cbClsExtra","cbWndExtra","hInstance",
  "hIcon","hCursor","hbrBackground","lpszMenuName","lpszClassName","hIconSm"];
 for(var i in a)this[a[i]]=arguments[i];
 this._const="uupllhhhhpph";
}

var IDI_APPLICATION=0x7F00, IDC_ARROW=0x7F00, CS_VREDRAW=0x1, CS_HREDRAW=0x2,
 CS_DBLCLKS=0x8, CS_OWNDC=0x20;

// использование:
DWX.Register("user32","LoadIconW","i=hp","r=h");
DWX.Register("user32","LoadCursorW","i=hp","r=h")
DWX.Register("user32","RegisterClassExW","i=p","r=t");
DWX.Register("user32","DefWindowProcW","i=hupp","r=l"); // HWND,UINT,WPARAM,LPARAM; LRESULT
DWX.Register("kernel32","GetModuleHandleW","i=p","r=h"); // i=(LPCTSTR); r=HMODULE

function WndProc(hWnd,uMsg,wParam,lParam){return DWX.DefWindowProcW(hWnd,uMsg,wParam,lParam);}
var hModule=DWX.GetModuleHandleW(0);
var pWndProc=DWX.RegisterCallback(WndProc,"i=hupp","r=l");
var szClass="DirectX9"; // То самое имя класса, которое мы будем регистрировать
// заполняем структуру и получаем её в нужном нам формате
var myWClass=new WNDCLASSEX((bit==32)?48:80, CS_VREDRAW|CS_HREDRAW|CS_DBLCLKS|CS_OWNDC,
 pWndProc, 0, 0, hModule, DWX.LoadIconW(0,IDI_APPLICATION),
 DWX.LoadCursorW(0,IDC_ARROW), 0/*цвет фона*/, 0, szClass, 0);
var wc=getStructWin(myWClass);
// регистрация класса
if(DWX.RegisterClassExW(wc)==0){WSH.Echo("Ошибка при регистрации класса.");/*return false*/}
// ... и т.д.

DWX.RegisterCallback(MainWndProc, "i=hupp", "r=p"); // HWND,UINT,WPARAM,LPARAM
...
function MainWndProc(hWnd, uMsg, wParam, lParam) {
 if(uMsg == WM_ERASEBKGND) stdout("WM_ERASEBKGND:  wParam = ("+typeof(wParam)+")"+wParam);
 if(uMsg == WM_NCPAINT) stdout("WM_NCPAINT:  wParam = ("+typeof(wParam)+")"+wParam);
 switch(uMsg) {
  case WM_DESTROY:
   DWX.PostQuitMessage(0);
   return 0;
 }
 return DWX.DefWindowProcW(hWnd, uMsg, wParam, lParam);
}