이 데이터 구문 분석 문제를 어떻게 해결 하시겠습니까?
https://stackoverflow.com/questions/819036
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
이것은 다소 긴 질문이므로 저와 함께 제발 제발.
우리는 동시에 개발중인 하드웨어에 대한 에뮬레이터를 구현하고 있습니다. 아이디어는 제 3 자에게 클라이언트 소프트웨어를 테스트하고 하드웨어 개발자에게 펌웨어를 구현할 수있는 참조 포인트를 제공하는 소프트웨어 솔루션을 제공하는 것입니다.
하드웨어 프로토콜을 작성한 사람들은 inca_xdr이라는 Sun XDR의 사용자 정의 버전을 사용했습니다. 메시지를 직렬화하고 해제하는 도구입니다. C로 작성되었으며 기본 코드를 피하여 프로토콜 데이터를 수동으로 구문 분석하고 싶습니다.
프로토콜은 본질적으로 다소 복잡하며 데이터 패킷은 여러 구조를 가질 수 있지만 항상 동일한 글로벌 구조를 가지고 있습니다.
헤드] [소개] [데이터] [꼬리
[HEAD] =
byte sync 0x03
byte length X [MSB] X = length of [HEADER] + [INTRO] + [DATA]
byte length X [LSB] X = length of [HEADER] + [INTRO] + [DATA]
byte check X [MSB] X = crc of [INTRO] [DATA]
byte check X [LSB] X = crc of [INTRO] [DATA]
byte headercheck X X = XOR over [SYNC] [LENGTH] [CHECK]
[INTRO]
byte version 0x03
byte address X X = 0 for point-to-point, 1-254 for specific controller, 255 = broadcast
byte sequence X X = sequence number
byte group X [MSB] X = The category of the message
byte group X [LSB] X = The category of the message
byte type X [MSB] X = The id of the message
byte type X [LSB] X = The id of the message
[DATA] =
The actuall data for the specified message,
this format really differs a lot.
It always starts with a DRCode which is one byte.
It more or less specifies the general structure of
the data, but even within the same structure the data
can mean many different things and have different lenghts.
(I think this is an artifact of the INCA_XDR tool)
[TAIL] =
byte 0x0D
보시다시피 많은 오버 헤드 데이터가 있지만 프로토콜은 RS232 (Point-to-Multipoint) 및 TCP/IP (P2P)와 함께 작동해야하기 때문입니다.
name size value
drcode 1 1
name 8 contains a name that can be used as a file name (only alphanumeric characters allowed)
timestamp 14 yyyymmddhhmmss contains timestamp of bitmap library
size 4 size of bitmap library to be loaded
options 1 currently no options
또는 완전히 다른 구조를 가질 수 있습니다.
name size value
drcode 1 2
lastblock 1 0 - 1 1 indicates last block. Firmware can be stored
blocknumber 2 Indicates block of firmware
blocksize 2 N size of block to load
blockdata N data of block of firmware
때로는 Drcode 일 뿐이며 추가 데이터가 없습니다.
그룹 및 유형 필드를 기반으로 에뮬레이터는 특정 동작을 수행해야합니다. 따라서 먼저 우리는이 두 필드를보고 데이터에 대해 무엇을 기대 해야하는지 알고 제대로 구문 분석해야합니다.
그런 다음 응답 데이터를 생성해야하며, 이는 다시 많은 다른 데이터 구조를 갖는 응답 데이터를 생성해야합니다. 일부 메시지는 단순히 ACK 또는 Nack 메시지를 생성하는 반면 다른 메시지는 데이터로 실제 답변을 생성합니다.
우리는 작은 조각으로 물건을 부수기로 결정했습니다.
우선 Idataprocessor가 있습니다.
이 인터페이스를 구현하는 클래스는 원시 데이터를 검증하고 메시지 클래스의 인스턴스를 생성하는 데 도움이됩니다. 그들은 통신에 대해 책임을지지 않으며, 단순히 바이트가 통과됩니다 [
원시 데이터 유효성 검사는 체크섬, CRC 및 길이 오류가 헤더를 확인하는 것을 의미합니다.
결과 메시지는 ImessageProcessor를 구현하는 클래스로 전달됩니다. 원시 데이터가 유효하지 않은 것으로 간주 되더라도 Idataprocessor에 응답 메시지 나 다른 것에 대한 개념이 없기 때문에 원시 데이터를 검증하기 만하면됩니다.
ImessageProcessor에 오류에 대해 알리기 위해 일부 추가 속성이 메시지 클래스에 추가되었습니다.
bool nakError = false;
bool tailError = false;
bool crcError = false;
bool headerError = false;
bool lengthError = false;
그들은 프로토콜과 관련이 없으며 iMessageProcessor에만 존재합니다.
ImessageProcessor는 실제 작업이 수행되는 곳입니다. 모든 다른 메시지 그룹과 유형으로 인해 패턴 일치는 중첩 된 if/else 및 caste 문을 피하는 좋은 방법처럼 보였기 때문에 F#을 사용하기로 결정했습니다. (F# 또는 LINQ 및 SQL 이외의 기능 언어에 대한 사전 경험이 없습니다)
ImessageProcessor는 데이터를 분석하고 ihardwarecontroller에서 어떤 방법을 호출 해야하는지 결정합니다. ihardwarecontroller를 갖는 것은 중복적 인 것처럼 보이지만 다른 구현으로 교체 할 수 있고 F#을 사용하지 않기를 원합니다. 현재 구현은 WPF 창이지만 코코아# 창 또는 단순히 콘솔 일 수 있습니다.
ihardwarecontroller는 또한 개발자가 사용자 인터페이스를 통해 하드웨어 매개 변수와 오류를 조작 할 수 있어야하기 때문에 상태 관리를 담당합니다.
따라서 ImessageProcessor가 ihardwarecontroller에서 올바른 방법을 호출하면 응답 메시지를 생성해야합니다. 다시 ...이 응답 메시지의 데이터는 여러 가지 구조를 가질 수 있습니다.
결국 IDATAFACTORY는 메시지를 통신에 담당하는 클래스로 전송 될 준비가 된 RAW 프로토콜 데이터로 메시지를 변환하는 데 사용됩니다. (예를 들어 데이터의 추가 캡슐화가 필요할 수 있습니다)
이것은이 코드를 작성하는 것에 대해 "어려운"것이 아니지만 모든 다른 명령과 데이터 구조에는 많은 코드가 필요하며 재사용 할 수있는 것은 거의 없습니다. (적어도 내가 볼 수있는 한, 누군가가 나를 잘못 증명할 수 있기를 바라고 있습니다)
F#을 처음 사용하는 것은 이번이 처음이므로 실제로 갈 때 배우고 있습니다. 아래 코드는 완성되지 않았으며 아마도 거대한 혼란처럼 보일 것입니다. 프로토콜의 모든 메시지만을 구현하며 많은 메시지가 많이 있다고 말할 수 있습니다. 그래서이 파일은 커질 것입니다!
알아야 할 중요 : 바이트 순서는 와이어를 통해 역전됩니다 (역사적 이유)
module Arendee.Hardware.MessageProcessors
open System;
open System.Collections
open Arendee.Hardware.Extenders
open Arendee.Hardware.Interfaces
open System.ComponentModel.Composition
open System.Threading
open System.Text
let VPL_NOERROR = (uint16)0
let VPL_CHECKSUM = (uint16)1
let VPL_FRAMELENGTH = (uint16)2
let VPL_OUTOFSEQUENCE = (uint16)3
let VPL_GROUPNOTSUPPORTED = (uint16)4
let VPL_REQUESTNOTSUPPORTED = (uint16)5
let VPL_EXISTS = (uint16)6
let VPL_INVALID = (uint16)7
let VPL_TYPERROR = (uint16)8
let VPL_NOTLOADING = (uint16)9
let VPL_NOTFOUND = (uint16)10
let VPL_OUTOFMEM = (uint16)11
let VPL_INUSE = (uint16)12
let VPL_SIZE = (uint16)13
let VPL_BUSY = (uint16)14
let SYNC_BYTE = (byte)0xE3
let TAIL_BYTE = (byte)0x0D
let MESSAGE_GROUP_VERSION = 3uy
let MESSAGE_GROUP = 701us
[<Export(typeof<IMessageProcessor>)>]
type public StandardMessageProcessor() = class
let mutable controller : IHardwareController = null
interface IMessageProcessor with
member this.ProcessMessage m : Message =
printfn "%A" controller.Status
controller.Status <- ControllerStatusExtender.DisableBit(controller.Status,ControllerStatus.Nak)
match m with
| m when m.LengthError -> this.nakResponse(m,VPL_FRAMELENGTH)
| m when m.CrcError -> this.nakResponse(m,VPL_CHECKSUM)
| m when m.HeaderError -> this.nakResponse(m,VPL_CHECKSUM)
| m -> this.processValidMessage m
| _ -> null
member public x.HardwareController
with get () = controller
and set y = controller <- y
end
member private this.processValidMessage (m : Message) =
match m.Intro.MessageGroup with
| 701us -> this.processDefaultGroupMessage(m);
| _ -> this.nakResponse(m, VPL_GROUPNOTSUPPORTED);
member private this.processDefaultGroupMessage(m : Message) =
match m.Intro.MessageType with
| (1us) -> this.firmwareVersionListResponse(m) //ListFirmwareVersions 0
| (2us) -> this.StartLoadingFirmwareVersion(m) //StartLoadingFirmwareVersion 1
| (3us) -> this.LoadFirmwareVersionBlock(m) //LoadFirmwareVersionBlock 2
| (4us) -> this.nakResponse(m, VPL_FRAMELENGTH) //RemoveFirmwareVersion 3
| (5us) -> this.nakResponse(m, VPL_FRAMELENGTH) //ActivateFirmwareVersion 3
| (12us) -> this.nakResponse(m,VPL_FRAMELENGTH) //StartLoadingBitmapLibrary 2
| (13us) -> this.nakResponse(m,VPL_FRAMELENGTH) //LoadBitmapLibraryBlock 2
| (21us) -> this.nakResponse(m, VPL_FRAMELENGTH) //ListFonts 0
| (22us) -> this.nakResponse(m, VPL_FRAMELENGTH) //LoadFont 4
| (23us) -> this.nakResponse(m, VPL_FRAMELENGTH) //RemoveFont 3
| (24us) -> this.nakResponse(m, VPL_FRAMELENGTH) //SetDefaultFont 3
| (31us) -> this.nakResponse(m, VPL_FRAMELENGTH) //ListParameterSets 0
| (32us) -> this.nakResponse(m, VPL_FRAMELENGTH) //LoadParameterSets 4
| (33us) -> this.nakResponse(m, VPL_FRAMELENGTH) //RemoveParameterSet 3
| (34us) -> this.nakResponse(m, VPL_FRAMELENGTH) //ActivateParameterSet 3
| (35us) -> this.nakResponse(m, VPL_FRAMELENGTH) //GetParameterSet 3
| (41us) -> this.nakResponse(m, VPL_FRAMELENGTH) //StartSelfTest 0
| (42us) -> this.returnStatus(m) //GetStatus 0
| (43us) -> this.nakResponse(m, VPL_FRAMELENGTH) //GetStatusDetail 0
| (44us) -> this.ResetStatus(m) //ResetStatus 5
| (45us) -> this.nakResponse(m, VPL_FRAMELENGTH) //SetDateTime 6
| (46us) -> this.nakResponse(m, VPL_FRAMELENGTH) //GetDateTime 0
| _ -> this.nakResponse(m, VPL_REQUESTNOTSUPPORTED)
(* The various responses follow *)
//Generate a NAK response
member private this.nakResponse (message : Message , error) =
controller.Status <- controller.Status ||| ControllerStatus.Nak
let intro = new MessageIntro()
intro.MessageGroupVersion <- MESSAGE_GROUP_VERSION
intro.Address <- message.Intro.Address
intro.SequenceNumber <- this.setHigh(message.Intro.SequenceNumber)
intro.MessageGroup <- MESSAGE_GROUP
intro.MessageType <- 130us
let errorBytes = UShortExtender.ToIntelOrderedByteArray(error)
let data = Array.zero_create(5)
let x = this.getStatusBytes
let y = this.getStatusBytes
data.[0] <- 7uy
data.[1..2] <- this.getStatusBytes
data.[3..4] <- errorBytes
let header = this.buildHeader intro data
let message = new Message()
message.Header <- header
message.Intro <- intro
message.Tail <- TAIL_BYTE
message.Data <- data
message
//Generate an ACK response
member private this.ackResponse (message : Message) =
let intro = new MessageIntro()
intro.MessageGroupVersion <- MESSAGE_GROUP_VERSION
intro.Address <- message.Intro.Address
intro.SequenceNumber <- this.setHigh(message.Intro.SequenceNumber)
intro.MessageGroup <- MESSAGE_GROUP
intro.MessageType <- 129us
let data = Array.zero_create(3);
data.[0] <- 0x05uy
data.[1..2] <- this.getStatusBytes
let header = this.buildHeader intro data
message.Header <- header
message.Intro <- intro
message.Tail <- TAIL_BYTE
message.Data <- data
message
//Generate a ReturnFirmwareVersionList
member private this.firmwareVersionListResponse (message : Message) =
//Validation
if message.Data.[0] <> 0x00uy then
this.nakResponse(message,VPL_INVALID)
else
let intro = new MessageIntro()
intro.MessageGroupVersion <- MESSAGE_GROUP_VERSION
intro.Address <- message.Intro.Address
intro.SequenceNumber <- this.setHigh(message.Intro.SequenceNumber)
intro.MessageGroup <- MESSAGE_GROUP
intro.MessageType <- 132us
let firmwareVersions = controller.ReturnFirmwareVersionList();
let firmwareVersionBytes = BitConverter.GetBytes((uint16)firmwareVersions.Count) |> Array.rev
//Create the data
let data = Array.zero_create(3 + (int)firmwareVersions.Count * 27)
data.[0] <- 0x09uy //drcode
data.[1..2] <- firmwareVersionBytes //Number of firmware versions
let mutable index = 0
let loops = firmwareVersions.Count - 1
for i = 0 to loops do
let nameBytes = ASCIIEncoding.ASCII.GetBytes(firmwareVersions.[i].Name) |> Array.rev
let timestampBytes = this.getTimeStampBytes firmwareVersions.[i].Timestamp |> Array.rev
let sizeBytes = BitConverter.GetBytes(firmwareVersions.[i].Size) |> Array.rev
data.[index + 3 .. index + 10] <- nameBytes
data.[index + 11 .. index + 24] <- timestampBytes
data.[index + 25 .. index + 28] <- sizeBytes
data.[index + 29] <- firmwareVersions.[i].Status
index <- index + 27
let header = this.buildHeader intro data
message.Header <- header
message.Intro <- intro
message.Data <- data
message.Tail <- TAIL_BYTE
message
//Generate ReturnStatus
member private this.returnStatus (message : Message) =
//Validation
if message.Data.[0] <> 0x00uy then
this.nakResponse(message,VPL_INVALID)
else
let intro = new MessageIntro()
intro.MessageGroupVersion <- MESSAGE_GROUP_VERSION
intro.Address <- message.Intro.Address
intro.SequenceNumber <- this.setHigh(message.Intro.SequenceNumber)
intro.MessageGroup <- MESSAGE_GROUP
intro.MessageType <- 131us
let statusDetails = controller.ReturnStatus();
let sizeBytes = BitConverter.GetBytes((uint16)statusDetails.Length) |> Array.rev
let detailBytes = ASCIIEncoding.ASCII.GetBytes(statusDetails) |> Array.rev
let data = Array.zero_create(statusDetails.Length + 5)
data.[0] <- 0x08uy
data.[1..2] <- this.getStatusBytes
data.[3..4] <- sizeBytes //Details size
data.[5..5 + statusDetails.Length - 1] <- detailBytes
let header = this.buildHeader intro data
message.Header <- header
message.Intro <- intro
message.Data <- data
message.Tail <- TAIL_BYTE
message
//Reset some status bytes
member private this.ResetStatus (message : Message) =
if message.Data.[0] <> 0x05uy then
this.nakResponse(message, VPL_INVALID)
else
let flagBytes = message.Data.[1..2] |> Array.rev
let flags = Enum.ToObject(typeof<ControllerStatus>,BitConverter.ToInt16(flagBytes,0)) :?> ControllerStatus
let retVal = controller.ResetStatus flags
if retVal <> 0x00us then
this.nakResponse(message,retVal)
else
this.ackResponse(message)
//StartLoadingFirmwareVersion (Ack/Nak)
member private this.StartLoadingFirmwareVersion (message : Message) =
if (message.Data.[0] <> 0x01uy) then
this.nakResponse(message, VPL_INVALID)
else
//Analyze the data
let name = message.Data.[1..8] |> Array.rev |> ASCIIEncoding.ASCII.GetString
let text = message.Data.[9..22] |> Array.rev |> Seq.map(fun x -> ASCIIEncoding.ASCII.GetBytes(x.ToString()).[0]) |> Seq.to_array |> ASCIIEncoding.ASCII.GetString
let timestamp = DateTime.ParseExact(text,"yyyyMMddHHmmss",Thread.CurrentThread.CurrentCulture)
let size = BitConverter.ToUInt32(message.Data.[23..26] |> Array.rev,0)
let overwrite =
match message.Data.[27] with
| 0x00uy -> false
| _ -> true
//Create a FirmwareVersion instance
let firmware = new FirmwareVersion();
firmware.Name <- name
firmware.Timestamp <- timestamp
firmware.Size <- size
let retVal = controller.StartLoadingFirmwareVersion(firmware,overwrite)
if retVal <> 0x00us then
this.nakResponse(message, retVal) //The controller denied the request
else
this.ackResponse(message);
//LoadFirmwareVersionBlock (ACK/NAK)
member private this.LoadFirmwareVersionBlock (message : Message) =
if message.Data.[0] <> 0x02uy then
this.nakResponse(message, VPL_INVALID)
else
//Analyze the data
let lastBlock =
match message.Data.[1] with
| 0x00uy -> false
| _true -> true
let blockNumber = BitConverter.ToUInt16(message.Data.[2..3] |> Array.rev,0)
let blockSize = BitConverter.ToUInt16(message.Data.[4..5] |> Array.rev,0)
let blockData = message.Data.[6..6 + (int)blockSize - 1] |> Array.rev
let retVal = controller.LoadFirmwareVersionBlock(lastBlock, blockNumber, blockSize, blockData)
if retVal <> 0x00us then
this.nakResponse(message, retVal)
else
this.ackResponse(message)
(* Helper methods *)
//We need to convert the DateTime instance to a byte[] understood by the device "yyyymmddhhmmss"
member private this.getTimeStampBytes (date : DateTime) =
let stringNumberToByte s = Byte.Parse(s.ToString()) //Casting to (byte) would give different results
let yearString = date.Year.ToString("0000")
let monthString = date.Month.ToString("00")
let dayString = date.Day.ToString("00")
let hourString = date.Hour.ToString("00")
let minuteString = date.Minute.ToString("00")
let secondsString = date.Second.ToString("00")
let y1 = stringNumberToByte yearString.[0]
let y2 = stringNumberToByte yearString.[1]
let y3 = stringNumberToByte yearString.[2]
let y4 = stringNumberToByte yearString.[3]
let m1 = stringNumberToByte monthString.[0]
let m2 = stringNumberToByte monthString.[1]
let d1 = stringNumberToByte dayString.[0]
let d2 = stringNumberToByte dayString.[1]
let h1 = stringNumberToByte hourString.[0]
let h2 = stringNumberToByte hourString.[1]
let min1 = stringNumberToByte minuteString.[0]
let min2 = stringNumberToByte minuteString.[1]
let s1 = stringNumberToByte secondsString.[0]
let s2 = stringNumberToByte secondsString.[1]
[| y1 ; y2 ; y3 ; y4 ; m1 ; m2 ; d1 ; d2 ; h1 ; h2 ; min1 ; min2 ; s1; s2 |]
//Sets the high bit of a byte to 1
member private this.setHigh (b : byte) : byte =
let array = new BitArray([| b |])
array.[7] <- true
let mutable converted = [| 0 |]
array.CopyTo(converted, 0);
(byte)converted.[0]
//Build the header of a Message based on Intro + Data
member private this.buildHeader (intro : MessageIntro) (data : byte[]) =
let headerLength = 7;
let introLength = 7;
let length = (uint16)(headerLength + introLength + data.Length)
let crcData = ByteArrayExtender.Concat(intro.GetRawData(),data)
let crcValue = ByteArrayExtender.CalculateCRC16(crcData)
let lengthBytes = UShortExtender.ToIntelOrderedByteArray(length);
let crcValueBytes = UShortExtender.ToIntelOrderedByteArray(crcValue);
let headerChecksum = (byte)(SYNC_BYTE ^^^ lengthBytes.[0] ^^^ lengthBytes.[1] ^^^ crcValueBytes.[0] ^^^ crcValueBytes.[1])
let header = new MessageHeader();
header.Sync <- SYNC_BYTE
header.Length <- length
header.HeaderChecksum <- headerChecksum
header.DataChecksum <- crcValue
header
member private this.getStatusBytes =
let l = controller.Status
let status = (uint16)controller.Status
let statusBytes = BitConverter.GetBytes(status);
statusBytes |> Array.rev
end
(실제 소스에서 클래스는 "하드웨어"와 더 구체적으로 이름이 다릅니다).
제안, 코드를 개선하는 방법 또는 문제를 처리하는 다양한 방법을 바라고 있습니다. 예를 들어, Ironpython과 같은 역동적 인 언어를 사용하면 일을 더 쉽게 만들 수 있습니다. 이와 같은 문제에 대한 당신의 경험, 당신이 무엇을 바꾸고, 피하는 것 등 ....
업데이트:
Brian의 답변을 바탕으로 다음을 작성했습니다.
type DrCode9Item = {Name : string ; Timestamp : DateTime ; Size : uint32; Status : byte}
type DrCode11Item = {Id : byte ; X : uint16 ; Y : uint16 ; SizeX : uint16 ; SizeY : uint16
Font : string ; Alignment : byte ; Scroll : byte ; Flash : byte}
type DrCode12Item = {Id : byte ; X : uint16 ; Y : uint16 ; SizeX : uint16 ; SizeY : uint16}
type DrCode14Item = {X : byte ; Y : byte}
type DRType =
| DrCode0 of byte
| DrCode1 of byte * string * DateTime * uint32 * byte
| DrCode2 of byte * byte * uint16 * uint16 * array<byte>
| DrCode3 of byte * string
| DrCode4 of byte * string * DateTime * byte * uint16 * array<byte>
| DrCode5 of byte * uint16
| DrCode6 of byte * DateTime
| DrCode7 of byte * uint16 * uint16
| DrCode8 of byte * uint16 * uint16 * uint16 * array<byte>
| DrCode9 of byte * uint16 * array<DrCode9Item>
| DrCode10 of byte * string * DateTime * uint32 * byte * array<byte>
| DrCode11 of byte * array<DrCode11Item>
| DrCode12 of byte * array<DrCode12Item>
| DrCode13 of byte * uint16 * byte * uint16 * uint16 * string * byte * byte
| DrCode14 of byte * array<DrCode14Item>
나는 모든 DR 유형 (꽤 많은)에 대해 이것을 계속할 수 있었지만 여전히 그것이 어떻게 도움이 될지 이해하지 못합니다. 나는 Wikibooks와 F#의 기초에서 그것에 대해 읽었지만 아직 내 머리를 클릭하지 않습니다.
업데이트 2
그래서 나는 다음을 수행 할 수 있다는 것을 이해합니다.
let execute dr =
match dr with
| DrCode0(drCode) -> printfn "Do something"
| DrCode1(drCode, name, timestamp, size, options) -> printfn "Show the size %A" size
| _ -> ()
let date = DateTime.Now
let x = DrCode1(1uy,"blabla", date, 100ul, 0uy)
그러나 메시지가 iMessageProcessor에 들어 오면 선택이 어떤 메시지인지 바로 여기에 만들어지고 적절한 기능이 호출됩니다. 위의 것은 추가 코드 일 뿐이며 적어도 그것이 이해하는 방법이므로 여기서 요점을 놓치고 있어야합니다. 그러나 나는 그것을 보지 못합니다.
execute x
해결책
나는 F#이 차별화 된 노조를 통해이 영역의 메시지를 표현하는 데 자연스럽게 적합하다고 생각합니다. 나는 상상하고있다
type Message =
| Message1 of string * DateTime * int * byte //name,timestamp,size,options
| Message2 of bool * short * short * byte[] //last,blocknum,blocksize,data
...
/to a byte 배열에서 메시지를 구문 분석/무시하는 메소드와 함께. 당신이 말했듯이,이 작품은 간단하고 지루합니다.
나는 메시지의 처리에 대해 명확하지 않지만 전체 메시지를 기반으로 한 메시지를 기반으로 손잡이가있는 것처럼 들립니다.
나는 당신의 '도구 유연성'에 대해 조금 걱정하고 있습니다 - 당신의 제약은 무엇입니까? (예 : .NET, Technologies X, Y, Z를 알고있는 프로그래머는 특정 기준을 충족해야합니다 ...)
다른 팁
여기 내 2 센트가 있습니다 (경고 : F#알지 못합니다) : 완전한 문법이 있어도 정밀하게 지정된 입력 파일이 있습니다. 파일의 내용을 조치에 매핑하려고합니다. 따라서 파일을 구문 분석하는 것이 좋습니다. F# 기능적 언어이기 때문에 파싱 기술에 맞을 수 있습니다. 재귀 하강 구문 분석. "Expert F#"책 재귀 하강 구문 분석에 대한 토론이 포함되어 있습니다.
제휴하지 않습니다 StackOverflow
