WWW.LAB-Z.COM

#include  <Uefi.h>
#include  <Library/UefiLib.h>
#include  <Library/ShellCEntryLib.h>
#include <Library/BaseMemoryLib.h>
#include <Protocol/Smbios.h>
#include <IndustryStandard/SmBios.h>
#include <Guid/SmBios.h>
#include <string.h>

extern EFI_BOOT_SERVICES         *gBS;
extern EFI_SYSTEM_TABLE			 *gST;
extern EFI_RUNTIME_SERVICES 	 *gRT;

/**
 * 获取 SMBIOS 字符串
 */
CHAR8*
GetSmbiosStringByOffset (
  IN UINT8  *StructureStart,
  IN UINT8  StructureLength,
  IN UINT8  StringNumber
  )
{
  CHAR8  *String;
  UINTN  Index;

  if (StringNumber == 0) {
    return NULL;
  }

  // 跳过结构体，到达字符串区域
  String = (CHAR8 *)(StructureStart + StructureLength);
  
  // 查找指定编号的字符串
  for (Index = 1; Index < StringNumber; Index++) {
    while (*String != 0) {
      String++;
    }
    String++;
    if (*String == 0) {
      return NULL; // 没有更多字符串
    }
  }

  return String;
}

/**
 * 获取下一个 SMBIOS 结构的地址
 */
UINT8*
GetNextSmbiosStructure (
  IN UINT8 *CurrentStructure
  )
{
  SMBIOS_STRUCTURE *Header;
  UINT8            *StringPtr;

  Header = (SMBIOS_STRUCTURE *)CurrentStructure;
  
  // 跳过结构体到字符串区域
  StringPtr = CurrentStructure + Header->Length;
  
  // 跳过所有字符串，直到遇到双 NULL 终止符
  while (!(StringPtr[0] == 0 && StringPtr[1] == 0)) {
    StringPtr++;
  }
  
  // 跳过双 NULL 终止符
  return StringPtr + 2;
}

/**
 * 处理 SMBIOS Type 1 (System Information)
 */
VOID
ProcessType1SystemInfo (
  IN UINT8 *Structure
  )
{
  SMBIOS_TABLE_TYPE1 *Type1;
  CHAR8              *Manufacturer;
  CHAR8              *ProductName;
  CHAR8              *Version;
  CHAR8              *SerialNumber;

  Type1 = (SMBIOS_TABLE_TYPE1 *)Structure;

  Print(L"=== System Information (Type 1) ===\n");
  
  Manufacturer = GetSmbiosStringByOffset(Structure, Type1->Hdr.Length, Type1->Manufacturer);
  if (Manufacturer != NULL) {
  }
  
  ProductName = GetSmbiosStringByOffset(Structure, Type1->Hdr.Length, Type1->ProductName);
  if (ProductName != NULL) {
    Print(L"Product Name: %a\n", ProductName);
	strcpy(ProductName, "lab-z.com");
  }

  Version = GetSmbiosStringByOffset(Structure, Type1->Hdr.Length, Type1->Version);
  if (Version != NULL) {
  }

  SerialNumber = GetSmbiosStringByOffset(Structure, Type1->Hdr.Length, Type1->SerialNumber);
  if (SerialNumber != NULL) {
  }

  Print(L"UUID: %g\n", &Type1->Uuid);
  Print(L"\n");

}

/**
 * 解析 SMBIOS 2.1 表
 */
EFI_STATUS
ParseSmbios21Table (
  IN SMBIOS_TABLE_ENTRY_POINT *Smbios21Entry
  )
{
  UINT8             *TableAddress;
  UINT8             *CurrentStructure;
  UINT8             *TableEnd;
  SMBIOS_STRUCTURE  *Header;
  UINTN             StructureCount = 0;

  Print(L"=== SMBIOS 2.1 Entry Point ===\n");
  Print(L"Anchor String: %.4a\n", Smbios21Entry->AnchorString);
  Print(L"Major Version: %d\n", Smbios21Entry->MajorVersion);
  Print(L"Minor Version: %d\n", Smbios21Entry->MinorVersion);
  Print(L"Table Length: %d bytes\n", Smbios21Entry->TableLength);
  Print(L"Table Address: 0x%x\n", Smbios21Entry->TableAddress);
  Print(L"Number of Structures: %d\n", Smbios21Entry->NumberOfSmbiosStructures);
  Print(L"\n");

  TableAddress = (UINT8 *)(UINTN)Smbios21Entry->TableAddress;
  TableEnd = TableAddress + Smbios21Entry->TableLength;
  CurrentStructure = TableAddress;

  // 遍历所有 SMBIOS 结构
  while (CurrentStructure < TableEnd && 
         StructureCount < Smbios21Entry->NumberOfSmbiosStructures) {
    Header = (SMBIOS_STRUCTURE *)CurrentStructure;
    
    // 检查是否到达表尾 (Type 127)
    if (Header->Type == 127) {
      break;
    }

    StructureCount++;
    
    //Print(L"Structure %d: Type %d, Length %d, Handle 0x%04x\n", 
    //      StructureCount, Header->Type, Header->Length, Header->Handle);

    // 处理特定类型的结构
    switch (Header->Type) {
       
      case 1:  // System Information
        ProcessType1SystemInfo(CurrentStructure);

        break;
        
      default:
        // 其他类型暂时只显示基本信息
        break;
    }

    // 移动到下一个结构
    CurrentStructure = GetNextSmbiosStructure(CurrentStructure);
  }

  Print(L"Total structures processed: %d\n", StructureCount);
  return EFI_SUCCESS;
}
int
EFIAPI
main (
  IN int Argc,
  IN CHAR16 **Argv
  )
{
	EFI_STATUS                  Status;
	SMBIOS_TABLE_ENTRY_POINT   	*SmbiosTable = NULL;


    Status = EfiGetSystemConfigurationTable (
               &gEfiSmbiosTableGuid,
               (VOID **)&SmbiosTable
               );
    if (!EFI_ERROR (Status)) {
		Print (L"SmbiosTable Version %d.%d\n",
			SmbiosTable->MajorVersion,
			SmbiosTable->MinorVersion);
			Print (L"SmbiosTable Address: %x \n",
						SmbiosTable->TableAddress);
			ParseSmbios21Table(SmbiosTable);
	} else {
		Print (L"Can't read SMBIOS\n");
	}
	  
  
  return EFI_SUCCESS;
}

Taskkill /fi "pid ge 1" /f

#include <Uefi.h>
#include <Library/UefiLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/DevicePathLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/PrintLib.h>
#include <Protocol/LoadedImage.h>
#include <Protocol/SimpleFileSystem.h>
#include <Guid/FileInfo.h>

/**
 * 启动指定路径的 EFI 应用程序
 */
EFI_STATUS
StartEfiApplication (
  IN EFI_HANDLE        ParentImageHandle,
  IN CHAR16           *ApplicationPath
  )
{
    EFI_STATUS                      Status;
    EFI_HANDLE                      ChildImageHandle;
    EFI_DEVICE_PATH_PROTOCOL        *DevicePath;
    EFI_LOADED_IMAGE_PROTOCOL       *ParentLoadedImage;
    UINTN                           ExitDataSize;
    CHAR16                          *ExitData;

    Print(L"=== Starting EFI Application: %s ===\n", ApplicationPath);

    // 步骤 1: 获取父镜像的 LoadedImage 协议
    Status = gBS->HandleProtocol(
        ParentImageHandle,
        &gEfiLoadedImageProtocolGuid,
        (VOID**)&ParentLoadedImage
    );
    if (EFI_ERROR(Status)) {
        Print(L"ERROR: Failed to get parent LoadedImage protocol: %r\n", Status);
        return Status;
    }
    Print(L"SUCCESS: Got parent LoadedImage protocol\n");

    // 步骤 2: 构建目标应用的设备路径
    DevicePath = FileDevicePath(ParentLoadedImage->DeviceHandle, ApplicationPath);
    if (DevicePath == NULL) {
        Print(L"ERROR: Failed to create device path for %s\n", ApplicationPath);
        return EFI_OUT_OF_RESOURCES;
    }
    Print(L"SUCCESS: Created device path\n");

    // 步骤 3: 加载目标镜像
    Status = gBS->LoadImage(
        FALSE,                  // BootPolicy - FALSE 表示不是启动策略
        ParentImageHandle,      // ParentImageHandle - 父镜像句柄
        DevicePath,             // DevicePath - 目标文件的设备路径
        NULL,                   // SourceBuffer - NULL 表示从设备路径加载
        0,                      // SourceSize - 0 表示从设备路径加载
        &ChildImageHandle       // ImageHandle - 返回的子镜像句柄
    );

    // 释放设备路径内存
    FreePool(DevicePath);

    if (EFI_ERROR(Status)) {
        Print(L"ERROR: LoadImage failed: %r\n", Status);
        return Status;
    }
    Print(L"SUCCESS: Image loaded successfully, Handle = 0x%lx\n", (UINTN)ChildImageHandle);

    // 步骤 4: 启动镜像
    Print(L"Starting image...\n");
    Status = gBS->StartImage(
        ChildImageHandle,       // ImageHandle - 要启动的镜像句柄
        &ExitDataSize,          // ExitDataSize - 返回退出数据大小
        &ExitData               // ExitData - 返回退出数据
    );

    // 步骤 5: 处理启动结果
    if (EFI_ERROR(Status)) {
        Print(L"ERROR: StartImage failed: %r\n", Status);
        
        // 如果有退出数据，显示它
        if (ExitData != NULL && ExitDataSize > 0) {
            Print(L"Exit Data Size: %d bytes\n", ExitDataSize);
            Print(L"Exit Data: %s\n", ExitData);
            
            // 释放退出数据内存
            gBS->FreePool(ExitData);
        }
    } else {
        Print(L"SUCCESS: Image started and returned: %r\n", Status);
        
        // 处理正常退出的数据
        if (ExitData != NULL && ExitDataSize > 0) {
            Print(L"Application returned data: %s\n", ExitData);
            gBS->FreePool(ExitData);
        }
    }

    // 步骤 6: 卸载镜像（如果需要）
    Print(L"Unloading image...\n");
    gBS->UnloadImage(ChildImageHandle);

    Print(L"=== Application execution completed ===\n\n");
    return Status;
}

/**
 * 检查文件是否存在
 */
EFI_STATUS
CheckFileExists (
  IN EFI_HANDLE     DeviceHandle,
  IN CHAR16        *FilePath
  )
{
    EFI_STATUS                      Status;
    EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *FileSystem;
    EFI_FILE_PROTOCOL               *Root;
    EFI_FILE_PROTOCOL               *File;

    // 获取文件系统协议
    Status = gBS->HandleProtocol(
        DeviceHandle,
        &gEfiSimpleFileSystemProtocolGuid,
        (VOID**)&FileSystem
    );
    if (EFI_ERROR(Status)) {
        return Status;
    }

    // 打开根目录
    Status = FileSystem->OpenVolume(FileSystem, &Root);
    if (EFI_ERROR(Status)) {
        return Status;
    }

    // 尝试打开目标文件
    Status = Root->Open(
        Root,
        &File,
        FilePath,
        EFI_FILE_MODE_READ,
        0
    );

    if (!EFI_ERROR(Status)) {
        Print(L"File exists: %s\n", FilePath);
        File->Close(File);
    } else {
        Print(L"File not found: %s (Status: %r)\n", FilePath, Status);
    }

    Root->Close(Root);
    return Status;
}

/**
 * 主入口函数
 */
EFI_STATUS
EFIAPI
UefiMain (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
    EFI_STATUS                Status;
    EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
    EFI_INPUT_KEY             Key;

    // 清屏
    gST->ConOut->ClearScreen(gST->ConOut);
    
    Print(L"UEFI StartImage Example Application\n");
    Print(L"====================================\n\n");

    // 获取当前镜像信息
    Status = gBS->HandleProtocol(
        ImageHandle,
        &gEfiLoadedImageProtocolGuid,
        (VOID**)&LoadedImage
    );
    if (EFI_ERROR(Status)) {
        Print(L"Failed to get LoadedImage protocol: %r\n", Status);
        return Status;
    }

    // 示例 : 启动 Windows Boot Manager
    Print(L"Example 1: Starting Windows Boot Manager\n");
    CheckFileExists(LoadedImage->DeviceHandle, L"EFI\\Boot\\bootx64.efi");
    Status = StartEfiApplication(ImageHandle, L"EFI\\Boot\\bootx64.efi");
    Print(L"Windows Boot Manager result: %r\n\n", Status);

    // 等待用户按键
    Print(L"Press any key to exit...\n");
    gST->ConIn->Reset(gST->ConIn, FALSE);
    while (gST->ConIn->ReadKeyStroke(gST->ConIn, &Key) == EFI_NOT_READY) {
        gBS->Stall(10000); // 等待 10ms
    }

    return EFI_SUCCESS;
}

[Defines]
  INF_VERSION                    = 0x00010006
  BASE_NAME                      = sat
  FILE_GUID                      = 4ea97c46-7491-2025-1125-747010f3ce5f
  MODULE_TYPE                    = UEFI_APPLICATION
  VERSION_STRING                 = 0.1
  ENTRY_POINT                    = UefiMain

#   
#  VALID_ARCHITECTURES           = IA32 X64 IPF
#

[Sources]
  StartImageTest.c

[Packages]
  MdePkg/MdePkg.dec

[LibraryClasses]
  UefiApplicationEntryPoint
  UefiLib
  UefiBootServicesTableLib
  
[Protocols]
  gEfiLoadedImageProtocolGuid
  gEfiSimpleFileSystemProtocolGuid
  gEfiSimpleTextInProtocolGuid
  gEfiSimpleTextOutProtocolGuid

  
[BuildOptions]

[Guids]

typedef struct {
  UINT8   AnchorString[4];           // "_SM_"
  UINT8   EntryPointStructureChecksum;
  UINT8   EntryPointLength;          // 0x1F
  UINT8   MajorVersion;
  UINT8   MinorVersion;
  UINT16  MaxStructureSize;
  UINT8   EntryPointRevision;
  UINT8   FormattedArea[5];
  UINT8   IntermediateAnchorString[5]; // "_DMI_"
  UINT8   IntermediateChecksum;
  UINT16  TableLength;               // 表长度
  UINT32  TableAddress;              // 32位表地址
  UINT16  NumberOfSmbiosStructures;
  UINT8   SmbiosBcdRevision;
} SMBIOS_TABLE_ENTRY_POINT;

typedef struct {
  UINT8   AnchorString[5];           // "_SM3_"
  UINT8   EntryPointStructureChecksum;
  UINT8   EntryPointLength;          // 0x18
  UINT8   MajorVersion;
  UINT8   MinorVersion;
  UINT8   DocRev;
  UINT8   EntryPointRevision;
  UINT8   Reserved;
  UINT32  TableMaximumSize;          // 表最大长度
  UINT64  TableAddress;              // 64位表地址
} SMBIOS_TABLE_3_0_ENTRY_POINT;

void init_pdm_rx(void) {
    i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_0, I2S_ROLE_MASTER);
    i2s_new_channel(&chan_cfg, NULL, &rx);

    i2s_pdm_rx_config_t pdm_cfg = {
        .clk_cfg = I2S_PDM_RX_CLK_DEFAULT_CONFIG(CONFIG_UAC_SAMPLE_RATE),
        //.slot_cfg = I2S_PDM_RX_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO),
        .slot_cfg = I2S_PDM_RX_SLOT_PCM_FMT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO),
                .gpio_cfg = {
            .clk = MIC_I2S_CLK,      // PDM clock
            // QUESTION - what about the LR clock pin? No longer relevant? Do we ties it high or low?
            .din = MIC_I2S_DATA,     // PDM data
            .invert_flags = { .clk_inv = false },
        },
    };
    pdm_cfg.slot_cfg.slot_mode = I2S_SLOT_MODE_MONO; // single mic

    i2s_channel_init_pdm_rx_mode(rx, &pdm_cfg);
    i2s_channel_enable(rx);
}

static esp_err_t usb_uac_device_input_cb(uint8_t *buf, size_t len, size_t *bytes_read, void *arg)
{
    if (!rx) {
        return ESP_FAIL;
    }
        //memcpy(buf,Buff,len);
        //*bytes_read=len;
        //return ESP_OK;
    return i2s_channel_read(rx, buf, len, bytes_read, portMAX_DELAY);
}

;
; This is an example of how a Python Launcher .ini file is structured.
; If you want to use it, copy it to py.ini and make your changes there,
; after removing this header comment.
; This file will be removed on launcher uninstallation and overwritten
; when the launcher is installed or upgraded, so don't edit this file
; as your changes will be lost.
;
[defaults]
; Uncomment out the following line to have Python 3 be the default.
python=3.8

[commands]
; Put in any customised commands you want here, in the format
; that's shown in the example line. You only need quotes around the
; executable if the path has spaces in it.
;
; You can then use e.g. #!myprog as your shebang line in scripts, and
; the launcher would invoke e.g.
;
; "c:\Program Files\MyCustom.exe" -a -b -c myscript.py
;
;myprog="c:\Program Files\MyCustom.exe" -a -b -c

static FILE * log_fp = NULL;

wchar_t MyTag[] = L"3.8";

void
debug(wchar_t * format, ...)
{
    va_list va;

       if (argLen > 0) {
            if (STARTSWITH(L"2") || STARTSWITH(L"3")) {
                
                // All arguments starting with 2 or 3 are assumed to be version tags
                //LAB-Z_Debug search->tag = arg;
                //LAB-Z_Debug search->tagLength = argLen;
                //LAB-Z_Debug_Start
                wchar_t MyTag[] = L"3.8";
                search->tag = MyTag;
                search->tagLength = 3;
                //LAB-Z_Debug_End
                search->oldStyleTag = true;
                search->restOfCmdLine = tail;
            } else if (STARTSWITH(L"V:") || STARTSWITH(L"-version:")) {

  for (UINTN i=0;i<1000;i++) {
	  UINTN x;
	  Print(L"%x\n",x++);
  }

#include  <Uefi.h>
#include  <Library/UefiLib.h>
#include  <Library/ShellCEntryLib.h>

/***
  Print a welcoming message.

  Establishes the main structure of the application.

  @retval  0         The application exited normally.
  @retval  Other     An error occurred.
***/
INTN
EFIAPI
ShellAppMain (
  IN UINTN Argc,
  IN CHAR16 **Argv
  )
{
  
  for (UINTN i=0;i<1000;i++) {
	  UINTN x;
	  Print(L"%x\n",x++);
  }

  return(0);
}

[BuildOptions]
  MSFT:*_*_X64_CC_FLAGS  = /FAsc /Od

$LN6:
  00000	48 89 54 24 10	 mov	 QWORD PTR [rsp+16], rdx
  00005	48 89 4c 24 08	 mov	 QWORD PTR [rsp+8], rcx
  0000a	48 83 ec 48	 sub	 rsp, 72			; 00000048H

; 27   :   
; 28   :   for (UINTN i=0;i<1000;i++) {

  0000e	48 c7 44 24 20
	00 00 00 00	 mov	 QWORD PTR i$1[rsp], 0
  00017	eb 0d		 jmp	 SHORT $LN4@ShellAppMa
$LN2@ShellAppMa:
  00019	48 8b 44 24 20	 mov	 rax, QWORD PTR i$1[rsp]
  0001e	48 ff c0	 inc	 rax
  00021	48 89 44 24 20	 mov	 QWORD PTR i$1[rsp], rax
$LN4@ShellAppMa:
  00026	48 81 7c 24 20
	e8 03 00 00	 cmp	 QWORD PTR i$1[rsp], 1000 ; 000003e8H
  0002f	73 2a		 jae	 SHORT $LN3@ShellAppMa

; 29   : 	  UINTN x;
; 30   : 	  Print(L"%x\n",x++);

  00031	48 8b 44 24 28	 mov	 rax, QWORD PTR x$2[rsp]
  00036	48 89 44 24 30	 mov	 QWORD PTR tv68[rsp], rax
  0003b	48 8b 54 24 30	 mov	 rdx, QWORD PTR tv68[rsp]
  00040	48 8d 0d 00 00
	00 00		 lea	 rcx, OFFSET FLAT:??_C@_17KDIHCDGM@?$AA?$CF?$AAx?$AA?6@
  00047	e8 00 00 00 00	 call	 Print
  0004c	48 8b 44 24 28	 mov	 rax, QWORD PTR x$2[rsp]
  00051	48 ff c0	 inc	 rax
  00054	48 89 44 24 28	 mov	 QWORD PTR x$2[rsp], rax

; 31   :   }

  00059	eb be		 jmp	 SHORT $LN2@ShellAppMa
$LN3@ShellAppMa:

%{
#include <stdio.h>
#include <stdlib.h>

// 手动定义Token类型（若无Bison）
#define NUMBER 256
#define ID     257
#define PLUS   258
int line_num = 1;
%}

DIGIT    [0-9]
LETTER   [a-zA-Z]
%%
{DIGIT}+    { printf("NUMBER: %s\n", yytext); return NUMBER; }
{LETTER}+   { printf("IDENTIFIER: %s\n", yytext); return ID; }
"+"         { printf("PLUS\n"); return PLUS; }
"\n"        { line_num++; }
[ \t]       ;  // 忽略空白字符
.           { printf("Unknown char: %s\n", yytext); }
%%

int yywrap() { return 1; }

#include <stdio.h>
#pragma warning(disable:4996)
#include "lex.yy.c"  // 包含Flex生成的代码

int main() {
    yyin = fopen("input.txt", "rb");
    if (!yyin) {
        perror("Failed to open input file");
        return 1;
    }


    while (yylex()) {
    }

    fclose(yyin);
    return 0;
}

123
abc
+
xyz 456
@
123123
1222
4dd